Padronanza dell’annotazione Integrazione senza soluzione di continuità di Detectron con LabelImg

Alto livello di conoscenza integrazione senza soluzione di continuità di Detectron con LabelImg

Introduzione

Contrassegnare l’immagine, o annotare la foto, nell’ambito dell’elaborazione delle immagini è stato una sfida. La nostra esplorazione approfondisce il lavoro di squadra tra LabelImg e Detectron, un potente duo che combina annotazioni precise con la creazione efficiente di modelli. LabelImg, che è facile da usare e preciso, eccelle nell’annotazione accurata, gettando una solida base per una chiara rilevazione degli oggetti.

Mentre esploriamo LabelImg e diventiamo bravi a disegnare bounding box, passiamo senza intoppi a Detectron. Questo robusto framework organizza i nostri dati marcati, rendendoli utili per addestrare modelli avanzati. LabelImg e Detectron insieme rendono la rilevazione degli oggetti facile per tutti, che tu sia un principiante o un esperto. Unisciti a noi, dove ogni immagine contrassegnata ci aiuta a sbloccare la piena potenza delle informazioni visive.

Obiettivi di apprendimento

• Iniziare con LabelImg.
• Preparazione dell’ambiente e installazione di LabelImg.
• Comprendere LabelImg e le sue funzionalità.
• Conversione dei dati VOC o Pascal in formato COCO per la rilevazione degli oggetti.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

• Svelando i misteri degli outlier delle serie temporali 2/4
• Che cos’è MLOps?
• Come il Bing Chat supera il ChatGPT nel fornire conoscenze in tempo reale aggiornate? Scopri Retrieval Augmented Generation (RAG)

Diagramma di flusso

Preparazione dell’ambiente

1. Creare un ambiente virtuale:

conda create -p ./venv python=3.8 -y

Questo comando crea un ambiente virtuale denominato “venv” utilizzando la versione 3.8 di Python.

2. Attivare l’ambiente virtuale: 

conda activate venv

Attiva l’ambiente virtuale per isolare l’installazione di LabelImg.

Installazione e utilizzo di LabelImg

1. Installare LabelImg:

pip install labelImg

Installa LabelImg all’interno dell’ambiente virtuale attivato.

2. Avviare LabelImg:

labelImg

Risoluzione dei problemi: se si verificano errori durante l’esecuzione dello script

Se si riscontrano errori durante l’esecuzione dello script, ho preparato un archivio zip contenente l’ambiente virtuale (venv) per la tua comodità.

1. Scarica l’archivio Zip:

• Scarica l’archivio venv.zip dal Link

2. Crea una cartella LabelImg:

• Crea una nuova cartella chiamata LabelImg sul tuo computer.

3. Estrai la cartella venv:

• Estrai il contenuto dell’archivio venv.zip nella cartella LabelImg.

4. Attiva l’ambiente virtuale:

• Apri il prompt dei comandi o il terminale.
• Naviga fino alla cartella LabelImg.
• Esegui il seguente comando per attivare l’ambiente virtuale:

conda activate ./venv

Questo processo garantisce di avere un ambiente virtuale preconfigurato pronto all’uso con LabelImg. L’archivio zip fornito racchiude le dipendenze necessarie, consentendo un’esperienza più fluida senza preoccuparsi di eventuali installazioni potenziali.

Ora procedi con i passaggi precedenti per l’installazione e l’utilizzo di LabelImg all’interno di questo ambiente virtuale attivato.

Flusso di annotazione con LabelImg

1. Annotazione delle immagini in formato PascalVOC:

• Costruisci e avvia LabelImg.
• Fai clic su ‘Cambia cartella di salvataggio predefinita’ nel menu/File.

• Fai clic su ‘Apri cartella’ per selezionare la directory delle immagini.

• Usa ‘Crea RectBox’ per annotare gli oggetti nell’immagine.

• Salva le annotazioni nella cartella specificata.

all’interno del .xml 

<annotation> <folder>train</folder>  <filename>0a8a68ee-f587-4dea-beec-79d02e7d3fa4___RS_Early.B 8461.JPG</filename> <path>/home/suyodhan/Documents/Blog /label/train/0a8a68ee-f587-4dea-beec-79d02e7d3fa4___RS_Early.B 8461.JPG</path>  <source>      <database>Sconosciuto</database>    </source> <size>        <width>256</width>      <height>256</height>        <depth>3</depth>    </size>   <segmented>0</segmented>    <object>      <name>Patata___Early_blight</name>      <pose>Non specificato</pose>        <truncated>0</truncated>        <difficult>0</difficult>        <bndbox>          <xmin>12</xmin>         <ymin>18</ymin>         <xmax>252</xmax>            <ymax>250</ymax>        </bndbox> </object></annotation>

Questa struttura XML segue il formato di annotazione Pascal VOC, comunemente utilizzato per i dataset di rilevamento degli oggetti. Questo formato fornisce una rappresentazione standardizzata dei dati annotati per addestrare modelli di visione artificiale. Se hai altre immagini con annotazioni, puoi continuare a generare file XML simili per ogni oggetto annotato nelle rispettive immagini.

Conversione delle annotazioni Pascal VOC nel formato COCO: uno script Python

I modelli di rilevamento degli oggetti spesso richiedono annotazioni in formati specifici per addestrare ed valutare in modo efficace. Mentre Pascal VOC è un formato ampiamente utilizzato, framework specifici come Detectron preferiscono le annotazioni COCO. Per colmare questa differenza, presentiamo uno script Python versatile, voc2coco.py, progettato per convertire senza soluzione di continuità le annotazioni Pascal VOC nel formato COCO.

#!/usr/bin/python# pip install lxmlimport sysimport osimport jsonimport xml.etree.ElementTree as ETimport globSTART_BOUNDING_BOX_ID = 1PRE_DEFINE_CATEGORIES = None# Se necessario, definisci in anticipo la categoria e il suo id#  PRE_DEFINE_CATEGORIES = {"aereo": 1, "bicicletta": 2, "uccello": 3, "barca": 4,#  "bottiglia":5, "bus": 6, "auto": 7, "gatto": 8, "sedia": 9,#  "mucca": 10, "tavolo": 11, "cane": 12, "cavallo": 13,#  "moto": 14, "persona": 15, "pianta in vaso": 16,#  "pecora": 17, "divano": 18, "treno": 19, "monitor TV": 20}def get(root, name):    vars = root.findall(name)    return varsdef get_and_check(root, name, length):    vars = root.findall(name)    if len(vars) == 0:        raise ValueError("Impossibile trovare %s in %s." % (name, root.tag))    if length > 0 and len(vars) != length:        raise ValueError(            "La dimensione di %s dovrebbe essere %d, ma è %d."            % (name, length, len(vars))        )    if length == 1:        vars = vars[0]    return varsdef get_filename_as_int(filename):    try:        filename = filename.replace("\\", "/")        filename = os.path.splitext(os.path.basename(filename))[0]        return str(filename)    except:        raise ValueError("Il nome del file %s dovrebbe essere un numero intero." % (filename))def get_categories(xml_files):    """Genera una mappatura di nome di categoria a id da una lista di file xml.        Argomenti:        xml_files {lista} -- Una lista di percorsi file xml.        Returns:        dict -- mappatura di nome di categoria a id.    """    classes_names = []    for xml_file in xml_files:        tree = ET.parse(xml_file)        root = tree.getroot()        for member in root.findall("object"):            classes_names.append(member[0].text)    classes_names = list(set(classes_names))    classes_names.sort()    return {name: i for i, name in enumerate(classes_names)}def convert(xml_files, json_file):    json_dict = {"images": [], "type": "instances", "annotations": [], "categories": []}    if PRE_DEFINE_CATEGORIES is not None:        categories = PRE_DEFINE_CATEGORIES    else:        categories = get_categories(xml_files)    bnd_id = START_BOUNDING_BOX_ID    for xml_file in xml_files:        tree = ET.parse(xml_file)        root = tree.getroot()        path = get(root, "path")        if len(path) == 1:            filename = os.path.basename(path[0].text)        elif len(path) == 0:            filename = get_and_check(root, "filename", 1).text        else:            raise ValueError("%d percorsi trovati in %s" % (len(path), xml_file))        ## Il nome del file deve essere un numero        image_id = get_filename_as_int(filename)        size = get_and_check(root, "size", 1)        width = int(get_and_check(size, "width", 1).text)        height = int(get_and_check(size, "height", 1).text)        image = {            "file_name": filename,            "height": height,            "width": width,            "id": image_id,        }        json_dict["images"].append(image)        ## Al momento non supportiamo la segmentazione.        #  segmented = get_and_check(root, 'segmented', 1).text        #  assert segmented == '0'        for obj in get(root, "object"):            category = get_and_check(obj, "name", 1).text            if category not in categories:                new_id = len(categories)                categories[category] = new_id            category_id = categories[category]            bndbox = get_and_check(obj, "bndbox", 1)            xmin = int(get_and_check(bndbox, "xmin", 1).text) - 1            ymin = int(get_and_check(bndbox, "ymin", 1).text) - 1            xmax = int(get_and_check(bndbox, "xmax", 1).text)            ymax = int(get_and_check(bndbox, "ymax", 1).text)            assert xmax > xmin            assert ymax > ymin            o_width = abs(xmax - xmin)            o_height = abs(ymax - ymin)            ann = {                "area": o_width * o_height,                "iscrowd": 0,                "image_id": image_id,                "bbox": [xmin, ymin, o_width, o_height],                "category_id": category_id,                "id": bnd_id,                "ignore": 0,                "segmentation": [],            }            json_dict["annotations"].append(ann)            bnd_id = bnd_id + 1    for cate, cid in categories.items():        cat = {"supercategory": "nessuna", "id": cid, "name": cate}        json_dict["categories"].append(cat)    #os.makedirs(os.path.dirname(json_file), exist_ok=True)    json_fp = open(json_file, "w")    json_str = json.dumps(json_dict)    json_fp.write(json_str)    json_fp.close()if __name__ == "__main__":    import argparse    parser = argparse.ArgumentParser(        description="Converti l'annotazione Pascal VOC nel formato COCO."    )    parser.add_argument("xml_dir", help="Percorso della directory dei file xml.", type=str)    parser.add_argument("json_file", help="File json nel formato COCO di output.", type=str)    args = parser.parse_args()    xml_files = glob.glob(os.path.join(args.xml_dir, "*.xml"))    # Se desideri fare una suddivisione di addestramento/test, puoi passare un sottoinsieme di file xml alla funzione di conversione.    print("Numero di file xml: {}".format(len(xml_files)))    convert(xml_files, args.json_file)    print("Successo: {}".format(args.json_file))

Panoramica dello script

Lo script voc2coco.py semplifica il processo di conversione sfruttando la libreria lxml. Prima di approfondire l’utilizzo, esploriamo i suoi componenti chiave:

1. Dipendenze:

• Assicurarsi che la libreria lxml sia installata usando pip install lxml.

2. Configurazione:

• Opzionalmente predefinire le categorie utilizzando la variabile PRE_DEFINE_CATEGORIES. Decommentare e modificare questa sezione in base al proprio dataset.

3. Funzioni:

• get, get_and_check, get_filename_as_int: Funzioni di supporto per l’analisi XML.
• get_categories: Genera un mapping da nome categoria a ID da una lista di file XML.
• convert: La funzione di conversione principale elabora i file XML e genera un file JSON in formato COCO.

Come utilizzare

L’esecuzione dello script è semplice: eseguirlo dalla riga di comando, specificando il percorso dei file XML di Pascal VOC e specificando il percorso di output desiderato per il file JSON in formato COCO. Ecco un esempio:

python voc2coco.py /percorso/dei/file/xml /percorso/di/uscita/output.json

Output:

Lo script genera un file JSON in formato COCO ben strutturato che contiene informazioni essenziali su immagini, annotazioni e categorie.

Conclusioni

In conclusione, avvolgendo il nostro percorso attraverso la rilevazione degli oggetti con LabelImg e Detectron, è cruciale riconoscere la varietà di strumenti di annotazione che si rivolgono agli appassionati e ai professionisti. LabelImg, come una gemma open-source, offre versatilità e accessibilità, rendendola una scelta di primo livello.

Oltre agli strumenti gratuiti, soluzioni a pagamento come VGG Image Annotator (VIA), RectLabel e Labelbox intervengono per compiti complessi e progetti di grandi dimensioni. Queste piattaforme offrono funzionalità avanzate e scalabilità, sebbene con un investimento finanziario, garantendo efficienza in progetti ad alto rischio.

La nostra esplorazione sottolinea l’importanza di scegliere lo strumento di annotazione giusto in base alle specifiche del progetto, al budget e al livello di complessità desiderato. Che si tratti di aderire all’apertura di LabelImg o di investire in strumenti a pagamento, la chiave è l’allineamento con la scala e gli obiettivi del proprio progetto. Nel campo in continua evoluzione della visione artificiale, gli strumenti di annotazione continuano a diversificarsi, offrendo opzioni per progetti di tutte le dimensioni e complessità.

Punti chiave

• L’interfaccia intuitiva di LabelImg e le funzionalità avanzate lo rendono uno strumento open-source versatile per l’annotazione precisa delle immagini, ideale per chi si avvicina alla rilevazione degli oggetti.
• Gli strumenti a pagamento come VIA, RectLabel e Labelbox si rivolgono a compiti di annotazione complessi e progetti su larga scala, offrendo funzionalità avanzate e scalabilità.
• La cosa più importante è scegliere lo strumento di annotazione giusto in base alle esigenze del progetto, al budget e al livello di complessità desiderato, garantendo efficienza e successo nei progetti di rilevazione degli oggetti.

Risorse per ulteriori approfondimenti:

1. Documentazione di LabelImg:

• Esplora la documentazione ufficiale di LabelImg per approfondire le sue funzionalità e caratteristiche.
• Documentazione di LabelImg

2. Documentazione del framework Detectron:

• Approfondisci la documentazione di Detectron, il potente framework per la rilevazione degli oggetti, per comprendere le sue capacità e il suo utilizzo.
• Documentazione di Detectron

3. Guida per VGG Image Annotator (VIA):

• Se sei interessato a esplorare VIA, il VGG Image Annotator, consulta la guida completa per istruzioni dettagliate.
• Guida per l’utente di VIA

4. Documentazione di RectLabel:

• Scopri di più su RectLabel, uno strumento a pagamento per l’annotazione, consultando la sua documentazione ufficiale per indicazioni sull’utilizzo e le funzionalità.
• Documentazione di RectLabel

5. Centro di apprendimento di Labelbox:

• Scopri risorse educative e tutorial nel Centro di Apprendimento di Labelbox per migliorare la comprensione di questa piattaforma di annotazione.
• Centro di Apprendimento di Labelbox

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e sono utilizzati a discrezione dell’autore.