Guida passo passo all'addestramento dei modelli YOLO11 con IBM Watsonx

Oggi le soluzioni di computer vision 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 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'IA e una perfetta integrazione con i servizi IBM Cloud.

È possibile addestrare i modelli diUltralytics YOLO11 utilizzando IBM Watsonx. Si tratta di una buona opzione per le aziende interessate a un addestramento efficiente dei modelli, alla loro messa a punto per attività specifiche e al miglioramento delle prestazioni dei modelli con strumenti robusti e un'impostazione facile da usare. In questa guida vi guideremo attraverso il processo di addestramento di YOLO11 con IBM Watsonx, dalla configurazione dell'ambiente alla valutazione dei modelli addestrati. Iniziamo!

Che cos'è IBM Watsonx?

Watsonx è la piattaforma cloud-based di IBM progettata per l'IA generativa 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 end-to-end e affidabile, in grado di accelerare i progetti di IA volti a risolvere i problemi aziendali. Fornisce strumenti potenti per la creazione, l'addestramento e la distribuzione di modelli di apprendimento automatico e semplifica la connessione con varie fonti di dati.

La sua interfaccia user-friendly e le sue capacità 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 IA, IBM Watsonx fornisce gli strumenti e il supporto necessari per promuovere l'innovazione.

Caratteristiche principali di IBM Watsonx

IBM Watsonx è costituito da tre componenti principali: watsonx.ai, watsonx.data e watsonx.governance. Ogni componente offre funzionalità che si rivolgono a diversi aspetti dell'IA e della gestione dei dati. Vediamoli da vicino.

Watsonx.ai

Watsonx.ai fornisce potenti strumenti per lo sviluppo dell'IA e offre accesso a modelli personalizzati supportati da IBM, a modelli di terze parti come Llama 3 e ai modelli Granite di IBM. Include il Prompt Lab per sperimentare con i prompt dell'intelligenza artificiale, il Tuning Studio per migliorare le prestazioni del modello con dati etichettati e il Flows Engine per semplificare lo sviluppo di applicazioni di intelligenza artificiale generativa. Inoltre, offre strumenti completi per automatizzare il ciclo di vita dei modelli di IA e per connettersi a varie API e librerie.

Watsonx.data

Watsonx.data supporta implementazioni sia in cloud che on-premise grazie all'integrazione con IBM Storage Fusion HCI. La sua console di facile utilizzo fornisce un accesso centralizzato ai dati in tutti gli ambienti e semplifica l'esplorazione dei dati con il comune SQL. Ottimizza i carichi di lavoro con motori di query efficienti come Presto e Spark, accelera gli approfondimenti sui dati con un livello semantico alimentato dall'intelligenza artificiale, include un database vettoriale per la rilevanza dell'intelligenza artificiale e supporta formati di dati aperti per una facile condivisione di dati analitici e di intelligenza artificiale.

Watsonx.governance

Watsonx.governance semplifica la conformità identificando automaticamente le modifiche normative e applicando le politiche. Collega i requisiti ai dati di rischio interni e fornisce schede informative aggiornate sull'intelligenza artificiale. La piattaforma aiuta a gestire il rischio con avvisi e strumenti per rilevare problemi quali distorsioni e derive. Inoltre, automatizza 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 e strumenti di reporting di facile utilizzo.

Come addestrare YOLO11 utilizzando IBM Watsonx

È possibile utilizzare IBM Watsonx per accelerare il flusso di lavoro di formazione dei modelli YOLO11 .

Prerequisiti

È necessario un account IBM Cloud per creare un progetto watsonx.ai e un account Kaggle per caricare il set di dati.

Fase 1: Impostazione dell'ambiente

Innanzitutto, è necessario configurare un account IBM per utilizzare un Jupyter Notebook. Accedere a watsonx.ai utilizzando il proprio account IBM Cloud.

Quindi, creare un progetto watsonx.ai e un blocco note Jupyter.

Una volta fatto ciò, si aprirà un ambiente notebook per caricare il set di dati. È possibile utilizzare il codice di questa esercitazione per affrontare un semplice compito di addestramento del modello di rilevamento degli oggetti.

Passo 2: Installare e importare le librerie rilevanti

Successivamente, è possibile installare e importare le librerie Python necessarie.

# Install the required packages
pip install torch torchvision torchaudio
pip install opencv-contrib-python-headless
pip install ultralytics==8.0.196

Per istruzioni dettagliate e buone pratiche relative al processo di installazione, consultare la nostra Guida all'installazione diUltralytics . Durante l'installazione dei pacchetti necessari per YOLO11, se si incontrano difficoltà, consultare la nostra guida ai problemi comuni per trovare soluzioni e suggerimenti.

Quindi, è possibile importare i pacchetti necessari.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Passo 3: caricare i dati

Per questa esercitazione, utilizzeremo un set di dati sui rifiuti marini disponibile su Kaggle. Con questo set di dati, addestreremo un modello YOLO11 per rilevare e classificare i rifiuti e gli oggetti biologici nelle immagini subacquee.

Possiamo caricare il set di dati direttamente nel notebook utilizzando l'API di Kaggle. Innanzitutto, creare un account Kaggle gratuito. Una volta creato l'account, è necessario generare una chiave API. Le istruzioni per generare la chiave si trovano nella documentazione dell'API di Kaggle, nella sezione "Credenziali API".

Copiare e incollare il nome utente e la chiave API di Kaggle nel codice seguente. Quindi eseguire 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 nostra directory di lavoro. Abbiamo anche stampato il contenuto della nostra directory di lavoro per confermare che il set di dati "trash_ICRA19" è stato caricato correttamente.

Se tra i contenuti della cartella compare "trash_ICRA19", il caricamento è avvenuto correttamente. Dovrebbero essere presenti tre file/cartelle: a config.yaml un file videos_for_testing e una cartella dataset directory. Ignoreremo il campo videos_for_testing quindi non esitate a cancellarla.

Utilizzeremo il file config.yaml e il contenuto della cartella dei dati per addestrare il nostro modello di rilevamento degli oggetti. Ecco un'immagine campione del nostro set di dati sui rifiuti marini.

Fase 4: Preelaborazione dei dati

Fortunatamente, 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 per aiutare il nostro modello a elaborare le immagini e le etichette. Al momento, la directory del set di dati caricato segue questa struttura:

Ma i modelli di YOLO richiedono per impostazione predefinita immagini ed etichette separate in sottodirectory all'interno della divisione train/val/test. È necessario riorganizzare la directory nella seguente struttura:

Per riorganizzare la directory dei set di dati, si può 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") 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, occorre modificare il file .yaml per il set di dati. Questa è l'impostazione che useremo nel nostro file .yaml. I numeri di 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

Eseguire il seguente script per cancellare il contenuto attuale di config.yaml e sostituirlo con il contenuto precedente, che riflette la nuova struttura delle directory dell'insieme di dati. Assicurarsi di sostituire la porzione work_dir del percorso della directory principale nella riga 4 con il percorso della propria directory di lavoro recuperata in precedenza. Lasciare le definizioni delle sottodirectory train, val e test. Inoltre, non modificate {work_dir} nella riga 23 del codice.

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

Fase 5: addestramento del modello YOLO11

Eseguire il seguente codice a riga di comando per perfezionare un modello predefinito preaddestrato YOLO11 .

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

Ecco un'analisi più approfondita dei parametri del comando di formazione del modello:

• task: specifica l'attività di computer vision per la quale si sta utilizzando il modello YOLO e il set di dati specificato.
• modalità: Indica lo scopo per cui si caricano il modello e i dati specificati. Poiché stiamo addestrando un modello, è impostato su "addestra". In seguito, quando verificheremo le prestazioni del modello, lo imposteremo su "predict".
• epochs: delimita il numero di volte in cui YOLO11 passerà attraverso l'intero set di dati.
• batch: Il valore numerico stabilisce le dimensioni dei batch di addestramento. I batch sono il numero di immagini che un modello elabora prima di aggiornare i suoi parametri.
• lr0: specifica il tasso di apprendimento iniziale del modello.
• plots: Indica a YOLO di generare e salvare i grafici delle metriche di addestramento e di valutazione del modello.

Per una comprensione dettagliata del processo di formazione del modello e delle migliori pratiche, consultare la guidaYOLO11 Model Training. Questa guida vi aiuterà a ottenere il massimo dai vostri esperimenti e a garantire un uso efficace di YOLO11 .

Fase 6: Prova del modello

Ora possiamo eseguire l'inferenza per verificare le prestazioni del nostro modello perfezionato:

!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 le etichette previste per ogni immagine del nostro set di test, nonché nuovi file immagine di output che sovrappongono il rettangolo di selezione previsto all'immagine originale.

Le etichette .txt previste per ogni immagine vengono salvate tramite il comando save_txt=True e le immagini di output con le sovrapposizioni dei riquadri di delimitazione sono generate attraverso il metodo save=True argomento.
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 caselle della stessa classe con una sovrapposizione pari o superiore al 50%. Ciò contribuisce a ridurre i potenziali duplicati delle caselle generate per lo stesso oggetto.
possiamo caricare le immagini con le sovrapposizioni dei riquadri di delimitazione previsti per vedere come si comporta il nostro modello su una manciata 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 qui sopra visualizza dieci immagini del set di test con i relativi riquadri di delimitazione previsti, accompagnati dalle etichette dei nomi delle classi e dai livelli di confidenza.

Fase 7: valutazione del modello

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

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

Il grafico di richiamo (R_curve.png) mostra una tendenza inversa:

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

Fase 8: Calcolo dell'intersezione sopra l'unione

È possibile misurare l'accuratezza della previsione calcolando l'IoU tra un riquadro di delimitazione previsto e un riquadro di delimitazione della verità a terra per lo stesso oggetto. Per maggiori dettagli, consultare il tutorial di IBM sull'addestramento di YOLO11.

Sintesi

Abbiamo esplorato le caratteristiche principali di IBM Watsonx e come addestrare un modello YOLO11 utilizzando IBM Watsonx. Abbiamo anche visto come IBM Watsonx può migliorare i vostri flussi di lavoro AI con strumenti avanzati per la creazione di modelli, la gestione dei dati e la conformità.

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

Inoltre, per saperne di più sulle diverse e interessanti integrazioni, consultate la pagina della guida alle integrazioni diUltralytics .

FAQ

Come si addestra un modello YOLO11 utilizzando IBM Watsonx?

Per addestrare un modello YOLO11 utilizzando IBM Watsonx, seguire i seguenti passaggi:

1. Configurare l'ambiente: Creare un account IBM Cloud e impostare un progetto Watsonx.ai. Utilizzare un Jupyter Notebook per l'ambiente di codifica.
2. Installare le librerie: Installare le librerie necessarie come torch, opencv, e ultralytics.
3. Caricare i dati: Utilizzare l'API di Kaggle per caricare il set di dati in Watsonx.
4. Preelaborazione dei dati: Organizzare il set di dati nella struttura di directory richiesta e aggiornare il file .yaml file di configurazione.
5. Addestrare il modello: Usare l'interfaccia a riga di comando YOLO per addestrare il modello con parametri specifici come epochs, batch size, e learning rate.
6. Test e valutazione: Eseguire l'inferenza per testare il modello e valutarne le prestazioni utilizzando metriche come precisione e richiamo.

Per istruzioni dettagliate, consultare la nostra guida all'addestramento dei modelliYOLO11 .

Quali sono le caratteristiche principali di IBM Watsonx per l'addestramento di modelli di intelligenza artificiale?

IBM Watsonx offre diverse funzioni chiave per l'addestramento dei modelli di intelligenza artificiale:

• Watsonx.ai: Fornisce strumenti per lo sviluppo dell'IA, compreso l'accesso a modelli personalizzati supportati da IBM e a 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. Include Prompt Lab, Tuning Studio e Flows Engine per una gestione completa del ciclo di vita dell'IA.
• Watsonx.data: Supporta implementazioni in cloud e on-premise, offrendo accesso centralizzato ai dati, motori di interrogazione efficienti come Presto e Spark e un livello semantico alimentato dall'intelligenza artificiale.
• Watsonx.governance: Automatizza la conformità, gestisce i rischi con gli avvisi e fornisce strumenti per rilevare problemi come distorsioni e derive. Include anche dashboard e strumenti di reporting per la collaborazione.

Per ulteriori informazioni, visitate la documentazione ufficiale di IBM Watsonx.

Perché dovrei usare IBM Watsonx per addestrare i modelli di Ultralytics YOLO11 ?

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

• Scalabilità: Scalate facilmente il vostro modello di formazione con i servizi IBM Cloud.
• Integrazione: Integrazione perfetta con varie fonti di dati e API.
• Interfaccia facile da usare: 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.

Per saperne di più su Ultralytics YOLO11 e come addestrare i modelli utilizzando IBM Watsonx nella nostra guida all'integrazione.

Come posso preelaborare il mio set di dati per l'addestramento di YOLO11 su IBM Watsonx?

Per preelaborare il set di dati per l'addestramento di YOLO11 su IBM Watsonx:

1. Organizzare le directory: Assicurarsi che il set di dati segua la struttura di directory YOLO con sottodirectory separate per le immagini e le etichette all'interno della divisione train/val/test.
2. Aggiornare il file .yaml: Modificare il .yaml per riflettere la nuova struttura delle cartelle e i nomi delle classi.
3. Eseguire lo script di preelaborazione: Utilizzare uno script Python per riorganizzare il dataset e aggiornare i dati .yaml file di conseguenza.

Ecco un esempio di script per organizzare il vostro set di dati:

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, consultare la nostra guida alla pre-elaborazione dei dati.

Quali sono i prerequisiti per addestrare un modello YOLO11 su IBM Watsonx?

Prima di iniziare l'addestramento di un modello YOLO11 su IBM Watsonx, assicurarsi di disporre dei seguenti prerequisiti:

• Account IBM Cloud: Creare un account su IBM Cloud per accedere a Watsonx.ai.
• Account Kaggle: Per caricare i set di dati, è necessario un account Kaggle e una chiave API.
• Notebook Jupyter: Impostare un ambiente Jupyter Notebook all'interno di Watsonx.ai per la codifica e l'addestramento dei modelli.

Per ulteriori informazioni sulla configurazione dell'ambiente, visitate la nostra guida all'installazione diUltralytics .

📅C reato 4 mesi fa ✏️ Aggiornato 2 mesi fa

Commenti