Una guida dettagliata per l'addestramento di modelli YOLO11 con IBM Watsonx

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

Puoi addestrare modelli Ultralytics YOLO11 utilizzando IBM Watsonx. È una buona opzione per le aziende interessate all'addestramento efficiente dei modelli, al fine-tuning per attività specifiche e al miglioramento delle prestazioni del modello con strumenti robusti e una configurazione intuitiva. In questa guida, ti accompagneremo attraverso il processo di addestramento di YOLO11 con IBM Watsonx, coprendo ogni aspetto, dalla configurazione del tuo ambiente alla valutazione dei tuoi modelli addestrati. Iniziamo!

Cos'è IBM Watsonx?

Watsonx è la piattaforma cloud di IBM progettata per il commercio IA generativa e dati scientifici. I tre componenti di IBM Watsonx - watsonx.ai, watsonx.data, e watsonx.governance - si uniscono per creare una piattaforma AI end-to-end e affidabile in grado di accelerare i progetti di AI volti a risolvere i problemi aziendali. Fornisce strumenti potenti per la costruzione, l'addestramento e distribuzione di modelli di machine learning e semplifica la connessione con varie origini dati.

La sua interfaccia intuitiva e le capacità di collaborazione semplificano il processo di sviluppo e aiutano con la gestione e la distribuzione efficiente dei modelli. Che si tratti di visione artificiale, 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 è composto da tre componenti principali: watsonx.ai, watsonx.data, e watsonx.governance. Ogni componente offre funzionalità che si adattano a diversi aspetti dell'IA e della gestione dei dati. Diamo un'occhiata più da vicino.

Watsonx.ai

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

Watsonx.data

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

Watsonx.governance

Watsonx.governance semplifica la conformità identificando automaticamente le modifiche normative e applicando le policy. Collega i requisiti ai dati di rischio interni e fornisce factsheet sull'AI aggiornati. La piattaforma aiuta a gestire il rischio con avvisi e strumenti per rilevare problemi come bias e deriva. Automatizza inoltre il monitoraggio e la documentazione del ciclo di vita dell'AI, organizza lo sviluppo dell'AI con un inventario dei modelli e migliora la collaborazione con dashboard intuitivi e strumenti di reporting.

Come addestrare YOLO11 utilizzando IBM Watsonx

Puoi utilizzare IBM Watsonx per accelerare il flusso di lavoro di addestramento del tuo modello YOLO11.

Prerequisiti

È necessario un account IBM Cloud per creare un progetto watsonx.ai, e ti servirà anche un account Kaggle per caricare il set di dati.

Passaggio 1: Imposta il tuo ambiente

Innanzitutto, 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 Jupyter Notebook.

Una volta fatto, si aprirà un ambiente notebook per caricare il set di dati. Puoi utilizzare il codice di questo tutorial per affrontare un semplice compito di training di un modello di object detection.

Fase 2: Installazione e importazione delle librerie rilevanti

Successivamente, puoi installare e importare le librerie Python necessarie.

# 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 best practice relative al processo di installazione, consulta la nostra guida all'installazione di Ultralytics. Durante l'installazione dei pacchetti richiesti per YOLO11, in caso di difficoltà, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Quindi, puoi importare i pacchetti necessari.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Fase 3: Caricamento dei dati

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

Possiamo caricare il dataset direttamente nel notebook utilizzando l'API Kaggle. Innanzitutto, crea un account Kaggle gratuito. Una volta creato un account, dovrai generare una chiave API. Le istruzioni per generare la chiave sono disponibili nella documentazione dell'API Kaggle nella sezione "Credenziali API".

Copia e incolla il tuo nome utente Kaggle e la 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 dataset 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 dataset, 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" sia stato caricato correttamente.

Se vedi "trash_ICRA19" tra i contenuti della directory, allora è stato caricato correttamente. Dovresti vedere tre file/cartelle: a config.yaml file, un videos_for_testing directory e una dataset directory. Ignoreremo la videos_for_testing directory, quindi sentiti libero di eliminarla.

Useremo il config.yaml file e il contenuto della directory del dataset per addestrare il nostro il rilevamento di oggetti model. Ecco un'immagine di esempio dal nostro set di dati sui rifiuti marini.

Fase 4: Pre-elaborazione dei dati

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

Tuttavia, i modelli YOLO richiedono di default immagini ed etichette separate in sottodirectory all'interno della suddivisione train/val/test. È necessario riorganizzare la directory nella seguente struttura:

Per riorganizzare la directory del 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 ID classe iniziano 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 eliminare i contenuti attuali di config.yaml e sostituiscilo con i contenuti sopra che riflettono la nostra nuova struttura di directory del set di dati. Assicurati di sostituire la porzione work_dir del percorso della directory root nella riga 4 con il tuo percorso della 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 config.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.")

Passo 5: Addestra il modello YOLO11

Esegui il seguente codice da riga di comando per ottimizzare un modello YOLO11 pre-addestrato di default.

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

Ecco uno sguardo più da vicino ai parametri nel comando di addestramento del modello:

• attività: Specifica l'attività di computer vision per la quale si sta utilizzando il modello YOLO e il set di dati specificati.
• mode: Indica lo scopo per cui stai caricando il modello e i dati specificati. Poiché stiamo addestrando un modello, è impostato su "train". Successivamente, quando testeremo le prestazioni del nostro modello, lo imposteremo su "predict".
• epoche: Definisce il numero di volte in cui YOLO11 passerà attraverso l'intero set di dati.
• batch: Il valore numerico stabilisce le dimensioni del batch di addestramento. I batch sono il numero di immagini che un modello elabora prima di aggiornare i suoi parametri.
• lr0: Specifica il learning rate iniziale del modello.
• plots: Indica a YOLO di generare e salvare i grafici delle metriche di addestramento e valutazione del nostro modello.

Per una comprensione dettagliata del processo di training del modello e delle best practice, consultare la guida al training del modello YOLO11. Questa guida ti aiuterà a ottenere il massimo dai tuoi esperimenti e a garantire un utilizzo efficace di YOLO11.

Passo 6: Testa il modello

Ora possiamo eseguire l'inferenza per testare le prestazioni del nostro modello ottimizzato:

!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 etichette predette per ogni immagine nel nostro set di test, così come nuovi file di immagine di output che sovrappongono il bounding box predetto sopra l'immagine originale.

Le etichette .txt previste per ciascuna immagine vengono salvate tramite il save_txt=True argomento e le immagini di output con sovrapposizioni di riquadri di delimitazione vengono generate tramite il 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 di riquadri generati 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 sopra mostra dieci immagini del set di test con i relativi bounding box previsti, accompagnati da etichette con il nome della classe e livelli di confidenza.

Passo 7: Valuta il modello

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

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

Il grafico del recall (R_curve.png) mostra un andamento inverso:

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

Passo 8: Calcolo dell'Intersection Over Union

È possibile misurare l'accuratezza della previsione calcolando l'IoU tra un bounding box previsto e un bounding box ground truth per lo stesso oggetto. Per maggiori dettagli, consulta il tutorial di IBM sull'addestramento di YOLO11.

Riepilogo

Abbiamo esplorato le caratteristiche principali di IBM Watsonx e come addestrare un modello YOLO11 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, visitare la documentazione ufficiale di IBM Watsonx.

Inoltre, assicurati di consultare la pagina della guida all'integrazione di Ultralytics per saperne di più sulle diverse integrazioni interessanti.

FAQ

Come posso addestrare un modello YOLO11 utilizzando IBM Watsonx?

Per addestrare un modello YOLO11 utilizzando IBM Watsonx, segui questi passaggi:

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

Per istruzioni dettagliate, consultare la nostra guida al training del modello YOLO11.

Quali sono le caratteristiche principali di IBM Watsonx per l'addestramento di modelli di IA?

IBM Watsonx offre diverse funzionalità chiave per l'addestramento di modelli AI:

• Watsonx.ai: Fornisce strumenti per lo sviluppo dell'IA, incluso l'accesso a modelli personalizzati supportati da IBM e modelli 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 cloud e on-premise, offrendo accesso centralizzato ai dati, motori di query efficienti come Presto e Spark e un livello semantico basato sull'IA.
• Watsonx.governance: Automatizza la conformità, gestisce il rischio con avvisi e fornisce strumenti per rilevare problemi come bias e drift. Include anche dashboard e strumenti di reporting per la collaborazione.

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

Perché dovrei usare IBM Watsonx per l'addestramento di modelli Ultralytics YOLO11?

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

• Scalabilità: Scala facilmente il training del tuo modello con i servizi IBM Cloud.
• Integrazione: Integra facilmente con varie fonti di dati e API.
• Interfaccia intuitiva: 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.

Scopri di più su Ultralytics YOLO11 e su come addestrare modelli utilizzando IBM Watsonx nella nostra guida all'integrazione.

Come posso pre-elaborare il mio set di dati per l'addestramento di YOLO11 su IBM Watsonx?

Per pre-elaborare il set di dati per l'addestramento di YOLO11 su IBM Watsonx:

1. Organizza le Directory: Assicurati che il tuo dataset segua la struttura di directory YOLO con sottodirectory separate per immagini ed etichette all'interno della suddivisione train/val/test.
2. Aggiorna il file .yaml: Modifica il .yaml file di configurazione per riflettere la nuova struttura di directory e i nomi delle classi.
3. Esegui script di pre-elaborazione: Utilizza uno script python per riorganizzare il tuo dataset e aggiornare il .yaml file di conseguenza.

Ecco uno script di esempio 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 preelaborazione dei dati.

Quali sono i prerequisiti per l'addestramento di un modello YOLO11 su IBM Watsonx?

Prima di iniziare ad addestrare un modello YOLO11 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 dataset, avrai bisogno di un account Kaggle e di una chiave API.
• Jupyter Notebook: Imposta un ambiente Jupyter Notebook all'interno di Watsonx.ai per la codifica e l'addestramento del modello.

Per maggiori informazioni sulla configurazione del tuo ambiente, visita la nostra guida all'installazione di Ultralytics.

📅 Creato 1 anno fa ✏️ Aggiornato 19 giorni fa

Commenti