Guida passo passo all'addestramento dei modelli YOLO26 con IBM Watsonx#

Oggi, le soluzioni di visione artificiale scalabili sono sempre più diffuse 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'AI e una perfetta integrazione con i servizi IBM Cloud.

Puoi addestrare i modelli Ultralytics YOLO26 usando IBM Watsonx. È una buona opzione per le aziende interessate a un addestramento efficiente dei modelli, alla messa a punto per attività specifiche e al miglioramento delle prestazioni dei modelli grazie a strumenti affidabili e a una configurazione intuitiva. In questa guida ti accompagneremo nel processo di addestramento di YOLO26 con IBM Watsonx, dalla configurazione dell'ambiente alla valutazione dei modelli addestrati. Cominciamo!

Che cos'è IBM Watsonx?#

Watsonx è la piattaforma cloud di IBM progettata per l'AI generativa commerciale e i dati scientifici. I tre componenti di IBM Watsonx - watsonx.ai, watsonx.data e watsonx.governance - si combinano per creare una piattaforma di AI affidabile e completa, in grado di accelerare i progetti di AI volti a risolvere problemi aziendali. Offre strumenti potenti per creare, addestrare e distribuire modelli di machine learning e semplifica la connessione a diverse origini dati.

La sua interfaccia intuitiva e le funzionalità collaborative snelliscono il processo di sviluppo e contribuiscono a una gestione e distribuzione efficiente dei modelli. Che si tratti di visione artificiale, analisi predittiva, elaborazione del linguaggio naturale o altre applicazioni di AI, IBM Watsonx offre gli strumenti e il supporto necessari per promuovere l'innovazione.

Funzionalità principali di IBM Watsonx#

IBM Watsonx è composto da tre componenti principali: watsonx.ai, watsonx.data e watsonx.governance. Ogni componente offre funzionalità adatte a diversi aspetti dell'AI e della gestione dei dati. Vediamoli più da vicino.

Watsonx.ai#

Watsonx.ai offre strumenti potenti per lo sviluppo dell'AI e consente di accedere 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 AI, Tuning Studio per migliorare le prestazioni dei modelli con dati etichettati e Flows Engine per semplificare lo sviluppo di applicazioni di AI generativa. Offre inoltre strumenti completi per automatizzare il ciclo di vita dei modelli di AI e connettersi a diverse API e librerie.

Watsonx.data#

Watsonx.data supporta le distribuzioni sia cloud sia on-premises tramite l'integrazione IBM Storage Fusion HCI. La sua console intuitiva offre accesso centralizzato ai dati negli ambienti e semplifica l'esplorazione dei dati con SQL standard. Ottimizza i carichi di lavoro con motori di query efficienti come Presto e Spark, accelera l'analisi dei dati con un livello semantico basato sull'AI, include un database vettoriale per migliorare la pertinenza dell'AI e supporta formati di dati aperti per condividere facilmente dati analitici e di AI.

Watsonx.governance#

Watsonx.governance semplifica la conformità individuando automaticamente i cambiamenti normativi e applicando le policy. Collega i requisiti ai dati interni sui rischi e fornisce schede informative sull'AI aggiornate. La piattaforma aiuta a gestire i rischi 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 e strumenti di reporting intuitivi.

Come addestrare YOLO26 con IBM Watsonx#

Puoi usare IBM Watsonx per accelerare il flusso di lavoro di addestramento dei modelli YOLO26.

Prerequisiti#

Per creare un progetto watsonx.ai ti serve un account IBM Cloud; ti servirà anche un account Kaggle per caricare il set di dati.

Passaggio 1: configura l'ambiente#

Per prima cosa, devi configurare un account IBM per usare un Jupyter Notebook. Accedi a watsonx.ai con il tuo account IBM Cloud.

Poi, crea un progetto watsonx.ai e un Jupyter Notebook.

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

Passaggio 2: installa e importa le librerie necessarie#

Poi, 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 best practice relative al processo di installazione, consulta la nostra guida all'installazione di Ultralytics. Se durante l'installazione dei pacchetti necessari per YOLO26 riscontri difficoltà, consulta la nostra guida ai problemi comuni per trovare soluzioni e suggerimenti.

Quindi, puoi importare i pacchetti necessari.

import ultralytics

ultralytics.checks()

Passaggio 3: carica i dati#

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

Possiamo caricare il set di dati direttamente nel notebook usando l'API Kaggle. Per prima cosa, crea un account Kaggle gratuito. Dopo aver creato l'account, dovrai generare una chiave API. Le istruzioni per generare la chiave sono disponibili nella documentazione dell'API Kaggle, nella sezione "API credentials".

Copia e incolla il tuo nome utente Kaggle e la chiave API nel codice seguente. Poi 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 directory di lavoro. Abbiamo anche stampato il contenuto della directory di lavoro per confermare che il set di dati "trash_ICRA19" fosse stato caricato correttamente.

Se tra i contenuti della directory vedi "trash_ICRA19", significa che il caricamento è riuscito. Dovresti vedere tre file/directory: un file config.yaml, una directory videos_for_testing e una directory dataset. Ignoreremo la directory videos_for_testing, quindi puoi eliminarla.

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

Passaggio 4: preprocessa i dati#

Per fortuna, 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 affinché il modello possa elaborare immagini ed etichette. Al momento, la directory del set di dati caricato ha questa struttura:

Per impostazione predefinita, però, i modelli YOLO richiedono directory separate per immagini ed etichette all'interno delle suddivisioni train/val/test. Dobbiamo riorganizzare la directory secondo la struttura seguente:

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

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

Poi, dobbiamo modificare il file .yaml del set di dati. Questa è la configurazione che useremo nel file .yaml. Gli 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 lo script seguente per eliminare il contenuto attuale di config.yaml e sostituirlo con la configurazione che riflette la nuova struttura della directory del set di dati. Lo script usa automaticamente la variabile work_dir definita in precedenza, quindi assicurati che punti al tuo set di dati prima di eseguirlo 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 mettere a punto un modello YOLO26 preaddestrato predefinito.

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

Vediamo più da vicino i parametri del comando di addestramento del modello:

• detect: l'attività di visione artificiale per cui usi il modello YOLO e il set di dati specificati.
• train: la modalità, che indica lo scopo per cui carichi il modello e i dati specificati. In seguito, quando verificheremo le prestazioni del modello, useremo predict.
• epochs: indica il numero di volte in cui YOLO26 elaborerà l'intero set di dati.
• batch: il valore numerico specifica le dimensioni dei batch di addestramento. I batch corrispondono al numero di immagini elaborate dal modello prima di aggiornare i propri parametri.
• plots: indica a YOLO di generare e salvare grafici delle metriche di addestramento e valutazione del modello.

Per comprendere nel dettaglio il processo di addestramento del modello e le procedure consigliate, consulta la guida all'addestramento dei modelli YOLO26. Questa guida ti aiuterà a ottenere il massimo dalle tue sperimentazioni e a usare YOLO26 in modo efficace.

Passaggio 6: testa il modello#

Ora possiamo eseguire l'inferenza per verificare le prestazioni del modello messo a punto:

!yolo detect 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 set di test e nuovi file immagine di output, sovrapponendo la bounding box prevista all'immagine originale.

Le etichette .txt previste per ogni immagine vengono salvate tramite l'argomento save_txt=True, mentre le immagini di output con le bounding box sovrapposte 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 le bounding box della stessa classe con una sovrapposizione pari o superiore al 50%. Questo aiuta a ridurre le potenziali bounding box duplicate generate per lo stesso oggetto. Possiamo caricare le immagini con le bounding box previste sovrapposte per vedere le prestazioni del modello su alcune 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 le bounding box previste, accompagnate dalle etichette dei nomi delle classi e dai livelli di confidenza.

Passaggio 7: valuta il modello#

Possiamo generare visualizzazioni della precisione e del richiamo del modello per ogni classe. Queste visualizzazioni vengono salvate nella directory dell'esecuzione di addestramento ({work_dir}/runs/detect/train/). Il punteggio di precisione è mostrato in BoxP_curve.png:

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

Il grafico del richiamo (BoxR_curve.png) mostra un andamento inverso:

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

Passaggio 8: calcola l'intersezione sull'unione#

Puoi misurare l'accuratezza delle previsioni calcolando l'IoU tra una bounding box prevista e una bounding box di ground truth per lo stesso oggetto. Per maggiori dettagli, consulta il tutorial IBM sull'addestramento di YOLO26.

Riepilogo#

Abbiamo esaminato le funzionalità principali di IBM Watsonx e come addestrare un modello YOLO26 usando IBM Watsonx. Abbiamo anche visto come IBM Watsonx possa migliorare i flussi di lavoro di AI con strumenti avanzati per la creazione dei modelli, la gestione dei dati e la conformità.

Per maggiori dettagli sull'utilizzo, consulta la documentazione ufficiale di IBM Watsonx.

Assicurati anche di consultare la pagina delle guide alle integrazioni di Ultralytics per saperne di più sulle diverse integrazioni disponibili.

Domande frequenti#