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

Al giorno d'oggi, le soluzioni di computer vision scalabili sono sempre più comuni e stanno trasformando il modo in cui gestiamo i dati visivi. Un ottimo esempio è IBM Watsonx, una piattaforma avanzata per l'AI e i 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 un'integrazione perfetta con i servizi IBM Cloud.

Puoi addestrare i modelli Ultralytics YOLO26 utilizzando IBM Watsonx. È una buona opzione per le aziende interessate a un addestramento dei modelli efficiente, al fine-tuning per attività specifiche e al miglioramento delle prestazioni dei modelli con strumenti robusti e 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. Iniziamo!

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 end-to-end affidabile, in grado di accelerare i progetti di AI finalizzati alla risoluzione di problemi aziendali. Fornisce 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 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 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à dedicate a diversi aspetti dell'AI e della gestione dei dati. Analizziamoli 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 distribuzioni cloud e on-premises tramite l'integrazione con IBM Storage Fusion HCI. La sua console intuitiva fornisce 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 la rilevanza nell'AI e supporta formati di dati aperti per condividere facilmente 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 interni sui rischi e fornisce schede informative aggiornate sull'AI. La piattaforma aiuta a gestire i rischi 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 intuitive e strumenti di reporting.

Come addestrare YOLO26 utilizzando IBM Watsonx#

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

Prerequisiti#

Ti serve un account IBM Cloud per creare un progetto watsonx.ai e ti serve anche un account Kaggle per caricare il set di dati.

Passaggio 1: configura 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 Jupyter Notebook.

Dopo averlo fatto, si aprirà un ambiente notebook in cui potrai caricare il tuo set di dati. Puoi utilizzare 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 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 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 utilizzeremo 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 in immagini subacquee.

Possiamo caricare il set di dati direttamente nel notebook utilizzando 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 "Credenziali API".

Copia e incolla il tuo nome utente Kaggle e la chiave API nel codice seguente. Esegui quindi 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/cartelle: un file config.yaml, una directory videos_for_testing e una directory dataset. Ignoreremo la directory videos_for_testing, quindi puoi eliminarla.

Utilizzeremo il file config.yaml e i contenuti 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#

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

Tuttavia, per impostazione predefinita i modelli YOLO richiedono immagini e annotazioni separate in sottodirectory all'interno della suddivisione train/val/test. Dobbiamo riorganizzare la directory nella struttura seguente:

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 del set di dati. Questa è la configurazione che utilizzeremo nel file .yaml. Gli ID numerici 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 eliminare il contenuto corrente di config.yaml e sostituirlo con la configurazione che riflette la nuova struttura della directory del set di dati. Lo script utilizza automaticamente la variabile work_dir definita in precedenza, quindi assicurati che punti al tuo set di dati 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 eseguire il fine-tuning di un modello YOLO26 preaddestrato con la configurazione predefinita.

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

Ecco un'analisi più dettagliata dei parametri nel comando di addestramento del modello:

• detect: La computer vision attività per cui utilizzi il modello YOLO e il set di dati specificati.
• train: La modalità, che indica lo scopo per cui stai caricando il modello e i dati specificati. Più tardi, quando testeremo le prestazioni del modello, utilizzeremo predict.
• epochs: delimita il numero di volte in cui YOLO26 passerà attraverso l'intero set di dati.
• batch: il valore numerico specifica le dimensioni dei batch di addestramento. I batch sono il numero di immagini che un modello elabora prima di aggiornare i propri 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 modello.

Per una comprensione dettagliata del processo di addestramento dei modelli e delle best practice, consulta la guida all'addestramento dei modelli YOLO26. Questa guida ti aiuterà a ottenere il massimo dai tuoi esperimenti e a utilizzare YOLO26 in modo efficace.

Passaggio 6: testa il modello#

Ora possiamo eseguire l'inferenza per testare le prestazioni del modello sottoposto a fine-tuning:

!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 annotazioni predette per ogni immagine del set di test, oltre a nuovi file di immagini di output che sovrappongono il riquadro delimitatore predetto all'immagine originale.

Le annotazioni .txt predette per ogni immagine vengono salvate tramite l'argomento save_txt=True, mentre le immagini di output con i riquadri delimitatori sovrapposti vengono generate tramite l'argomento save=True. Il parametro conf=0.5 informa il modello di ignorare tutte le predizioni con un livello di confidenza inferiore al 50%.

Infine, iou=.5 indica al modello di ignorare i riquadri della stessa classe con una sovrapposizione pari o superiore al 50%. Questo aiuta a ridurre i potenziali riquadri duplicati generati per lo stesso oggetto. Possiamo caricare le immagini con i riquadri delimitatori predetti sovrapposti per osservare 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 precedente visualizza dieci immagini dal set di test con i relativi riquadri delimitatori predetti, accompagnati dalle etichette dei nomi delle classi e dai livelli di confidenza.

Passaggio 7: valuta il modello#

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

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

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

A differenza della precisione, la recall si muove nella direzione opposta, mostrando una recall maggiore con istanze a bassa confidenza e una recall minore con istanze ad alta confidenza. Questo è un esempio appropriato del compromesso tra precisione e recall nei modelli di classificazione.

Passaggio 8: calcola l'Intersezione sull'unione#

Puoi misurare l'accuratezza delle predizioni calcolando IoU tra un riquadro delimitatore predetto e un riquadro delimitatore di riferimento per lo stesso oggetto. Consulta il tutorial di IBM sull'addestramento di YOLO26 per maggiori dettagli.

Riepilogo#

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

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

Assicurati inoltre di consultare la pagina della guida alle integrazioni di Ultralytics per saperne di più sulle diverse integrazioni disponibili.

FAQ#