Tutorial Lengkap Label Studio: Data Labeling untuk Machine Learning
Label Studio adalah platform data labeling open-source untuk machine learning. Platform ini mendukung labeling berbagai tipe data termasuk teks, gambar, audio, video, dan time series, menjadikannya essential untuk membangun dataset training ML berkualitas tinggi.
Mengapa Label Studio?
Keunggulan Label Studio:- Multi-modal: Label teks, gambar, audio, video, HTML
- Fleksibel: Interface labeling yang customizable
- Kolaboratif: Workflow anotasi berbasis tim
- Integrasi: ML backends, cloud storage, webhooks
- Open source: Self-hosted dengan opsi enterprise
- Anotasi NLP (NER, sentiment, classification)
- Computer vision labeling (bounding boxes, segmentation)
- Transkripsi dan klasifikasi audio
- Anotasi data multi-modal
- Workflow active learning
Instalasi
# Install dengan pip
pip install label-studio
Start Label Studio
label-studio start
Atau dengan Docker
docker run -it -p 8080:8080 \
-v $(pwd)/mydata:/label-studio/data \
heartexlabs/label-studio:latest
Akses di http://localhost:8080
Quick Start
1. Buat Project
from labelstudiosdk import Client
Koneksi ke Label Studio
ls = Client(url='http://localhost:8080', apikey='your-api-key')
Buat project
project = ls.startproject(
title='Analisis Sentimen',
labelconfig='''
'''
)
print(f"Project dibuat: {project.id}")
2. Import Data
# Import dari list
tasks = [
{"text": "Saya suka produk ini!"},
{"text": "Ini sangat buruk."},
{"text": "Biasa saja, tidak istimewa."}
]
project.importtasks(tasks)
Import dari file
project.importtasks('data.json')
Import dari URL
project.importtasks([
{"image": "https://example.com/image1.jpg"},
{"image": "https://example.com/image2.jpg"}
])
3. Export Anotasi
# Export semua anotasi
annotations = project.exporttasks()
Export dalam format spesifik
annotations = project.exporttasks(exporttype='JSON')
annotations = project.exporttasks(exporttype='CSV')
annotations = project.exporttasks(exporttype='COCO')
annotations = project.exporttasks(exporttype='YOLO')
Simpan ke file
import json
with open('annotations.json', 'w') as f:
json.dump(annotations, f)
Konfigurasi Label
1. Klasifikasi Teks
2. Named Entity Recognition
3. Klasifikasi Gambar
4. Object Detection (Bounding Boxes)
5. Image Segmentation
6. Transkripsi Audio
7. Klasifikasi Audio dengan Regions
8. Anotasi Video
Operasi SDK
1. Manajemen Project
from labelstudiosdk import Client
ls = Client(url='http://localhost:8080', api
key='your-api-key')
List semua projects
projects = ls.getprojects()
for p in projects:
print(f"{p.id}: {p.title}")
Get project spesifik
project = ls.getproject(projectid=1)
Update project
project.setparams(
title="Judul Baru",
description="Deskripsi baru"
)
Hapus project
project.delete()
2. Manajemen Task
# Get semua tasks
tasks = project.gettasks()
Get task spesifik
task = project.gettask(taskid=1)
Update task
project.updatetask(
taskid=1,
data={"text": "Teks diupdate"}
)
Hapus task
project.deletetask(taskid=1)
Get tasks dengan filter
from labelstudiosdk.datamanager import Filters, Column, Operator, Type
filters = Filters.create(Filters.AND, [
Filters.item(
Column.completedat,
Operator.EMPTY,
Type.Datetime,
Filters.value(True)
)
])
unlabeledtasks = project.gettasks(filters=filters)
3. Manajemen Anotasi
# Buat anotasi
annotation = project.createannotation(
taskid=1,
result=[
{
"fromname": "sentiment",
"toname": "text",
"type": "choices",
"value": {"choices": ["Positif"]}
}
]
)
Get anotasi untuk task
annotations = project.getannotations(taskid=1)
Hapus anotasi
project.deleteannotation(annotationid=1)
4. Upload Prediksi
# Upload prediksi untuk pre-labeling
predictions = [
{
"task": 1,
"result": [
{
"fromname": "sentiment",
"toname": "text",
"type": "choices",
"value": {"choices": ["Positif"]}
}
],
"score": 0.95
}
]
project.createpredictions(predictions)
Bulk prediction upload
modelpredictions = []
for task in project.gettasks():
pred = model.predict(task['data']['text'])
modelpredictions.append({
"task": task['id'],
"result": [{
"fromname": "sentiment",
"toname": "text",
"type": "choices",
"value": {"choices": [pred['label']]}
}],
"score": pred['confidence']
})
project.createpredictions(modelpredictions)
Integrasi Cloud Storage
1. Amazon S3
# Koneksikan S3 storage
storage = project.connects3importstorage(
bucket='my-bucket',
prefix='images/',
awsaccesskeyid='AKIAXXXXXXXX',
awssecretaccesskey='xxxxxxxxxx',
regionname='us-east-1',
recursivescan=True
)
Sync storage
storage.sync()
Export ke S3
exportstorage = project.connects3exportstorage(
bucket='my-bucket',
prefix='annotations/',
awsaccesskeyid='AKIAXXXXXXXX',
awssecretaccesskey='xxxxxxxxxx'
)
2. Google Cloud Storage
# Koneksikan GCS storage
storage = project.connectgoogleimportstorage(
bucket='my-bucket',
prefix='data/',
googleapplicationcredentials='path/to/credentials.json'
)
storage.sync()
3. Azure Blob Storage
# Koneksikan Azure storage
storage = project.connectazureimportstorage(
container='my-container',
prefix='images/',
accountname='myaccount',
accountkey='xxxxxxxxxx'
)
storage.sync()
Integrasi ML Backend
1. Buat ML Backend
# mlbackend.py
from label
studioml import LabelStudioMLBase
class SentimentModel(LabelStudioMLBase):
def init(self, kwargs):
super(SentimentModel, self).init(kwargs)
# Load model Anda
from transformers import pipeline
self.model = pipeline("sentiment-analysis")
def predict(self, tasks, kwargs):
predictions = []
for task in tasks:
text = task['data']['text']
result = self.model(text)[0]
label = "Positif" if result['label'] == 'POSITIVE' else "Negatif"
predictions.append({
'result': [{
'from
name': 'sentiment',
'toname': 'text',
'type': 'choices',
'value': {'choices': [label]}
}],
'score': result['score']
})
return predictions
def fit(self, annotations, kwargs):
# Train model dengan anotasi baru
pass
2. Jalankan ML Backend
# Install ML backend
pip install label-studio-ml
Initialize backend
label-studio-ml init mybackend --script mlbackend.py
Start backend
label-studio-ml start mybackend -p 9090
3. Koneksi ke Label Studio
# Tambahkan ML backend ke project
project.connectmlbackend(
url='http://localhost:9090',
title='Sentiment Model'
)
Trigger prediksi
project.startpredictions()
Active Learning
1. Setup Active Learning
from labelstudioml import LabelStudioMLBase
import numpy as np
class ActiveLearningModel(LabelStudioMLBase):
def predict(self, tasks, kwargs):
predictions = []
for task in tasks:
# Get prediksi model dengan uncertainty
pred, confidence = self.model.predict
withuncertainty(task['data'])
predictions.append({
'result': [{
'from
name': 'label',
'toname': 'text',
'type': 'choices',
'value': {'choices': [pred]}
}],
'score': confidence
})
return predictions
def gettaskstolabel(self, n=10):
# Get tasks diurutkan berdasarkan uncertainty
tasks = self.project.gettasks()
predictions = self.predict(tasks)
# Sort berdasarkan uncertainty (confidence terendah duluan)
sortedtasks = sorted(
zip(tasks, predictions),
key=lambda x: x[1]['score']
)
return [t[0] for t in sortedtasks[:n]]
2. Uncertainty Sampling
from labelstudiosdk import Client
ls = Client(url='http://localhost:8080', api
key='your-api-key')
project = ls.getproject(projectid=1)
Get tasks dengan prediction scores
tasks = project.gettasks()
Sort berdasarkan prediction score (uncertainty)
uncertaintasks = sorted(
[t for t in tasks if t.get('predictions')],
key=lambda t: min(p['score'] for p in t['predictions'])
)
Prioritaskan uncertain tasks
for task in uncertaintasks[:10]:
print(f"Task {task['id']}: Score {task['predictions'][0]['score']}")
Webhooks
1. Setup Webhooks
# Buat webhook
webhook = project.createwebhook(
url='https://my-server.com/webhook',
sendpayload=True,
sendforallactions=False,
actions=['ANNOTATIONCREATED', 'ANNOTATIONUPDATED']
)
Actions yang tersedia:
- ANNOTATIONCREATED
- ANNOTATIONUPDATED
- ANNOTATIONDELETED
- TASKCREATED
- PROJECTUPDATED
2. Handle Webhook
from flask import Flask, request
app = Flask(name)
@app.route('/webhook', methods=['POST'])
def handlewebhook():
data = request.json
action = data['action']
annotation = data.get('annotation')
task = data.get('task')
if action == 'ANNOTATIONCREATED':
# Trigger model retraining
print(f"Anotasi baru untuk task {task['id']}")
# retrainmodel(annotation)
return {'status': 'ok'}
if name == 'main':
app.run(port=5000)
Quality Control
1. Agreement Metrics
# Get agreement scores
agreements = project.getagreement()
for taskid, agreement in agreements.items():
print(f"Task {taskid}: {agreement['agreement']:.2%}")
2. Review Workflow
Best Practices
1. Import Data Efisien
import json
from labelstudiosdk import Client
ls = Client(url='http://localhost:8080', apikey='your-api-key')
project = ls.getproject(projectid=1)
Batch import untuk dataset besar
def batchimport(data, batchsize=1000):
for i in range(0, len(data), batchsize):
batch = data[i:i+batchsize]
project.importtasks(batch)
print(f"Imported {min(i+batchsize, len(data))}/{len(data)}")
Load dan import
with open('largedataset.json') as f:
data = json.load(f)
batchimport(data)
2. Processing Export
import pandas as pd
Export anotasi
annotations = project.exporttasks()
Proses untuk ML training
trainingdata = []
for task in annotations:
if task['annotations']:
annotation = task['annotations'][0]
for result in annotation['result']:
if result['type'] == 'choices':
trainingdata.append({
'text': task['data']['text'],
'label': result['value']['choices'][0]
})
df = pd.DataFrame(trainingdata)
df.tocsv('training_data.csv', index=False)
Kesimpulan
Label Studio adalah essential untuk data labeling ML dengan:
Key takeaways:
- Rancang interface labeling yang jelas
- Gunakan prediksi untuk efisiensi pre-labeling
- Implementasikan workflow quality control
- Manfaatkan webhooks untuk automation
- Batch operations untuk dataset besar