Tutorial Lengkap FiftyOne by Voxel51: Tool Open-Source untuk Dataset dan Model Computer Vision

# Tutorial Lengkap FiftyOne by Voxel51: Tool Open-Source untuk Dataset dan Model Computer Vision **Penulis: Ruby Abdullah** **Tanggal: 9 September 2026** ## Pendahuluan Dalam dunia computer vision,...

By Ruby Abdullah · · tutorial
FiftyOneComputer VisionDataset CurationModel EvaluationVoxel51

Tutorial Lengkap FiftyOne by Voxel51: Tool Open-Source untuk Dataset dan Model Computer Vision

Penulis: Ruby Abdullah Tanggal: 9 September 2026

Pendahuluan

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:

  • Kualitas data lebih penting dari arsitektur model. FiftyOne membantu Anda memastikan bahwa dataset Anda bersih, seimbang, dan representatif. Model yang sederhana dengan data berkualitas tinggi sering kali mengungguli model kompleks dengan data yang buruk.
  • Visualisasi adalah kunci. FiftyOne App memungkinkan Anda melihat data dan prediksi model secara visual, yang sering kali mengungkapkan masalah yang tidak terlihat dari metrik numerik saja. Jangan hanya mengandalkan angka mAP atau accuracy; lihat langsung di mana model Anda gagal.
  • Analisis error yang mendalam. Dengan fitur evaluasi FiftyOne, Anda dapat memahami persis di mana dan mengapa model gagal, apakah karena false positive, false negative, atau kategori tertentu yang performanya rendah.
  • Deteksi error anotasi. Fitur mistakenness dan uniqueness dari FiftyOne Brain dapat menghemat puluhan jam waktu review manual. Dalam pengalaman praktis, hampir setiap dataset memiliki persentase label yang salah, dan menemukan serta memperbaikinya secara signifikan meningkatkan performa model.
  • Integrasi yang mulus. FiftyOne bekerja dengan baik bersama PyTorch, TensorFlow, dan Hugging Face, sehingga Anda dapat mengintegrasikannya ke dalam workflow yang sudah ada tanpa perubahan besar.
  • Dataset curation berbasis embeddings. Kemampuan untuk melakukan similarity search dan visualisasi embeddings membuka kemungkinan baru dalam kurasi dataset, seperti menemukan cluster data yang underrepresented atau mengidentifikasi outlier.
  • 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!

    Artikel Terkait

    Tutorial Surya OCR: Document AI untuk Text Detection, OCR, dan Layout Analysis

    Tutorial Surya OCR: Document AI untuk Text Detection, OCR, dan Layout Analysis Surya adalah library Document AI open-sou...

    Florence-2: Model Vision Multi-Task dari Microsoft

    Florence-2: Model Vision Multi-Task dari Microsoft Daftar Isi Pendahuluan Prasyarat Instalasi Memuat Model Florence-2

    Supervision: Toolkit Computer Vision dari Roboflow

    Supervision: Toolkit Computer Vision dari Roboflow Dalam proyek computer vision, setelah model mendeteksi objek, Anda ma...

    Tutorial Albumentations: Advanced Image Augmentation untuk Computer Vision

    Albumentations - Augmentasi Gambar Tingkat Lanjut Daftar Isi Pendahuluan Prasyarat Instalasi dan Pengaturan [Memahami Pi...