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 per 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 con 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 con strumenti affidabili 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 AI end-to-end affidabile, in grado di accelerare i progetti AI volti a risolvere problemi aziendali. Offre strumenti potenti per creare, addestrare e distribuire modelli di machine learning, oltre a semplificare la connessione a diverse fonti di dati.

La sua interfaccia intuitiva e le funzionalità collaborative semplificano il processo di sviluppo e favoriscono una gestione e un deployment efficienti dei modelli. Per la visione artificiale, l'analisi predittiva, l'elaborazione del linguaggio naturale o altre applicazioni 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à per diversi aspetti della gestione dell'AI e dei dati. Vediamoli più da vicino.

Watsonx.ai#

Watsonx.ai offre strumenti potenti per lo sviluppo AI e dà 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 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 AI e connettersi a varie API e librerie.

Watsonx.data#

Watsonx.data supporta deployment sia cloud sia on-premises tramite l'integrazione IBM Storage Fusion HCI. La sua console intuitiva offre accesso centralizzato ai dati in tutti gli 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 rilevanza dell'AI e supporta formati di dati aperti per facilitare la condivisione di dati analitici e AI.

Watsonx.governance#

Watsonx.governance semplifica la conformità individuando automaticamente le modifiche normative e applicando le policy. Collega i requisiti ai dati interni sui rischi e fornisce schede informative 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 AI con un inventario dei modelli e migliora la collaborazione con dashboard intuitive e strumenti di reportistica.

Come addestrare YOLO26 con IBM Watsonx#

Puoi usare IBM Watsonx per accelerare il flusso di lavoro di addestramento dei modelli 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, 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.

A questo punto si aprirà un ambiente notebook in cui potrai caricare il 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#

A questo punto 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 sulla procedura 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.

Poi 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. Trovi le istruzioni per generare la chiave nella sezione "API credentials" della documentazione dell'API Kaggle.

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 visualizzato e salvato la directory di lavoro. Abbiamo anche visualizzato il contenuto della directory di lavoro per verificare che il set di dati "trash_ICRA19" fosse stato caricato correttamente.

Se tra i contenuti della directory vedi "trash_ICRA19", 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.

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: preelabora i dati#

Per fortuna, tutte le etichette nel 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 per aiutare il modello a elaborarle. Al momento, la directory del set di dati caricato ha questa struttura:

Tuttavia, per impostazione predefinita i modelli YOLO richiedono immagini ed etichette separate in sottodirectory all'interno delle suddivisioni train/val/test. Dobbiamo riorganizzare la directory in questa struttura:

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)

Ora dobbiamo modificare il file .yaml del set di dati. Questa è la configurazione che useremo nel file .yaml. Gli ID delle classi 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 lo script seguente per eliminare il contenuto attuale di config.yaml e sostituirlo con la configurazione che rispecchia la nuova struttura delle directory del set di dati. Lo script usa automaticamente la variabile work_dir che abbiamo definito in precedenza, quindi verifica 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 codice da riga di comando seguente per ottimizzare un modello YOLO26 preaddestrato predefinito.

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

Ecco una panoramica più dettagliata dei parametri nel comando di addestramento del modello:

• detect: L'attività di visione artificiale per cui stai utilizzando il modello YOLO e il set di dati specificati.
• train: modalità che indica lo scopo per cui carichi il modello e i dati specificati. In seguito, quando testeremo 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 training. I batch corrispondono al numero di immagini che un modello elabora prima di aggiornare i propri parametri.
• plots: Indica a YOLO di generare e salvare i grafici delle metriche di training e valutazione del nostro modello.

Per comprendere nel dettaglio il processo di training del modello e le best practice, consulta la guida al training del modello YOLO26. Questa guida ti aiuterà a ottenere il massimo dai tuoi esperimenti e ad assicurarti di usare YOLO26 in modo efficace.

Passaggio 6: testare il modello#

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

!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 che sovrappongono il riquadro di delimitazione previsto all'immagine originale.

Le etichette .txt previste per ogni immagine vengono salvate tramite l'argomento save_txt=True, mentre le immagini di output con i riquadri di delimitazione 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 riquadri della stessa classe con una sovrapposizione pari o superiore al 50%. Questo aiuta a ridurre il numero di potenziali riquadri duplicati generati per lo stesso oggetto. Possiamo caricare le immagini con i riquadri di delimitazione previsti sovrapposti per vedere le prestazioni del nostro 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 mostra dieci immagini del set di test con i relativi riquadri di delimitazione previsti, accompagnati dalle etichette con i nomi delle classi e dai livelli di confidenza.

Passaggio 7: valutare il modello#

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

Il grafico mostra un aumento esponenziale della precisione all'aumentare del livello di confidenza delle previsioni del modello. Tuttavia, dopo due epoche, la precisione del modello non ha ancora raggiunto un plateau a un determinato livello di confidenza.

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

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

Passaggio 8: calcolare l'Intersection Over Union#

Puoi misurare la precisione delle previsioni calcolando l'IoU tra un riquadro di delimitazione previsto e un riquadro di delimitazione della verità di riferimento per lo stesso oggetto. Per maggiori dettagli, consulta il tutorial IBM sul training di YOLO26.

Riepilogo#

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

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

Inoltre, consulta la pagina della guida alle integrazioni di Ultralytics per scoprire altre interessanti integrazioni.

Domande frequenti#