Vai al contenuto

Come convertire COCO nel YOLO

Formazione Ultralytics YOLO richiedono annotazioni in YOLO , ma molti strumenti di annotazione diffusi esportano invece in formato COCO . Questa guida illustra come convertire COCO in YOLO e avviare l'addestramento di modelli di rilevamento di oggetti, segmentazione di istanze e stima della posa.

Perché passare da COCO YOLO?

Il formato COCO memorizza tutte le annotazioni in un unico file, mentre YOLO utilizza un file di testo per ogni immagine con coordinate normalizzate. La conversione è necessaria perché:

  • YOLO richiedono .txt file di etichette con un file per ogni immagine, contenente class x_center y_center width height in coordinate normalizzate.
  • COCO utilizza le coordinate dei pixel in [x_min, y_min, width, height] formato con un unico file JSON per tutte le immagini.
  • Gli ID delle classi sono diversi — COCO valori arbitrari category_id valori, mentre YOLO ID di classe con indicizzazione a partire da zero.
FunzionalitàCOCOYOLO
StrutturaUn unico file JSON per tutte le immaginiUno .txt file per immagine
Formato Bbox[x_min, y_min, width, height] in pixelclass x_center y_center width height normalizzato (0-1)
ID classecategory_id (può iniziare da qualsiasi numero)Con indicizzazione a partire da zero (inizia da 0)
SegmentazioneMatrici di poligoni in segmentation campoCoordinate poligonali in base all'ID della classe
Punti chiave[x, y, visibility, ...] in pixel[x, y, visibility, ...] normalizzato

Guida rapida

Il modo più veloce per convertire COCO e iniziare l'addestramento:

from ultralytics.data.converter import convert_coco

convert_coco(
    labels_dir="path/to/annotations/",  # directory containing your JSON files
    save_dir="path/to/output/",  # where to save converted labels
    cls91to80=False,  # IMPORTANT: set False for custom datasets
)

Una volta completata la conversione, organizza la struttura delle directory, crea un file dataset.yaml e avvia l'addestramento. Consulta la guida dettagliata passo dopo passo qui sotto.

Set di dati personalizzati: utilizzare sempre cls91to80=False

Il cls91to80=True L'impostazione predefinita è stata progettata solo per lo standard Dataset COCO con 80 classi di oggetti, che associa 91 ID di categoria non contigui a 80 ID di classe contigui. Per qualsiasi set di dati personalizzato, è possibile deve insieme cls91to80=False — altrimenti gli ID delle classi verranno mappati in modo errato senza che te ne accorga e il tuo modello imparerà classi sbagliate.

Guida dettagliata alla conversione

1. Prepara il tuo Dataset COCO

Un tipico set di dati COCO esportato da strumenti di annotazione presenta la seguente struttura:

my_dataset/
├── images/
│   ├── train/
│   │   ├── img_001.jpg
│   │   ├── img_002.jpg
│   │   └── ...
│   └── val/
│       ├── img_100.jpg
│       └── ...
└── annotations/
    ├── instances_train.json
    └── instances_val.json

Ogni file JSON segue lo schema Formato COCO scheda tecnica con tre campi obbligatori — images, annotations, e categories:

{
    "images": [{ "id": 1, "file_name": "img_001.jpg", "width": 640, "height": 480 }],
    "annotations": [
        {
            "id": 1,
            "image_id": 1,
            "category_id": 1,
            "bbox": [100, 50, 200, 150],
            "area": 30000,
            "iscrowd": 0
        }
    ],
    "categories": [
        { "id": 1, "name": "helmet" },
        { "id": 2, "name": "vest" }
    ]
}

2. Converti Annotazioni

Utilizzare il convert_coco() funzione per convertire le annotazioni COCO di COCO in YOLO .txt formato:

Converti YOLO COCO YOLO

from ultralytics.data.converter import convert_coco

convert_coco(
    labels_dir="my_dataset/annotations/",
    save_dir="my_dataset/converted/",
    cls91to80=False,
)

from ultralytics.data.converter import convert_coco

convert_coco(
    labels_dir="my_dataset/annotations/",
    save_dir="my_dataset/converted/",
    use_segments=True,
    cls91to80=False,
)

from ultralytics.data.converter import convert_coco

convert_coco(
    labels_dir="my_dataset/annotations/",
    save_dir="my_dataset/converted/",
    use_keypoints=True,
    cls91to80=False,
)

3. Organizzare la Struttura delle Directory

Dopo la conversione, i file delle etichette devono essere salvati nella stessa cartella delle immagini. YOLO un labels/ directory che rispecchia la images/ directory:

import shutil
from pathlib import Path

# Paths
converted_dir = Path("my_dataset/converted/labels")
dataset_dir = Path("my_dataset")

# Move labels next to images for each split
for split in ["train", "val"]:
    src = converted_dir / split  # convert_coco strips "instances_" prefix from JSON filename
    dst = dataset_dir / "labels" / split
    dst.mkdir(parents=True, exist_ok=True)
    for f in src.glob("*.txt"):
        shutil.move(str(f), str(dst / f.name))

La struttura finale del tuo set di dati dovrebbe essere la seguente:

my_dataset/
├── images/
│   ├── train/
│   │   ├── img_001.jpg
│   │   └── ...
│   └── val/
│       └── ...
├── labels/
│   ├── train/
│   │   ├── img_001.txt
│   │   └── ...
│   └── val/
│       └── ...
└── dataset.yaml

4. Creare dataset.yaml

Crea un dataset.yaml file di configurazione che associa COCO ai nomi YOLO . Questo file indica YOLO si trovano i dati e quali classi detect:

import json
from pathlib import Path

import yaml

# Read categories from your COCO JSON
with open("my_dataset/annotations/instances_train.json") as f:
    coco = json.load(f)

# Build class names matching convert_coco output (category_id - 1)
categories = sorted(coco["categories"], key=lambda x: x["id"])
names = {cat["id"] - 1: cat["name"] for cat in categories}
# NOTE: convert_coco maps class IDs as category_id - 1, so category_id must
# start from 1. If your categories start from 0, add 1 to each ID first.

# Create dataset.yaml
dataset = {
    "path": str(Path("my_dataset").resolve()),
    "train": "images/train",
    "val": "images/val",
    "names": names,
}

with open("my_dataset/dataset.yaml", "w") as f:
    yaml.dump(dataset, f, default_flow_style=False)

Il file YAML risultante:

path: /absolute/path/to/my_dataset
train: images/train
val: images/val
names:
    0: helmet
    1: vest

Per ulteriori dettagli sul formato YAML dei set di dati, consultare la guida alla configurazione dei set di dati.

5. Addestra il tuo modello YOLO

Una volta preparato il set di dati convertito, addestra un YOLO :

Allenamento su COCO convertiti

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # load a pretrained model
results = model.train(data="my_dataset/dataset.yaml", epochs=100, imgsz=640)

yolo detect train model=yolo26n.pt data=my_dataset/dataset.yaml epochs=100 imgsz=640

Per suggerimenti e best practice sull'addestramento, consultare la guida all'addestramento dei modelli.

6. Verifica la tua conversione

Prima di iniziare l'addestramento, controlla a campione alcuni file di etichette per verificare che gli ID delle classi e le coordinate siano corretti:

from pathlib import Path

label_file = Path("my_dataset/labels/train/img_001.txt")
for line in label_file.read_text().strip().splitlines():
    parts = line.split()
    cls_id = int(parts[0])
    coords = [float(v) for v in parts[1:5]]
    assert cls_id >= 0, f"Negative class ID {cls_id} — category_id in your JSON may start from 0"
    assert all(0 <= v <= 1 for v in coords), f"Coordinates out of [0, 1] range: {coords}"

Suggerimento

Se noti degli ID di classe negativi, è probabile che COCO tuo COCO utilizzi category_id a partire da 0. Aggiungi 1 a tutti category_id valori nel tuo JSON prima dell'esecuzione convert_coco(), poiché mappa gli ID di classe come category_id - 1.

Risoluzione dei problemi più comuni

ID classe errati dopo la conversione

Se il tuo modello funziona ma rileva classi di oggetti errate, probabilmente stai usando cls91to80=True (predefinito) su un dataset personalizzato. Questo mappa il tuo category_id valori tramite la tabella di conversione COCO , che è corretta solo per lo standard Dataset COCO.

Soluzione: Utilizzare sempre cls91to80=False per set di dati personalizzati.

Non sono stati rilevati etichette durante l'addestramento

Se i corsi di formazione dimostrano WARNING: No labels found oppure 0 images, N backgrounds, i tuoi file di etichette non si trovano nella directory prevista. convert_coco() salva le etichette in una directory di output separata (ad es., save_dir/labels/train/), ma YOLO si aspetta labels/ parallelamente a images/ all'interno della directory del tuo set di dati.

Soluzione: Spostare i file delle etichette in modo che corrispondano al formato atteso struttura delle directory. Assicurarsi labels/train/ è un fratello o una sorella di images/train/.

Errore KeyError durante la conversione

Se ottieni KeyError: 'bbox' o errori simili durante l'esecuzione convert_coco(), il tuo labels_dir probabilmente contiene file JSON non legati a un'istanza (ad es., captions_train2017.json) che hanno una struttura di annotazione diversa.

Soluzione: Inserire solo i file JSON di annotazione delle istanze (ad es., instances_train2017.json) nel labels_dir.

File di etichette vuoti dopo la conversione

Se la conversione viene completata ma .txt se i file sono vuoti o mancanti, tutte le annotazioni potrebbero iscrowd: 1 (comune con SAM-maschere generate), o bounding box avere larghezza o altezza pari a zero.

Soluzione: Ispeziona le tue annotazioni JSON per iscrowd valori. Se si utilizzano SAM , pre-elaborare il JSON per impostare iscrowd: 0.

Differenze nell'ID classe nelle etichette convertite

Se gli ID delle classi nei file di etichette non sono contigui (ad esempio, 0, 4, 9 invece di 0, 1, 2), il tuo strumento di annotazione utilizza ID non contigui category_id valori.

Soluzione: Verificare gli ID delle classi nel proprio .txt i file corrispondono al names dizionario in dataset.yaml. Rimappare gli ID a valori contigui se necessario.

Per informazioni complete sull'API e la descrizione dei parametri, consultare il convert_coco Riferimento API.

FAQ

Come posso convertire le annotazioni COCO nel YOLO ?

Utilizzare il convert_coco() funzione di Ultralytics convertire le annotazioni COCO in YOLO .txt formato. Imposta cls91to80=False per i set di dati personalizzati:

from ultralytics.data.converter import convert_coco

convert_coco(labels_dir="path/to/annotations/", save_dir="output/", cls91to80=False)

Dopo la conversione, riorganizza i tuoi file di etichette in modo che labels/ riflette il images/ directory, quindi creare un dataset.yaml file. Vedi il guida passo dopo passo per il flusso di lavoro completo.

Perché YOLO mostra il messaggio "Nessuna etichetta trovata" dopo COCO ?

Questo accade perché convert_coco() salva le etichette in una sottodirectory all'interno di save_dir/labels/ (ad esempio, save_dir/labels/train/) piuttosto che direttamente nel tuo dataset labels/train/ insieme a images/train/. YOLO si aspetta che le etichette siano parallele alle immagini — ad esempio, images/train/img.jpg esigenze labels/train/img.txt. Spostare le etichette convertite per corrispondere a questa struttura. Vedere definizione della struttura delle directory.

Cosa significa cls91to80 fare in convert_coco()?

Il cls91to80 Il parametro controlla come COCO category_id i valori vengono associati agli ID YOLO . Quando True (predefinito), utilizza una tabella di lookup progettata per lo standard Dataset COCO, che ha 80 classi con ID non contigui (1-90). Per set di dati personalizzati, impostare sempre cls91to80=False — questo sottrae semplicemente 1 da ciascuno category_id per creare ID di classe con indicizzazione a zero.

Posso addestrare YOLO sui dati COCO senza convertirli?

Non con l'attuale pipeline YOLO : le annotazioni devono essere in YOLO .txt formato con un file per ogni immagine. Utilizza convert_coco() Converti prima il tuo file COCO , poi segui queste istruzioni guida per organizzare e formare. Per ulteriori informazioni sui formati supportati, consultare formati dei set di dati.

È possibile convertire le annotazioni COCO nel YOLO ?

Sì, usa use_segments=True quando si chiama convert_coco() per includere le maschere di segmentazione dei poligoni nelle YOLO convertite. Ciò produce file di etichette compatibili con Modelli YOLO:

from ultralytics.data.converter import convert_coco

convert_coco(labels_dir="annotations/", save_dir="output/", use_segments=True, cls91to80=False)

Come posso convertire le annotazioni COCO nel YOLO ?

Usa use_keypoints=True per convertire le annotazioni COCO per stima della posa formazione:

from ultralytics.data.converter import convert_coco

convert_coco(labels_dir="annotations/", save_dir="output/", use_keypoints=True, cls91to80=False)

Si noti che se entrambi use_segments e use_keypoints sono impostati su True, solo i keypoint verranno scritti nei file di etichette — i segment vengono ignorati silenziosamente.



📅 Creato 6 giorni fa ✏️ Aggiornato 6 giorni fa
dependabotraimbekovm

Commenti