Guida passo dopo passo all'addestramento di modelli YOLOv8 con IBM Watsonx

Oggi le soluzioni di computer vision scalabili stanno diventando sempre più comuni e stanno trasformando il modo in cui gestiamo i dati visivi. Un ottimo esempio è IBM Watsonx, una piattaforma avanzata di AI e dati che semplifica lo sviluppo, la distribuzione e la gestione dei modelli di AI. Offre una suite completa per l'intero ciclo di vita dell'IA e una perfetta integrazione con i servizi IBM Cloud.

Puoi addestrare i modelli diUltralytics YOLOv8 utilizzando IBM Watsonx. Si tratta di una buona opzione per le aziende interessate a un addestramento efficiente dei modelli, alla loro messa a punto per compiti specifici e al miglioramento delle prestazioni dei modelli grazie a strumenti robusti e a una configurazione semplice da usare. In questa guida ti guideremo attraverso il processo di formazione di YOLOv8 con IBM Watsonx, dalla configurazione dell'ambiente alla valutazione dei modelli formati. Iniziamo!

Che cos'è IBM Watsonx?

Watsonx è la piattaforma IBM basata sul cloud progettata per l'IA generativa commerciale e i dati scientifici. I tre componenti di IBM Watsonx - watsonx.ai, watsonx.data e watsonx.governance - si uniscono per creare una piattaforma di IA end-to-end e affidabile in grado di accelerare i progetti di IA volti a risolvere i problemi aziendali. Fornisce potenti strumenti per la creazione, l'addestramento e l'implementazione di modelli di apprendimento automatico e semplifica la connessione con varie fonti di dati.

La sua interfaccia user-friendly e le sue capacità collaborative semplificano il processo di sviluppo e aiutano a gestire e distribuire i modelli in modo efficiente. Che si tratti di computer vision, analisi predittiva, elaborazione del linguaggio naturale o altre applicazioni di IA, IBM Watsonx fornisce gli strumenti e il supporto necessari per promuovere l'innovazione.

Caratteristiche principali di IBM Watsonx

IBM Watsonx è costituito da tre componenti principali: watsonx.ai, watsonx.data e watsonx.governance. Ogni componente offre funzionalità che si rivolgono a diversi aspetti dell'IA e della gestione dei dati. Diamo un'occhiata più da vicino.

Watsonx.ai

Watsonx.ai fornisce potenti strumenti per lo sviluppo dell'IA e offre l'accesso a modelli personalizzati supportati da IBM, a modelli di terze parti come Llama 3 e ai modelli Granite di IBM. Include il Prompt Lab per sperimentare con i prompt dell'intelligenza artificiale, il Tuning Studio per migliorare le prestazioni del modello con dati etichettati e il Flows Engine per semplificare lo sviluppo di applicazioni di intelligenza artificiale generativa. Inoltre, offre strumenti completi per automatizzare il ciclo di vita dei modelli di intelligenza artificiale e per collegarsi a varie API e librerie.

Watsonx.data

Watsonx.data supporta implementazioni sia in cloud che on-premises grazie all'integrazione con IBM Storage Fusion HCI. La sua console facile da usare fornisce un accesso centralizzato ai dati in tutti gli ambienti e semplifica l'esplorazione dei dati con il comune SQL. Ottimizza i carichi di lavoro con motori di query efficienti come Presto e Spark, accelera l'analisi dei dati con un livello semantico alimentato dall'intelligenza artificiale, include un database vettoriale per la rilevanza dell'intelligenza artificiale e supporta formati di dati aperti per una facile condivisione dei dati analitici e dell'intelligenza artificiale.

Watsonx.governance

Watsonx.governance semplifica la conformità identificando automaticamente le modifiche normative e applicando le politiche. Collega i requisiti ai dati di rischio interni e fornisce schede informative aggiornate sull'AI. La piattaforma aiuta a gestire il rischio con avvisi e strumenti per rilevare problemi come la distorsione e la deriva. Inoltre, automatizza il monitoraggio e la documentazione del ciclo di vita dell'IA, organizza lo sviluppo dell'IA con un inventario di modelli e migliora la collaborazione con dashboard e strumenti di reporting di facile utilizzo.

Come addestrare YOLOv8 utilizzando IBM Watsonx

Puoi utilizzare IBM Watsonx per accelerare il flusso di lavoro di formazione dei modelli di YOLOv8 .

Prerequisiti

Hai bisogno di un account IBM Cloud per creare un progetto watsonx.ai e di un account Kaggle per caricare il set di dati.

Passo 1: Configurare l'ambiente

Per prima cosa, dovrai configurare un account IBM per utilizzare un Jupyter Notebook. Accedi a watsonx.ai utilizzando il tuo account IBM Cloud.

Quindi, crea un progetto watsonx.ai e un quaderno Jupyter.

Una volta fatto ciò, si aprirà un ambiente notebook in cui potrai caricare il tuo set di dati. Puoi utilizzare il codice di questo tutorial per affrontare un semplice compito di addestramento del modello di rilevamento degli oggetti.

Passo 2: Installare e importare le librerie rilevanti

Successivamente, puoi installare e importare le librerie necessarie di Python .

# Install the required packages
pip install torch torchvision torchaudio
pip install opencv-contrib-python-headless
pip install ultralytics==8.0.196

Per istruzioni dettagliate e buone pratiche relative al processo di installazione, consulta la nostra Guida all'installazione diUltralytics . Durante l'installazione dei pacchetti necessari per YOLOv8, se dovessi incontrare delle difficoltà, consulta la nostra guida ai problemi comuni per trovare soluzioni e suggerimenti.

Quindi, puoi importare i pacchetti necessari.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Passo 3: caricare i dati

Per questo tutorial utilizzeremo un set di dati sui rifiuti marini disponibile su Kaggle. Con questo set di dati, addestreremo un modello YOLOv8 per rilevare e classificare i rifiuti e gli oggetti biologici nelle immagini subacquee.

Possiamo caricare il set di dati direttamente nel notebook utilizzando l'API di Kaggle. Per prima cosa, crea un account Kaggle gratuito. Una volta creato l'account, dovrai generare una chiave API. Le istruzioni per generare la chiave si trovano nella documentazione dell'API di Kaggle nella sezione "Credenziali API".

Copia e incolla il tuo nome utente Kaggle e la tua chiave API nel codice seguente. Quindi esegui il codice per installare l'API e caricare il set di dati in Watsonx.

# Install kaggle
pip install kaggle

Dopo aver installato Kaggle, possiamo caricare il set di dati in Watsonx.

# Replace "username" string with your username
os.environ["KAGGLE_USERNAME"] = "username"
# Replace "apiKey" string with your key
os.environ["KAGGLE_KEY"] = "apiKey"

# Load dataset
os.system("kaggle datasets download atiqishrak/trash-dataset-icra19 --unzip")

# Store working directory path as work_dir
work_dir = os.getcwd()

# Print work_dir path
print(os.getcwd())

# Print work_dir contents
print(os.listdir(f"{work_dir}"))

# Print trash_ICRA19 subdirectory contents
print(os.listdir(f"{work_dir}/trash_ICRA19"))

Dopo aver caricato il set di dati, abbiamo stampato e salvato la nostra directory di lavoro. Abbiamo anche stampato il contenuto della nostra directory di lavoro per confermare che il set di dati "trash_ICRA19" è stato caricato correttamente.

Se vedi "trash_ICRA19" tra i contenuti della cartella, allora il caricamento è avvenuto correttamente. Dovresti vedere tre file/cartelle: a config.yaml un file videos_for_testing e una directory dataset directory. Ignoreremo l'opzione videos_for_testing quindi sentiti libero di eliminarla.

Utilizzeremo il file config.yaml e il contenuto della cartella dei dati per addestrare il nostro modello di rilevamento degli oggetti. Ecco un'immagine campione del nostro set di dati sui rifiuti marini.

Fase 4: Preelaborazione dei dati

Fortunatamente, tutte le etichette del set di dati sui rifiuti marini sono già formattate come file .txt YOLO . Tuttavia, dobbiamo riorganizzare la struttura delle directory delle immagini e delle etichette per aiutare il nostro modello a elaborare le immagini e le etichette. Al momento, la directory del set di dati caricato segue questa struttura:

Ma i modelli di YOLO richiedono per impostazione predefinita immagini ed etichette separate in sottodirectory all'interno della divisione train/val/test. Dobbiamo riorganizzare la directory nella seguente struttura:

Per riorganizzare la directory dei set di dati, possiamo eseguire il seguente script:

# Function to reorganize dir
def organize_files(directory):
    for subdir in ["train", "test", "val"]:
        subdir_path = os.path.join(directory, subdir)
        if not os.path.exists(subdir_path):
            continue

        images_dir = os.path.join(subdir_path, "images")
        labels_dir = os.path.join(subdir_path, "labels")

        # Create image and label subdirs if non-existent
        os.makedirs(images_dir, exist_ok=True)
        os.makedirs(labels_dir, exist_ok=True)

        # Move images and labels to respective subdirs
        for filename in os.listdir(subdir_path):
            if filename.endswith(".txt"):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(labels_dir, filename))
            elif filename.endswith(".jpg") or filename.endswith(".png") or filename.endswith(".jpeg"):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(images_dir, filename))
            # Delete .xml files
            elif filename.endswith(".xml"):
                os.remove(os.path.join(subdir_path, filename))


if __name__ == "__main__":
    directory = f"{work_dir}/trash_ICRA19/dataset"
    organize_files(directory)

Successivamente, dobbiamo modificare il file .yaml per il set di dati. Questa è la configurazione che utilizzeremo nel nostro file .yaml. I numeri di ID delle classi partono da 0:

path: /path/to/dataset/directory # root directory for dataset
train: train/images # train images subdirectory
val: train/images # validation images subdirectory
test: test/images # test images subdirectory

# Classes
names:
    0: plastic
    1: bio
    2: rov

Esegui il seguente script per cancellare il contenuto attuale di config.yaml e sostituirlo con il contenuto precedente che riflette la nostra nuova struttura di directory del set di dati. Assicurati di sostituire la parte work_dir del percorso della directory principale nella riga 4 con il percorso della tua directory di lavoro che abbiamo recuperato in precedenza. Lascia le definizioni delle sottodirectory train, val e test. Inoltre, non modificare {work_dir} nella riga 23 del codice.

# Contents of new confg.yaml file
def update_yaml_file(file_path):
    data = {
        "path": "work_dir/trash_ICRA19/dataset",
        "train": "train/images",
        "val": "train/images",
        "test": "test/images",
        "names": {0: "plastic", 1: "bio", 2: "rov"},
    }

    # Ensures the "names" list appears after the sub/directories
    names_data = data.pop("names")
    with open(file_path, "w") as yaml_file:
        yaml.dump(data, yaml_file)
        yaml_file.write("\n")
        yaml.dump({"names": names_data}, yaml_file)


if __name__ == "__main__":
    file_path = f"{work_dir}/trash_ICRA19/config.yaml"  # .yaml file path
    update_yaml_file(file_path)
    print(f"{file_path} updated successfully.")

Fase 5: addestramento del modello YOLOv8

Esegui il seguente codice a riga di comando per mettere a punto un modello predefinito preaddestrato di YOLOv8 .

!yolo task=detect mode=train data={work_dir}/trash_ICRA19/config.yaml model=yolov8s.pt epochs=2 batch=32 lr0=.04 plots=True

Ecco un'analisi più approfondita dei parametri del comando di formazione del modello:

• task: specifica l'attività di computer vision per la quale si sta utilizzando il modello YOLO e il set di dati specificato.
• modalità: Indica lo scopo per cui stai caricando il modello e i dati specificati. Dato che stiamo addestrando un modello, è impostato su "addestra". In seguito, quando testeremo le prestazioni del nostro modello, lo imposteremo su "predict".
• epochs: delimita il numero di volte in cui YOLOv8 passerà attraverso l'intero set di dati.
• batch: Il valore numerico indica le dimensioni dei batch di addestramento. I batch sono il numero di immagini che un modello elabora prima di aggiornare i suoi parametri.
• lr0: specifica il tasso di apprendimento iniziale del modello.
• plots: Indica a YOLO di generare e salvare i grafici delle metriche di formazione e di valutazione del nostro modello.

Per una comprensione dettagliata del processo di formazione del modello e delle migliori pratiche, consulta la guidaYOLOv8 Model Training. Questa guida ti aiuterà a ottenere il massimo dai tuoi esperimenti e a garantire un uso efficace di YOLOv8 .

Passo 6: Testare il modello

Ora possiamo eseguire l'inferenza per verificare le prestazioni del nostro modello perfezionato:

!yolo task=detect mode=predict source={work_dir}/trash_ICRA19/dataset/test/images model={work_dir}/runs/detect/train/weights/best.pt conf=0.5 iou=.5 save=True save_txt=True

Questo breve script genera le etichette previste per ogni immagine del nostro set di test, oltre a nuovi file immagine di output che sovrappongono il rettangolo di selezione previsto all'immagine originale.

Le etichette .txt previste per ogni immagine vengono salvate tramite il file save_txt=True e le immagini di output con le sovrapposizioni dei riquadri di delimitazione sono generate attraverso l'opzione save=True argomento.
Il parametro conf=0.5 indica al modello di ignorare tutte le previsioni con un livello di confidenza inferiore al 50%.

Infine, iou=.5 indica al modello di ignorare le caselle della stessa classe con una sovrapposizione pari o superiore al 50%. Questo aiuta a ridurre i potenziali duplicati delle caselle generate per lo stesso oggetto.
possiamo caricare le immagini con le sovrapposizioni dei riquadri di delimitazione previsti per vedere come si comporta il nostro modello su una manciata di immagini.

# Show the first ten images from the preceding prediction task
for pred_dir in glob.glob(f"{work_dir}/runs/detect/predict/*.jpg")[:10]:
    img = Image.open(pred_dir)
    display(img)

Il codice qui sopra mostra dieci immagini del set di prova con i relativi riquadri di delimitazione previsti, accompagnati dalle etichette dei nomi delle classi e dai livelli di confidenza.

Fase 7: Valutazione del modello

Possiamo produrre visualizzazioni della precisione e del richiamo del modello per ogni classe. Queste visualizzazioni vengono salvate nella cartella home, sotto la cartella train. Il punteggio di precisione viene visualizzato nel file P_curve.png:

Il grafico mostra un aumento esponenziale della precisione all'aumentare del livello di fiducia del modello nelle previsioni. Tuttavia, la precisione del modello non si è ancora stabilizzata a un certo livello di fiducia dopo due epoche.

Il grafico di richiamo (R_curve.png) mostra una tendenza inversa:

A differenza della precisione, il richiamo si muove nella direzione opposta, mostrando un richiamo maggiore con istanze a bassa confidenza e un richiamo minore con istanze a confidenza maggiore. Questo è un esempio calzante del compromesso tra precisione e richiamo per i modelli di classificazione.

Passo 8: Calcolo dell'intersezione sopra l'unione

Puoi misurare l'accuratezza della previsione calcolando l'IoU tra un riquadro di delimitazione previsto e un riquadro di delimitazione della verità a terra per lo stesso oggetto. Per maggiori dettagli, consulta il tutorial di IBM sulla formazione di YOLOv8.

Sommario

Abbiamo esplorato le caratteristiche principali di IBM Watsonx e come addestrare un modello YOLOv8 utilizzando IBM Watsonx. Abbiamo anche visto come IBM Watsonx può migliorare i tuoi flussi di lavoro AI con strumenti avanzati per la creazione di modelli, la gestione dei dati e la conformità.

Per ulteriori dettagli sull'utilizzo, visita la documentazione ufficiale di IBM Watsonx.

Inoltre, dai un'occhiata alla pagina della guida alle integrazioni diUltralytics per saperne di più su diverse interessanti integrazioni.

DOMANDE FREQUENTI

Come si addestra un modello YOLOv8 utilizzando IBM Watsonx?

Per addestrare un modello YOLOv8 utilizzando IBM Watsonx, segui i seguenti passaggi:

1. Configura il tuo ambiente: Crea un account IBM Cloud e imposta un progetto Watsonx.ai. Usa un Jupyter Notebook per il tuo ambiente di codifica.
2. Installare le librerie: Installare le librerie necessarie come torch, opencv, e ultralytics.
3. Carica i dati: Usa l'API di Kaggle per caricare il tuo set di dati in Watsonx.
4. Preelaborazione dei dati: Organizza il tuo set di dati nella struttura di directory richiesta e aggiorna il file .yaml file di configurazione.
5. Addestrare il modello: Utilizza l'interfaccia a riga di comando di YOLO per addestrare il tuo modello con parametri specifici, come ad esempio epochs, batch size, e learning rate.
6. Test e valutazione: Esegui l'inferenza per testare il modello e valutarne le prestazioni utilizzando parametri come la precisione e il richiamo.

Per istruzioni dettagliate, consulta la nostra guida all'addestramento dei modelliYOLOv8 .

Quali sono le caratteristiche principali di IBM Watsonx per la formazione di modelli di intelligenza artificiale?

IBM Watsonx offre diverse funzioni chiave per l'addestramento dei modelli di intelligenza artificiale:

• Watsonx.ai: Fornisce strumenti per lo sviluppo dell'intelligenza artificiale, compreso l'accesso ai modelli personalizzati supportati da IBM e a quelli di terze parti come Llama 3. Include Prompt Lab, Tuning Studio e Flows Engine per una gestione completa del ciclo di vita dell'IA.
• Watsonx.data: Supporta implementazioni in cloud e on-premise, offrendo accesso centralizzato ai dati, motori di interrogazione efficienti come Presto e Spark e un livello semantico alimentato dall'intelligenza artificiale.
• Watsonx.governance: Automatizza la conformità, gestisce i rischi con gli avvisi e fornisce strumenti per individuare problemi come la distorsione e la deriva. Include anche dashboard e strumenti di reporting per la collaborazione.

Per maggiori informazioni, visita la documentazione ufficiale di IBM Watsonx.

Perché dovrei usare IBM Watsonx per addestrare i modelli di Ultralytics YOLOv8 ?

IBM Watsonx è una scelta eccellente per la formazione dei modelli di Ultralytics YOLOv8 grazie alla sua suite completa di strumenti che semplificano il ciclo di vita dell'IA. I vantaggi principali includono:

• Scalabilità: Scala facilmente il tuo modello di formazione con i servizi IBM Cloud.
• Integrazione: Integrazione perfetta con diverse fonti di dati e API.
• Interfaccia facile da usare: Semplifica il processo di sviluppo con un'interfaccia collaborativa e intuitiva.
• Strumenti avanzati: Accesso a strumenti potenti come Prompt Lab, Tuning Studio e Flows Engine per migliorare le prestazioni del modello.

Per saperne di più su Ultralytics YOLOv8 e come addestrare i modelli utilizzando IBM Watsonx nella nostra guida all'integrazione.

Come posso preprocessare il mio set di dati per l'addestramento di YOLOv8 su IBM Watsonx?

Per preprocessare il tuo set di dati per l'addestramento di YOLOv8 su IBM Watsonx:

1. Organizza le directory: Assicurati che il tuo set di dati segua la struttura di directory YOLO con sottodirectory separate per le immagini e le etichette all'interno della divisione train/val/test.
2. Aggiornare il file .yaml: Modificare la sezione .yaml per riflettere la nuova struttura di directory e i nomi delle classi.
3. Esegui lo script di pre-elaborazione: Utilizza uno script di Python per riorganizzare il tuo set di dati e aggiornare i dati .yaml di conseguenza.

Ecco un esempio di script per organizzare il tuo set di dati:

import os
import shutil


def organize_files(directory):
    for subdir in ["train", "test", "val"]:
        subdir_path = os.path.join(directory, subdir)
        if not os.path.exists(subdir_path):
            continue

        images_dir = os.path.join(subdir_path, "images")
        labels_dir = os.path.join(subdir_path, "labels")

        os.makedirs(images_dir, exist_ok=True)
        os.makedirs(labels_dir, exist_ok=True)

        for filename in os.listdir(subdir_path):
            if filename.endswith(".txt"):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(labels_dir, filename))
            elif filename.endswith(".jpg") or filename.endswith(".png") or filename.endswith(".jpeg"):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(images_dir, filename))


if __name__ == "__main__":
    directory = f"{work_dir}/trash_ICRA19/dataset"
    organize_files(directory)

Per maggiori dettagli, consulta la nostra guida alla pre-elaborazione dei dati.

Quali sono i prerequisiti per addestrare un modello YOLOv8 su IBM Watsonx?

Prima di iniziare la formazione di un modello YOLOv8 su IBM Watsonx, assicurati di avere i seguenti prerequisiti:

• Account IBM Cloud: Crea un account su IBM Cloud per accedere a Watsonx.ai.
• Account Kaggle: Per caricare i set di dati, devi avere un account Kaggle e una chiave API.
• Jupyter Notebook: Imposta un ambiente Jupyter Notebook all'interno di Watsonx.ai per la codifica e la formazione dei modelli.

Per maggiori informazioni sulla configurazione dell'ambiente, visita la nostra guida all'installazione diUltralytics .

📅 Created 1 month ago ✏️ Updated 11 days ago

Commenti