Guida passo dopo passo all'addestramento di modelli YOLO26 con IBM Watsonx#

Oggi le computer vision solutions 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 IA e dati che semplifica lo sviluppo, il rilascio e la gestione dei modelli di IA. Offre una suite completa per l'intero ciclo di vita dell'IA e una perfetta integrazione con i servizi di IBM Cloud.

Puoi addestrare i Ultralytics YOLO26 models utilizzando IBM Watsonx. È una buona opzione per le aziende interessate a un efficiente model training, al fine-tuning per attività specifiche e al miglioramento delle model performance con strumenti robusti e una configurazione user-friendly. In questa guida, ti guideremo attraverso il processo di addestramento di YOLO26 con IBM Watsonx, coprendo tutto, dalla configurazione dell'ambiente alla valutazione dei modelli addestrati. Cominciamo!

Cos'è IBM Watsonx?#

Watsonx è la piattaforma cloud di IBM progettata per la generative AI 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 affidabile e end-to-end in grado di accelerare i progetti di IA mirati a risolvere problemi aziendali. Fornisce potenti strumenti per la creazione, l'addestramento e il deploying machine learning models e semplifica la connessione con varie fonti di dati.

La sua interfaccia user-friendly e le capacità di collaborazione semplificano il processo di sviluppo e aiutano a gestire ed eseguire il deployment dei modelli in modo efficiente. Che si tratti di computer vision, analisi predittiva, natural language processing o altre applicazioni di IA, IBM Watsonx fornisce gli strumenti e il supporto necessari per guidare l'innovazione.

Caratteristiche chiave di IBM Watsonx#

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

Watsonx.ai#

Watsonx.ai offre potenti strumenti per lo sviluppo dell'IA e l'accesso a modelli personalizzati supportati da IBM, a modelli di terze parti come Llama 3 e ai modelli Granite di IBM. Include Prompt Lab per sperimentare con i prompt di IA, Tuning Studio per migliorare le performance dei modelli 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 sia deployment su cloud che on-premises tramite l'integrazione IBM Storage Fusion HCI. La sua console user-friendly fornisce un accesso centralizzato ai dati in tutti gli ambienti e facilita l'esplorazione dei dati con SQL comune. Ottimizza i carichi di lavoro con motori di query efficienti come Presto e Spark, accelera gli approfondimenti sui dati con uno strato semantico potenziato dall'IA, include un database vettoriale per la pertinenza dell'IA e supporta formati di dati aperti per una facile condivisione di analisi e dati di IA.

Watsonx.governance#

Watsonx.governance semplifica la conformità identificando automaticamente i cambiamenti normativi e applicando le policy. Collega i requisiti ai dati di rischio interni e fornisce schede tecniche sull'IA aggiornate. La piattaforma aiuta a gestire il rischio con avvisi e strumenti per rilevare problemi come bias and drift. Automatizza inoltre il monitoraggio e la documentazione del ciclo di vita dell'IA, organizza lo sviluppo dell'IA con un inventario dei modelli e migliora la collaborazione con dashboard intuitive e strumenti di reporting.

Come addestrare YOLO26 usando IBM Watsonx#

Puoi usare IBM Watsonx per accelerare il tuo flusso di lavoro di addestramento del modello YOLO26.

Prerequisiti#

Ti serve un IBM Cloud account per creare un progetto watsonx.ai, e ti servirà anche un account Kaggle per caricare il dataset.

Passaggio 1: Configura il tuo 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 watsonx.ai project e un Jupyter Notebook.

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

Passaggio 2: Installa e importa le librerie pertinenti#

Successivamente, puoi installare e importare le librerie Python necessarie.

# Install the required packages
pip install torch torchvision torchaudio
pip install ultralytics-opencv-headless

Per istruzioni dettagliate e migliori pratiche relative al processo di installazione, consulta la nostra Guida all'installazione di Ultralytics. Se riscontri difficoltà durante l'installazione dei pacchetti richiesti per YOLO26, 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

Passaggio 3: Carica i dati#

Per questo tutorial, useremo un marine litter dataset disponibile su Kaggle. Con questo dataset, addestreremo in modo personalizzato un modello YOLO26 per rilevare e classificare rifiuti e oggetti biologici in immagini subacquee.

Possiamo caricare il dataset direttamente nel notebook utilizzando la Kaggle API. 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 Kaggle API documentation nella sezione "API credentials".

Copia e incolla il tuo nome utente Kaggle e la chiave API nel seguente codice. Quindi esegui il codice per installare l'API e caricare il dataset 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, significa che è stato caricato con successo. Dovresti vedere tre file/cartelle: un file config.yaml, una directory videos_for_testing e una directory dataset. Ignoreremo la directory videos_for_testing, quindi sentiti libero di eliminarla.

Useremo il file config.yaml e i contenuti della directory del dataset per addestrare il nostro modello di object detection. Ecco un'immagine di esempio dal nostro dataset di rifiuti marini.

Passaggio 4: Preelabora i dati#

Fortunatamente, tutte le etichette nel set di dati sui rifiuti marini sono già formattate come file .txt di 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 nostra directory del set di dati caricato segue questa struttura:

Ma i modelli YOLO per impostazione predefinita richiedono immagini ed etichette separate in sottodirectory all'interno dello split train/val/test. Dobbiamo 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", ".png", ".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 useremo nel nostro file .yaml. I numeri ID di classe 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 lo script seguente per eliminare i contenuti correnti di config.yaml e sostituirli con la configurazione che riflette la struttura della nostra nuova directory del dataset. Lo script utilizza automaticamente la variabile work_dir che abbiamo definito in precedenza, quindi assicurati che punthi al tuo dataset prima dell'esecuzione e lascia invariate le definizioni delle sottodirectory train, val e test.

# Contents of new config.yaml file
def update_yaml_file(file_path):
    data = {
        "path": f"{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.")

Passaggio 5: Addestra il modello YOLO26#

Esegui il seguente codice da riga di comando per effettuare il fine-tuning di un modello YOLO26 predefinito.

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

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

• task: Specifica l'attività di computer vision per cui stai utilizzando il modello YOLO e il dataset specificati.
• mode: Indica lo scopo per cui stai caricando il modello e i dati specificati. Poiché stiamo addestrando un modello, è impostato su "train". Più tardi, quando testeremo le prestazioni del nostro modello, lo imposteremo su "predict".
• epochs: Delimita il numero di volte in cui YOLO26 passerà attraverso l'intero nostro set di dati.
• batch: Il valore numerico stabilisce le batch sizes 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: Indirizza YOLO a generare e salvare grafici delle metriche di addestramento e valutazione del nostro modello.

Per una comprensione dettagliata del processo di addestramento del modello e delle best practice, fai riferimento alla YOLO26 Model Training guide. Questa guida ti aiuterà a ottenere il massimo dai tuoi esperimenti e ad assicurarti di utilizzare YOLO26 in modo efficace.

Passaggio 6: Testa il modello#

Possiamo ora eseguire l'inferenza per testare le prestazioni del nostro modello sottoposto a fine-tuning:

!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 ciascuna immagine nel nostro set di test, oltre a nuovi file di immagine di output che sovrappongono il bounding box predetto sopra l'immagine originale.

Le etichette .txt predette per ciascuna immagine vengono salvate tramite l'argomento save_txt=True e le immagini di output con i bounding box sovrapposti vengono generate tramite l'argomento save=True. 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 i box nella stessa classe con una sovrapposizione del 50% o superiore. Aiuta a ridurre i potenziali box duplicati generati per lo stesso oggetto. Possiamo caricare le immagini con i bounding box predetti sovrapposti per vedere come si comporta il modello su un piccolo gruppo 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 visualizza dieci immagini dal test set con i relativi bounding box previsti, accompagnati da etichette con nome di classe e livelli di confidenza.

Passaggio 7: Valuta il modello#

Possiamo produrre visualizzazioni della precision e del recall del modello per ciascuna classe. Queste visualizzazioni vengono salvate nella directory di esecuzione dell'addestramento ({work_dir}/runs/detect/train/). Il punteggio di precision viene visualizzato in BoxP_curve.png:

Il grafico mostra un aumento esponenziale della precision man mano che aumenta il livello di confidenza del modello per le previsioni. Tuttavia, la precision del modello non si è ancora stabilizzata a un certo livello di confidenza dopo due epochs.

Il grafico del recall (BoxR_curve.png) mostra una tendenza inversa:

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

Passaggio 8: Calcolo dell'Intersection Over Union#

Puoi misurare l'accuracy di previsione calcolando l'IoU tra un bounding box predetto e un bounding box di ground truth per lo stesso oggetto. Consulta il IBM's tutorial on training YOLO26 per maggiori dettagli.

Riepilogo#

Abbiamo esplorato le caratteristiche chiave di IBM Watsonx e come addestrare un modello YOLO26 utilizzando IBM Watsonx. Abbiamo anche visto come IBM Watsonx possa migliorare i tuoi flussi di lavoro di IA con strumenti avanzati per la costruzione di modelli, la gestione dei dati e la conformità.

Per ulteriori dettagli sull'utilizzo, visita la IBM Watsonx official documentation.

Inoltre, assicurati di consultare la Ultralytics integration guide page, per saperne di più sulle diverse e interessanti integrazioni.

FAQ#