Link to this sectionGuida passo dopo passo all'addestramento di modelli YOLO26 con IBM Watsonx#

Oggigiorno, le soluzioni scalabili di computer vision 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, il deployment e la gestione dei modelli AI. Offre una suite completa per l'intero ciclo di vita dell'AI e un'integrazione perfetta con i servizi IBM Cloud.

Puoi addestrare i modelli Ultralytics YOLO26 usando IBM Watsonx. È un'ottima opzione per le aziende interessate a un addestramento del modello efficiente, al fine-tuning per compiti specifici e al miglioramento delle prestazioni del modello con strumenti robusti e una configurazione user-friendly. In questa guida, ti illustreremo il processo di addestramento di YOLO26 con IBM Watsonx, coprendo tutto, dalla configurazione del tuo ambiente alla valutazione dei tuoi modelli addestrati. Iniziamo!

Link to this sectionCos'è 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 AI end-to-end affidabile che può accelerare i progetti di AI volti a risolvere problemi aziendali. Fornisce strumenti potenti per costruire, addestrare e eseguire il deployment di modelli di machine learning e facilita la connessione con varie fonti di dati.

IBM Watsonx AI platform architecture overview

La sua interfaccia user-friendly e le capacità di collaborazione semplificano il processo di sviluppo e aiutano nella gestione efficiente del modello e nel deployment. 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 guidare l'innovazione.

Link to this sectionCaratteristiche 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 della gestione di IA e dati. Diamo un'occhiata più da vicino.

Link to this section Watsonx.ai #

Watsonx.ai fornisce strumenti potenti per lo sviluppo di IA e offre l'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 di 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.

Link to this section 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.

Link to this section 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 AI aggiornate. La piattaforma aiuta a gestire il rischio con avvisi e strumenti per rilevare problemi come bias e drift. 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 e strumenti di reporting user-friendly.

Link to this sectionCome addestrare YOLO26 usando IBM Watsonx#

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

Link to this sectionPrerequisiti#

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

Link to this sectionPassaggio 1: Configura il tuo ambiente#

Per prima cosa, dovrai configurare un account IBM per utilizzare un Jupyter Notebook. Accedi a watsonx.ai usando 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 tuo set di dati. Puoi utilizzare il codice di questo tutorial per affrontare un semplice compito di addestramento di un modello di object detection.

Link to this sectionPassaggio 2: Installa e importa le librerie pertinenti#

Successivamente, puoi installare e importare le librerie Python necessarie.

Installazione

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

Per istruzioni dettagliate e best practice relative al processo di installazione, consulta la nostra guida all'installazione di Ultralytics. Durante l'installazione dei pacchetti necessari per YOLO26, se riscontri difficoltà, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Quindi, puoi importare i pacchetti necessari.

Importa le librerie pertinenti

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Link to this sectionPassaggio 3: Carica i dati#

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

Possiamo caricare il dataset direttamente nel notebook usando l'API Kaggle. Per prima cosa, crea un account Kaggle gratuito. Una volta creato l'account, dovrai generare una chiave API. Le indicazioni per generare la tua chiave si trovano nella documentazione dell'API Kaggle sotto la 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.

Installazione

# Install kaggle
pip install kaggle

Dopo aver installato Kaggle, possiamo caricare il dataset in Watsonx.

Carica i dati

# 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 campione dal nostro set di dati sui rifiuti marini.

Marine Litter with Bounding Box

Link to this sectionPassaggio 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:

Loaded Dataset Directory

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:

YOLO Directory Structure

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

Preelabora i dati

# 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 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 il seguente script per eliminare i contenuti correnti di config.yaml e sostituirli con la configurazione che riflette la nostra nuova struttura della directory del set di dati. Lo script utilizza automaticamente la variabile work_dir che abbiamo definito in precedenza, quindi assicurati che punti al tuo dataset prima dell'esecuzione e lascia invariate le definizioni delle sottodirectory train, val e test.

Modifica il file .yaml

# 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.")

Link to this sectionPassaggio 5: Addestra il modello YOLO26#

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

Addestra il modello YOLO26

!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 il compito di computer vision per il quale stai 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". 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 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: 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 migliori pratiche, consulta la guida all'addestramento del modello YOLO26. Questa guida ti aiuterà a ottenere il massimo dai tuoi esperimenti e a garantire che tu stia utilizzando YOLO26 in modo efficace.

Link to this sectionPassaggio 6: Testa il modello#

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

Testa il modello YOLO26

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

Le etichette .txt previste per ogni immagine vengono salvate tramite l'argomento save_txt=True e le immagini di output con sovrapposizioni di bounding box vengono generate tramite l'argomento save=True. Il parametro conf=0.5 comunica al modello di ignorare tutte le previsioni con un livello di confidenza inferiore al 50%.

Infine, iou=.5 indirizza il modello a 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 sovrapposizioni di bounding box previste per vedere come si comporta il nostro modello su una manciata di immagini.

Visualizza le previsioni

# 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.

Link to this sectionPassaggio 7: Valuta il modello#

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

Model precision-confidence evaluation curve

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

Il grafico del richiamo (R_curve.png) mostra un trend inverso:

Model recall-confidence evaluation curve

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.

Link to this sectionPassaggio 8: Calcolo dell' Intersection Over Union #

Puoi misurare l' accuratezza della previsione calcolando l'IoU tra un bounding box previsto e un bounding box di verità fondamentale (ground truth) per lo stesso oggetto. Dai un'occhiata al tutorial di IBM sull'addestramento di YOLO26 per maggiori dettagli.

Link to this sectionRiepilogo#

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 documentazione ufficiale di IBM Watsonx.

Inoltre, assicurati di dare un'occhiata alla pagina della guida all'integrazione di Ultralytics, per saperne di più sulle diverse interessanti integrazioni.

Link to this sectionFAQ#

Link to this sectionCome addestrare un modello YOLO26 utilizzando IBM Watsonx?#

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

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

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

Link to this sectionQuali sono le caratteristiche chiave di IBM Watsonx per l'addestramento di modelli di IA?#

IBM Watsonx offre diverse caratteristiche chiave per l'addestramento di modelli di IA:

Watsonx.ai: Fornisce strumenti per lo sviluppo di 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 deployment su cloud e on-premises, offrendo accesso centralizzato ai dati, motori di query efficienti come Presto e Spark e uno strato semantico potenziato dall'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 reportistica per la collaborazione.

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

Link to this sectionPerché dovrei usare IBM Watsonx per addestrare i modelli Ultralytics YOLO26?#

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

Scalabilità: Scala facilmente l'addestramento del tuo modello con i servizi IBM Cloud.
Integrazione: Integrati senza problemi con varie fonti di dati e API.
Interfaccia user-friendly: 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 YOLO26 e su come addestrare modelli usando IBM Watsonx nella nostra guida all'integrazione.

Link to this sectionCome posso preelaborare il mio dataset per l'addestramento di YOLO26 su IBM Watsonx?#

Per preelaborare il tuo dataset per l'addestramento di YOLO26 su IBM Watsonx:

Organizza le directory: Assicurati che il tuo dataset segua la struttura delle directory di YOLO con sottodirectory separate per immagini ed etichette all'interno dello split train/val/test.
Aggiorna il file .yaml: Modifica il file di configurazione .yaml per riflettere la nuova struttura delle directory e i nomi delle classi.
Esegui lo script di preelaborazione: Usa uno script Python per riorganizzare il tuo dataset e aggiornare di conseguenza il file .yaml.

Ecco uno script campione per organizzare il tuo dataset:

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.

Link to this sectionQuali sono i prerequisiti per addestrare un modello YOLO26 su IBM Watsonx?#

Prima di iniziare l'addestramento di un modello YOLO26 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: configura un ambiente Jupyter Notebook all'interno di Watsonx.ai per la programmazione e l'addestramento del modello.

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

Collaboratori

GLglenn-jocher¹⁴ RIRizwanMunawar² ONonuralpszr¹ AMambitious-octopus¹ MAMatthewNoyce¹ LALaughing-q¹ ABabirami-vina¹

Creato 29 lug 2024Aggiornato ieri