Tutorial Lengkap FiftyOne by Voxel51: Tool Open-Source untuk Dataset dan Model Computer Vision
Penulis: Ruby Abdullah Tanggal: 9 September 2026Pendahuluan
Dalam dunia computer vision, kualitas dataset adalah fondasi utama yang menentukan performa model. Sayangnya, banyak praktisi AI/ML yang menghabiskan waktu berminggu-minggu untuk melatih model, namun mengabaikan proses kurasi dataset. Masalah seperti label yang salah, data duplikat, distribusi kelas yang tidak seimbang, dan sampel berkualitas rendah sering kali menjadi penyebab utama model yang underperforming.
FiftyOne, dikembangkan oleh Voxel51, hadir sebagai solusi open-source yang dirancang khusus untuk mengatasi tantangan-tantangan tersebut. FiftyOne adalah toolkit yang memungkinkan Anda memuat, memvisualisasikan, menganalisis, dan mengkurasi dataset computer vision secara efisien. Tool ini mendukung berbagai format dataset populer, terintegrasi dengan framework seperti PyTorch, TensorFlow, dan Hugging Face, serta menyediakan antarmuka visual interaktif yang sangat membantu dalam proses eksplorasi data.
Beberapa fitur utama FiftyOne yang akan kita bahas dalam tutorial ini:
- Dataset Loading & Management: Memuat dataset dari berbagai sumber dan format
- Visualisasi Interaktif: Menjelajahi dataset melalui antarmuka web yang intuitif
- Evaluasi Model: Menganalisis prediksi model secara mendalam
- Deteksi Error Anotasi: Menemukan label yang salah secara otomatis
- Dataset Curation: Mengkurasi dataset menggunakan embeddings dan similarity search
- Integrasi Framework: Bekerja seamless dengan PyTorch, TensorFlow, dan Hugging Face
Tutorial ini ditulis untuk praktisi AI/ML yang ingin meningkatkan kualitas dataset dan workflow computer vision mereka. Setiap bagian dilengkapi dengan contoh kode yang bisa langsung dijalankan.
Instalasi
Instalasi Dasar
FiftyOne dapat diinstal menggunakan pip. Pastikan Anda menggunakan Python 3.8 atau lebih baru.
pip install fiftyone
Untuk instalasi lengkap dengan semua dependensi opsional:
pip install fiftyone[all]
Instalasi dengan Virtual Environment
Disarankan menggunakan virtual environment untuk menghindari konflik dependensi:
python -m venv fiftyone-env
source fiftyone-env/bin/activate # Linux/Mac
atau
fiftyone-env\Scripts\activate # Windows
pip install fiftyone
Instalasi Dependensi Tambahan
Jika Anda berencana menggunakan FiftyOne dengan framework tertentu, instal dependensi tambahan:
# Untuk integrasi PyTorch
pip install torch torchvision
Untuk integrasi TensorFlow
pip install tensorflow
Untuk integrasi Hugging Face
pip install transformers datasets
Untuk fitur embedding dan similarity
pip install umap-learn scikit-learn
Verifikasi Instalasi
Setelah instalasi selesai, verifikasi dengan menjalankan perintah berikut:
import fiftyone as fo
print(fo.version)
Test memuat dataset bawaan
dataset = fo.zoo.loadzoodataset("quickstart", maxsamples=10)
print(f"Dataset berhasil dimuat: {len(dataset)} sampel")
Jika tidak ada error, instalasi Anda berhasil. FiftyOne juga menyediakan CLI yang berguna:
# Cek versi
fiftyone --version
Lihat dataset yang tersedia di zoo
fiftyone zoo datasets list
Jalankan FiftyOne App
fiftyone app launch
Basic Usage
Membuat Dataset dari Scratch
Mari mulai dengan membuat dataset sederhana secara manual:
import fiftyone as fo
Membuat dataset kosong
dataset = fo.Dataset("dataset-pertama-saya")
Menambahkan sampel satu per satu
sample = fo.Sample(filepath="/path/to/gambar1.jpg")
sample["groundtruth"] = fo.Classification(label="kucing")
sample["confidencescore"] = 0.95
dataset.addsample(sample)
Menambahkan beberapa sampel sekaligus
samples = []
for i in range(5):
s = fo.Sample(filepath=f"/path/to/gambar{i}.jpg")
s["groundtruth"] = fo.Classification(label="anjing")
samples.append(s)
dataset.addsamples(samples)
print(f"Total sampel: {len(dataset)}")
print(dataset)
Memuat Dataset dari Zoo
FiftyOne menyediakan FiftyOne Dataset Zoo yang berisi puluhan dataset populer yang siap digunakan:
import fiftyone as fo
import fiftyone.zoo as foz
Memuat dataset COCO (subset)
dataset = foz.loadzoodataset(
"coco-2017",
split="validation",
maxsamples=200,
labeltypes=["detections"],
)
print(f"Dataset: {dataset.name}")
print(f"Jumlah sampel: {len(dataset)}")
print(f"Tags media: {dataset.mediatype}")
Lihat skema dataset
print(dataset.getfieldschema())
Lihat sampel pertama
sample = dataset.first()
print(sample)
print(f"Jumlah deteksi: {len(sample.groundtruth.detections)}")
Memuat Dataset dari Direktori Lokal
Untuk memuat dataset dari file lokal dengan berbagai format:
import fiftyone as fo
Format: direktori gambar dengan label di subfolder
dataset = fo.Dataset.fromdir(
datasetdir="/path/to/dataset",
datasettype=fo.types.ImageClassificationDirectoryTree,
name="dataset-klasifikasi-lokal",
)
Format COCO
datasetcoco = fo.Dataset.fromdir(
datasettype=fo.types.COCODetectionDataset,
datapath="/path/to/images",
labelspath="/path/to/annotations.json",
name="dataset-coco-lokal",
)
Format YOLO
datasetyolo = fo.Dataset.fromdir(
datasettype=fo.types.YOLOv5Dataset,
datasetdir="/path/to/yolo-dataset",
name="dataset-yolo-lokal",
)
Format VOC (Pascal VOC)
datasetvoc = fo.Dataset.fromdir(
datasettype=fo.types.VOCDetectionDataset,
datapath="/path/to/images",
labelspath="/path/to/annotations",
name="dataset-voc-lokal",
)
Visualisasi dengan FiftyOne App
Salah satu fitur paling powerful dari FiftyOne adalah antarmuka visualisasi interaktifnya:
import fiftyone as fo
import fiftyone.zoo as foz
Muat dataset
dataset = foz.loadzoodataset("quickstart", maxsamples=100)
Luncurkan FiftyOne App di browser
session = fo.launchapp(dataset)
App akan terbuka di browser pada http://localhost:5151
Anda bisa menjelajahi gambar, label, dan metadata secara interaktif
Di dalam FiftyOne App, Anda dapat:
- Menelusuri gambar satu per satu atau dalam grid
- Memfilter sampel berdasarkan label, tag, atau field tertentu
- Melihat bounding box, segmentation mask, dan anotasi lainnya
- Menandai sampel yang perlu direview
Filtering dan Querying Dataset
FiftyOne menyediakan API yang kuat untuk memfilter dan melakukan query pada dataset:
import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F
dataset = foz.loadzoodataset("quickstart", maxsamples=200)
Filter berdasarkan label tertentu
viewkucing = dataset.filterlabels(
"groundtruth",
F("label") == "cat"
)
print(f"Sampel dengan label 'cat': {len(viewkucing)}")
Filter berdasarkan confidence score
viewhighconf = dataset.filterlabels(
"predictions",
F("confidence") > 0.8
)
Mengurutkan berdasarkan field tertentu
viewsorted = dataset.sortby("metadata.sizebytes", reverse=True)
Mengambil sampel random
viewrandom = dataset.take(20, seed=42)
Menghitung statistik
counts = dataset.countvalues("groundtruth.detections.label")
print("Distribusi label:")
for label, count in sorted(counts.items(), key=lambda x: x[1], reverse=True):
print(f" {label}: {count}")
Menggabungkan beberapa filter
viewcomplex = (
dataset
.match(F("metadata.sizebytes") > 50000)
.filterlabels("groundtruth", F("label").isin(["cat", "dog"]))
.limit(50)
)
print(f"Hasil filter kompleks: {len(viewcomplex)} sampel")
Menambahkan Tag dan Metadata
import fiftyone as fo
dataset = fo.Dataset("contoh-tagging")
Menambahkan tag ke sampel
for sample in dataset:
if somecondition(sample):
sample.tags.append("review-needed")
sample.save()
Menambahkan custom field
for sample in dataset:
sample["qualityscore"] = computequality(sample)
sample["source"] = "batch-september-2026"
sample.save()
Tag seluruh dataset
dataset.tagsamples("validated")
Advanced Usage
Evaluasi Model Predictions
FiftyOne sangat powerful untuk mengevaluasi prediksi model. Berikut cara mengevaluasi model object detection:
import fiftyone as fo
import fiftyone.zoo as foz
Muat dataset dengan ground truth dan predictions
dataset = foz.loadzoodataset("quickstart", maxsamples=200)
Evaluasi deteksi menggunakan COCO-style mAP
results = dataset.evaluatedetections(
"predictions", # field yang berisi prediksi
gtfield="groundtruth", # field yang berisi ground truth
evalkey="eval", # key untuk menyimpan hasil evaluasi
computemAP=True,
)
Lihat hasil evaluasi
print(f"mAP: {results.mAP():.4f}")
print(f"mAP@50: {results.mAP(iou=0.5):.4f}")
print(f"mAP@75: {results.mAP(iou=0.75):.4f}")
Lihat performa per kelas
results.printreport()
Confusion matrix
plot = results.plotconfusionmatrix(backend="matplotlib")
plot.show()
Lihat True Positives, False Positives, dan False Negatives
True Positives
tpview = dataset.filterlabels("predictions", F("eval") == "tp")
False Positives (prediksi salah)
fpview = dataset.filterlabels("predictions", F("eval") == "fp")
False Negatives (yang terlewat)
fnview = dataset.filterlabels("groundtruth", F("eval") == "fn")
print(f"True Positives: {tpview.count('predictions.detections')}")
print(f"False Positives: {fpview.count('predictions.detections')}")
print(f"False Negatives: {fnview.count('groundtruth.detections')}")
Visualisasikan error
session = fo.launchapp(fpview)
Evaluasi Model Klasifikasi
import fiftyone as fo
import fiftyone.zoo as foz
Muat dataset klasifikasi
dataset = foz.loadzoodataset(
"imagenet-sample",
maxsamples=500,
)
Jalankan model zoo untuk prediksi
model = foz.loadzoomodel("resnet50-imagenet-torch")
dataset.applymodel(model, labelfield="predictions")
Evaluasi klasifikasi
results = dataset.evaluateclassifications(
"predictions",
gtfield="groundtruth",
evalkey="evalcls",
)
Metrik evaluasi
print(f"Accuracy: {results.metrics()['accuracy']:.4f}")
print(f"Precision (macro): {results.metrics()['precision']:.4f}")
print(f"Recall (macro): {results.metrics()['recall']:.4f}")
Lihat sampel yang salah diprediksi
mistakes = dataset.match(F("evalcls") == False)
print(f"Jumlah kesalahan prediksi: {len(mistakes)}")
session = fo.launchapp(mistakes)
Menemukan Error Anotasi
Salah satu fitur paling berharga dari FiftyOne adalah kemampuannya untuk menemukan kesalahan anotasi secara otomatis. Ini menggunakan teknik yang disebut "label mistakes" yang memanfaatkan embeddings dan analisis outlier:
import fiftyone as fo
import fiftyone.zoo as foz
import fiftyone.brain as fob
Muat dataset
dataset = foz.loadzoodataset("quickstart", maxsamples=500)
Compute mistakenness score
Score tinggi = kemungkinan besar labelnya salah
fob.computemistakenness(
dataset,
"predictions",
labelfield="groundtruth",
)
Urutkan berdasarkan mistakenness (tertinggi dulu)
mistakeview = dataset.sortby("mistakenness", reverse=True)
Lihat 20 sampel yang paling mungkin salah label
topmistakes = mistakeview.limit(20)
print(f"Top 20 sampel dengan kemungkinan label error tertinggi:")
for sample in topmistakes:
print(f" File: {sample.filepath}")
print(f" Label: {sample.groundtruth.label if sample.groundtruth else 'N/A'}")
print(f" Mistakenness: {sample.mistakenness:.4f}")
print()
Visualisasikan di App
session = fo.launchapp(topmistakes)
Menemukan Duplikat
import fiftyone as fo
import fiftyone.zoo as foz
import fiftyone.brain as fob
dataset = foz.loadzoodataset("quickstart", maxsamples=500)
Hitung image uniqueness
Score rendah = kemungkinan duplikat atau sangat mirip
fob.computeuniqueness(dataset)
Lihat distribusi uniqueness
print(dataset.bounds("uniqueness"))
Temukan gambar yang paling mirip (potential duplicates)
dupview = dataset.sortby("uniqueness")
lowunique = dupview.match(F("uniqueness") < 0.3)
print(f"Potential duplicates: {len(lowunique)} sampel")
session = fo.launchapp(lowunique)
Dataset Curation dengan Embeddings
Embeddings memungkinkan Anda memahami struktur dataset dan melakukan kurasi berbasis similarity:
import fiftyone as fo
import fiftyone.zoo as foz
import fiftyone.brain as fob
dataset = foz.loadzoodataset("quickstart", maxsamples=500)
Compute embeddings menggunakan model pre-trained
model = foz.loadzoomodel("clip-vit-base32-torch")
dataset.applymodel(model, labelfield="clippredictions")
Compute embeddings untuk visualisasi
fob.computevisualization(
dataset,
model=model,
brainkey="imgviz",
)
Visualisasikan embeddings di FiftyOne App
session = fo.launchapp(dataset)
Di App, buka panel "Embeddings" untuk melihat visualisasi 2D
Similarity search
fob.computesimilarity(
dataset,
model=model,
brainkey="imgsim",
)
Cari gambar yang mirip dengan sampel tertentu
queryid = dataset.first().id
similarview = dataset.sortbysimilarity(queryid, k=10, brainkey="imgsim")
print(f"10 gambar paling mirip dengan sampel pertama:")
for sample in similarview:
print(f" {sample.filepath}")
Text-to-Image Search dengan CLIP
import fiftyone as fo
import fiftyone.zoo as foz
import fiftyone.brain as fob
dataset = foz.loadzoodataset("quickstart", maxsamples=500)
Load model CLIP
model = foz.loadzoomodel("clip-vit-base32-torch")
Compute similarity index
fob.computesimilarity(
dataset,
model=model,
brainkey="clipsim",
)
Search menggunakan teks
textquery = "a photo of a dog playing in the park"
textresults = dataset.sortbysimilarity(
textquery,
k=15,
brainkey="clipsim",
)
print(f"Hasil pencarian untuk: '{textquery}'")
print(f"Ditemukan {len(textresults)} gambar relevan")
session = fo.launchapp(textresults)
Hardness Analysis
FiftyOne juga bisa mengidentifikasi sampel yang "sulit" bagi model, yang berguna untuk active learning:
import fiftyone as fo
import fiftyone.zoo as foz
import fiftyone.brain as fob
dataset = foz.loadzoodataset("quickstart", maxsamples=500)
Compute hardness
Score tinggi = sampel sulit bagi model
fob.computehardness(dataset, "predictions")
Lihat sampel tersulit
hardview = dataset.sortby("hardness", reverse=True).limit(30)
print("30 sampel tersulit:")
for sample in hardview:
print(f" Hardness: {sample.hardness:.4f} - {sample.filepath}")
Sampel ini ideal untuk ditambahkan ke training set berikutnya (active learning)
session = fo.launchapp(hardview)
Integrasi dengan Framework Populer
Integrasi dengan PyTorch
import fiftyone as fo
import fiftyone.zoo as foz
import fiftyone.utils.torch as fout
import torch
import torchvision.transforms as T
from torch.utils.data import DataLoader
Muat dataset FiftyOne
dataset = foz.loadzoodataset(
"coco-2017",
split="validation",
maxsamples=100,
labeltypes=["detections"],
)
Konversi ke PyTorch Dataset
pytorchdataset = fout.TorchImageClassificationDataset(
dataset,
labelfield="groundtruth",
transform=T.Compose([
T.Resize((224, 224)),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
]),
)
Gunakan DataLoader PyTorch seperti biasa
dataloader = DataLoader(pytorchdataset, batchsize=16, shuffle=True)
for images, targets in dataloader:
print(f"Batch shape: {images.shape}")
break
Menambahkan prediksi model PyTorch ke dataset FiftyOne
model = foz.loadzoomodel("faster-rcnn-resnet50-fpn-coco-torch")
dataset.applymodel(model, labelfield="torchpredictions")
print("Prediksi PyTorch berhasil ditambahkan ke dataset")
Integrasi dengan TensorFlow
import fiftyone as fo
import fiftyone.zoo as foz
import fiftyone.utils.tf as fout
import tensorflow as tf
Muat dataset
dataset = foz.loadzoodataset(
"coco-2017",
split="validation",
maxsamples=100,
labeltypes=["detections"],
)
Konversi ke tf.data.Dataset
tfdataset = fout.TFImageClassificationDataset(
dataset,
labelfield="groundtruth",
imagesize=(224, 224),
)
Muat model TensorFlow dari Model Zoo
model = foz.loadzoomodel("ssd-mobilenet-v2-fpnlite-coco-tf2")
dataset.applymodel(model, labelfield="tfpredictions")
Evaluasi prediksi TensorFlow
results = dataset.evaluatedetections(
"tfpredictions",
gtfield="groundtruth",
evalkey="evaltf",
computemAP=True,
)
print(f"TensorFlow Model mAP: {results.mAP():.4f}")
Integrasi dengan Hugging Face
import fiftyone as fo
import fiftyone.zoo as foz
Muat dataset dari Hugging Face Hub
import fiftyone.utils.huggingface as fouh
Load dataset dari Hugging Face
dataset = fouh.loadfromhub(
"detection-datasets/coco",
maxsamples=200,
name="hf-coco-sample",
)
print(f"Dataset dari HF: {len(dataset)} sampel")
Gunakan model Hugging Face untuk prediksi
from transformers import pipeline
Object detection dengan model HF
detector = pipeline(
"object-detection",
model="facebook/detr-resnet-50",
)
Jalankan prediksi dan simpan ke FiftyOne
for sample in dataset.itersamples(progress=True):
imgpath = sample.filepath
results = detector(imgpath)
detections = []
for r in results:
# Konversi format HF ke format FiftyOne
box = r["box"]
# FiftyOne menggunakan format [x, y, width, height] relatif (0-1)
imgw, imgh = sample.metadata.width, sample.metadata.height
boundingbox = [
box["xmin"] / imgw,
box["ymin"] / imgh,
(box["xmax"] - box["xmin"]) / imgw,
(box["ymax"] - box["ymin"]) / imgh,
]
detections.append(
fo.Detection(
label=r["label"],
boundingbox=boundingbox,
confidence=r["score"],
)
)
sample["hfpredictions"] = fo.Detections(detections=detections)
sample.save()
print("Prediksi Hugging Face berhasil disimpan!")
session = fo.launchapp(dataset)
Export Dataset ke Berbagai Format
import fiftyone as fo
dataset = fo.loaddataset("my-dataset")
Export ke format COCO
dataset.export(
exportdir="/path/to/export/coco",
datasettype=fo.types.COCODetectionDataset,
labelfield="groundtruth",
)
Export ke format YOLO
dataset.export(
exportdir="/path/to/export/yolo",
datasettype=fo.types.YOLOv5Dataset,
labelfield="groundtruth",
)
Export ke format TFRecord
dataset.export(
exportdir="/path/to/export/tfrecord",
datasettype=fo.types.TFObjectDetectionDataset,
labelfield="groundtruth",
)
Export ke format Pascal VOC
dataset.export(
exportdir="/path/to/export/voc",
datasettype=fo.types.VOCDetectionDataset,
labelfield="groundtruth",
)
print("Dataset berhasil diekspor ke semua format!")
Best Practices
1. Selalu Mulai dengan Eksplorasi Data
Sebelum melatih model, luangkan waktu untuk benar-benar memahami dataset Anda. Gunakan FiftyOne App untuk menjelajahi data secara visual. Cari pola-pola seperti class imbalance, gambar berkualitas rendah, atau anotasi yang tidak konsisten.
import fiftyone as fo
from fiftyone import ViewField as F
dataset = fo.loaddataset("my-dataset")
Cek distribusi label
labelcounts = dataset.countvalues("groundtruth.detections.label")
print("Distribusi label:")
for label, count in sorted(labelcounts.items(), key=lambda x: x[1], reverse=True):
print(f" {label}: {count}")
Cek ukuran gambar
bounds = dataset.bounds("metadata.width")
print(f"Lebar gambar: {bounds[0]} - {bounds[1]} pixels")
Cek gambar yang terlalu kecil
smallimages = dataset.match(F("metadata.width") < 100)
print(f"Gambar terlalu kecil (<100px): {len(smallimages)}")
2. Gunakan Persistent Dataset
Untuk dataset besar, gunakan persistent dataset agar tidak perlu reload setiap kali:
import fiftyone as fo
Buat persistent dataset
dataset = fo.Dataset("project-deteksi-v2", persistent=True)
Nanti bisa dimuat kembali
dataset = fo.loaddataset("project-deteksi-v2")
3. Manfaatkan Views untuk Workflow yang Terorganisir
Gunakan views untuk membuat subset dataset tanpa menduplikasi data:
import fiftyone as fo
from fiftyone import ViewField as F
dataset = fo.loaddataset("my-dataset")
Buat saved views untuk berbagai keperluan
trainview = dataset.matchtags("train")
dataset.saveview("training-set", trainview)
View untuk sampel yang perlu direview
reviewview = dataset.match(F("mistakenness") > 0.8)
dataset.saveview("needs-review", reviewview)
View untuk sampel berkualitas tinggi
hqview = dataset.match(
(F("uniqueness") > 0.5) & (F("metadata.sizebytes") > 100000)
)
dataset.saveview("high-quality", hqview)
4. Iterative Model Development
Gunakan FiftyOne sebagai bagian dari siklus pengembangan model Anda:
import fiftyone as fo
import fiftyone.brain as fob
dataset = fo.loaddataset("my-dataset")
Iterasi 1: Evaluasi model baseline
resultsv1 = dataset.evaluatedetections(
"predictionsv1",
gtfield="groundtruth",
evalkey="evalv1",
computemAP=True,
)
print(f"Model v1 mAP: {resultsv1.mAP():.4f}")
Analisis error
fob.computemistakenness(dataset, "predictionsv1", labelfield="groundtruth")
fob.computehardness(dataset, "predictionsv1")
Identifikasi area improvement
hardsamples = dataset.sortby("hardness", reverse=True).limit(100)
Iterasi 2: Setelah perbaikan, evaluasi lagi
resultsv2 = dataset.evaluatedetections(
"predictionsv2",
gtfield="groundtruth",
evalkey="evalv2",
computemAP=True,
)
print(f"Model v2 mAP: {resultsv2.mAP():.4f}")
print(f"Improvement: {(resultsv2.mAP() - resultsv1.mAP()) * 100:.2f}%")
5. Dokumentasi dan Reprodusibilitas
Selalu simpan metadata tentang proses kurasi Anda:
import fiftyone as fo
from datetime import datetime
dataset = fo.loaddataset("my-dataset")
Tambahkan info dataset
dataset.info = {
"description": "Dataset deteksi objek untuk proyek X",
"version": "2.1",
"createdat": datetime.now().isoformat(),
"curator": "Ruby Abdullah",
"notes": "Dibersihkan dari duplikat dan label error",
"totalremovedduplicates": 45,
"totalfixedlabels": 23,
}
dataset.save()
6. Gunakan FiftyOne Brain untuk Analisis Otomatis
FiftyOne Brain menyediakan beberapa metode analisis otomatis yang sangat berguna:
import fiftyone as fo
import fiftyone.brain as fob
dataset = fo.loaddataset("my-dataset")
Jalankan semua analisis sekaligus
fob.computeuniqueness(dataset) # Temukan duplikat
fob.computehardness(dataset, "predictions") # Temukan sampel sulit
fob.computemistakenness( # Temukan label error
dataset,
"predictions",
labelfield="groundtruth",
)
Buat summary report
stats = {
"totalsamples": len(dataset),
"potentialduplicates": len(dataset.match(F("uniqueness") < 0.2)),
"hardsamples": len(dataset.match(F("hardness") > 0.8)),
"potentialmistakes": len(dataset.match(F("mistakenness") > 0.8)),
}
print("Dataset Quality Report:")
for key, value in stats.items():
print(f" {key}: {value}")
7. Penanganan Dataset Besar
Untuk dataset dengan jutaan gambar, gunakan teknik berikut:
import fiftyone as fo
Gunakan skip dan limit untuk pagination
dataset = fo.loaddataset("large-dataset")
Proses dalam batch
batchsize = 1000
for i in range(0, len(dataset), batchsize):
batch = dataset.skip(i).limit(batchsize)
# Proses batch
print(f"Processing batch {i // batchsize + 1}")
Gunakan selectfields untuk performa lebih baik
lightview = dataset.selectfields(["ground_truth", "metadata"])
Kesimpulan
FiftyOne adalah tool yang sangat berharga dalam ekosistem computer vision modern. Dengan FiftyOne, Anda dapat mengubah workflow pengembangan model dari yang sebelumnya berfokus hanya pada arsitektur model, menjadi workflow yang juga memberikan perhatian serius pada kualitas dataset.
Beberapa poin penting yang perlu diingat dari tutorial ini:
Sebagai langkah selanjutnya, saya menyarankan Anda untuk:
- Mulai dengan dataset kecil dan familiar untuk memahami workflow FiftyOne
- Jalankan FiftyOne Brain pada dataset proyek Anda yang sebenarnya untuk menemukan masalah tersembunyi
- Integrasikan FiftyOne ke dalam pipeline CI/CD Anda untuk monitoring kualitas data secara otomatis
- Eksplorasi FiftyOne Teams untuk kolaborasi tim yang lebih baik
Dengan menerapkan praktik-praktik yang dibahas dalam tutorial ini, Anda akan memiliki fondasi yang kuat untuk membangun dataset berkualitas tinggi dan model computer vision yang lebih andal. Kualitas dataset bukan sekadar langkah awal, melainkan proses berkelanjutan yang harus terus diperhatikan sepanjang siklus hidup proyek AI Anda.
Selamat mencoba FiftyOne, dan semoga tutorial ini membantu meningkatkan kualitas proyek computer vision Anda!