Guida passo dopo passo all'addestramento di modelli YOLO26 con IBM Watsonx
Oggigiorno, 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, il deployment e la gestione dei modelli di AI. Offre una suite completa per l'intero ciclo di vita dell'AI e un'integrazione fluida 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 attività specifiche e al miglioramento delle prestazioni del modello con strumenti robusti e una configurazione user-friendly. In questa guida, ti accompagneremo nel processo di addestramento di YOLO26 con IBM Watsonx, coprendo tutto, dalla configurazione dell'ambiente alla valutazione dei tuoi modelli addestrati. Iniziamo!
Cos'è IBM Watsonx?
Watsonx è la piattaforma basata su cloud 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 AI end-to-end affidabile che può accelerare i progetti di AI mirati alla risoluzione di problemi aziendali. Fornisce strumenti potenti per costruire, addestrare e effettuare il deployment di modelli di machine learning e semplifica la connessione con varie fonti di dati.
La sua interfaccia intuitiva e le capacità di collaborazione semplificano il processo di sviluppo e aiutano nella gestione e nel deployment efficiente del modello. Che si tratti di computer vision, analisi predittiva, elaborazione del linguaggio naturale o altre applicazioni di AI, IBM Watsonx fornisce gli strumenti e il supporto necessari per guidare l'innovazione.
Caratteristiche principali di IBM Watsonx
IBM Watsonx è composto da tre componenti principali: watsonx.ai, watsonx.data e watsonx.governance. Ogni componente offre funzionalità che soddisfano diversi aspetti dell'AI e della gestione dei dati. Diamo loro un'occhiata più da vicino.
Watsonx.ai
Watsonx.ai fornisce potenti strumenti per lo sviluppo di AI e offre accesso a modelli personalizzati supportati da IBM, modelli di terze parti come Llama 3 e i modelli Granite di IBM. Include il Prompt Lab per sperimentare con i prompt di AI, il Tuning Studio per migliorare le prestazioni del modello con dati etichettati e il Flows Engine per semplificare lo sviluppo di applicazioni di AI generativa. Inoltre, offre strumenti completi per automatizzare il ciclo di vita del modello AI e connettersi a varie API e librerie.
Watsonx.data
Watsonx.data supporta sia deployment cloud che on-premises attraverso l'integrazione IBM Storage Fusion HCI. La sua console intuitiva fornisce un accesso centralizzato ai dati in vari ambienti e rende facile l'esplorazione dei dati con SQL comune. Ottimizza i carichi di lavoro con motori di query efficienti come Presto e Spark, accelera gli insight sui dati con un layer semantico basato su AI, include un database vettoriale per la pertinenza dell'AI e supporta formati di dati aperti per una facile condivisione di analytics e dati AI.
Watsonx.governance
Watsonx.governance rende la conformità più facile identificando automaticamente le modifiche normative 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 reportistica intuitivi.
Come addestrare YOLO26 usando IBM Watsonx
Puoi utilizzare IBM Watsonx per accelerare il tuo flusso di lavoro di addestramento del modello YOLO26.
Prerequisiti
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.
Passaggio 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 ciò, si aprirà un ambiente notebook per caricare il tuo set di dati. Puoi usare il codice di questo tutorial per affrontare un semplice compito di addestramento di un modello di object detection.
Passaggio 2: Installa e importa le librerie rilevanti
Successivamente, puoi installare e importare le librerie Python necessarie.
# Install the required packages
pip install torch torchvision torchaudio
pip install ultralytics-opencv-headlessPer istruzioni dettagliate e best practice relative al processo di installazione, controlla la nostra guida all'installazione di Ultralytics. Se durante l'installazione dei pacchetti richiesti per YOLO26 riscontri difficoltà, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.
Quindi, puoi importare i pacchetti necessari.
# Import ultralytics
import ultralytics
ultralytics.checks()
# Import packages to retrieve and display image filesPassaggio 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 di Kaggle. Innanzitutto, crea un account Kaggle gratuito. Una volta creato l'account, dovrai generare una chiave API. Le istruzioni per generare la tua chiave si trovano nella documentazione dell'API di Kaggle sotto la sezione "API credentials".
Copia e incolla il tuo nome utente Kaggle e la tua chiave API nel codice seguente. Quindi esegui il codice per installare l'API e caricare il dataset in Watsonx.
# Install kaggle
pip install kaggleDopo aver installato Kaggle, possiamo caricare il dataset 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 dataset, abbiamo stampato e salvato la nostra directory di lavoro. Abbiamo anche stampato il contenuto della nostra directory di lavoro per confermare che il dataset "trash_ICRA19" sia stato caricato correttamente.
Se vedi "trash_ICRA19" tra i contenuti della directory, significa che è stato caricato correttamente. 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 dataset di rifiuti marini.
Passaggio 4: Preelabora i dati
Fortunatamente, tutte le etichette nel dataset dei 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 immagini ed etichette. Al momento, la nostra directory del dataset caricato segue questa struttura:
Tuttavia, i modelli YOLO richiedono per impostazione predefinita immagini ed etichette separate in sottodirectory all'interno dello split train/val/test. Dobbiamo riorganizzare la directory nella seguente struttura:
Per riorganizzare la directory del dataset, 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") 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 dataset. Questa è la configurazione che useremo nel nostro file .yaml. I numeri 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: rovEsegui 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 dataset. Lo script usa 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.
# 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 effettuare il fine-tuning di un modello YOLO26 predefinito.
!yolo task=detect mode=train data={work_dir}/trash_ICRA19/config.yaml model=yolo26n.pt epochs=2 batch=32 lr0=.04 plots=TrueEcco un'occhiata più da vicino ai parametri nel comando di addestramento del modello:
- task: Specifica l'attività di computer vision per cui stai usando il modello YOLO e il dataset 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 il nostro intero dataset.
- 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: Indica a YOLO di 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 best practice, fai riferimento alla guida all'addestramento 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: Testa il modello
Ora possiamo eseguire l'inferenza per testare 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=TrueQuesto breve script genera etichette previste per ogni immagine nel nostro set di test, 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 informa il modello di ignorare tutte le previsioni con un livello di confidenza inferiore al 50%.
Infine, iou=.5 indica al modello di ignorare i box nella stessa classe con una sovrapposizione pari o superiore al 50%. Aiuta a ridurre potenziali box duplicati generati per lo stesso oggetto.
Possiamo caricare le immagini con le sovrapposizioni di bounding box previste 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 sopra visualizza dieci immagini dal set di test con i loro bounding box previsti, accompagnati da etichette dei nomi delle classi e livelli di confidenza.
Passaggio 7: Valuta il modello
Possiamo produrre visualizzazioni della precisione e del recall del modello per ogni classe. Queste visualizzazioni vengono salvate nella home directory, sotto la cartella train. Il punteggio di precisione viene visualizzato nel P_curve.png:
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 determinato livello di confidenza dopo due epoche.
Il grafico del recall (R_curve.png) mostra una tendenza inversa:
A differenza della precisione, il recall si muove nella direzione opposta, mostrando un recall maggiore con istanze a bassa confidenza e un recall minore con istanze ad alta confidenza. Questo è un esempio calzante del compromesso tra precisione e recall per i modelli di classificazione.
Passaggio 8: Calcolo della Intersection Over Union
Puoi misurare l'accuratezza della previsione calcolando lo IoU tra un bounding box previsto e un bounding box di ground truth per lo stesso oggetto. Dai un'occhiata al tutorial di IBM sull'addestramento di YOLO26 per maggiori dettagli.
Riepilogo
Abbiamo esplorato le caratteristiche chiave di IBM Watsonx e come addestrare un modello YOLO26 usando IBM Watsonx. Abbiamo anche visto come IBM Watsonx possa migliorare i tuoi flussi di lavoro AI 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 controllare la pagina della guida all'integrazione di Ultralytics, per saperne di più su diverse integrazioni entusiasmanti.
FAQ
Come addestro un modello YOLO26 usando IBM Watsonx?
Per addestrare un modello YOLO26 usando IBM Watsonx, segui questi passaggi:
- Configura il tuo ambiente: Crea un account IBM Cloud e configura un progetto Watsonx.ai. Usa un Jupyter Notebook per il tuo ambiente di programmazione.
- Installa le librerie: Installa le librerie necessarie come
torch,opencveultralytics. - Carica i dati: Usa l'API di Kaggle per caricare il tuo dataset in Watsonx.
- Preelabora i dati: Organizza il tuo dataset nella struttura di directory richiesta e aggiorna il file di configurazione
.yaml. - Addestra il modello: Usa l'interfaccia da riga di comando YOLO per addestrare il tuo modello con parametri specifici come
epochs,batch sizeelearning rate. - Testa e valuta: Esegui l'inferenza per testare il modello e valutarne le prestazioni usando metriche come precisione e recall.
Per istruzioni dettagliate, fai riferimento alla nostra guida all'addestramento del modello YOLO26.
Quali sono le caratteristiche principali di IBM Watsonx per l'addestramento di modelli di AI?
IBM Watsonx offre diverse caratteristiche chiave per l'addestramento di modelli di AI:
- Watsonx.ai: Fornisce strumenti per lo sviluppo di AI, incluso l'accesso a modelli personalizzati supportati da IBM e modelli di terze parti come Llama 3. Include il Prompt Lab, il Tuning Studio e il Flows Engine per una gestione completa del ciclo di vita dell'AI.
- Watsonx.data: Supporta deployment cloud e on-premises, offrendo accesso centralizzato ai dati, motori di query efficienti come Presto e Spark e un layer semantico basato su AI.
- 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.
Perché dovrei usare IBM Watsonx per addestrare i modelli Ultralytics YOLO26?
IBM Watsonx è una scelta eccellente per l'addestramento dei modelli Ultralytics YOLO26 grazie alla sua suite completa di strumenti che semplificano il ciclo di vita dell'AI. I vantaggi principali includono:
- Scalabilità: Scala facilmente il tuo addestramento del modello con i servizi IBM Cloud.
- Integrazione: Integrati perfettamente 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 il Prompt Lab, il Tuning Studio e il Flows Engine per migliorare le prestazioni del modello.
Scopri di più su Ultralytics YOLO26 e su come addestrare i modelli usando IBM Watsonx nella nostra guida all'integrazione.
Come 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 YOLO con sottodirectory separate per immagini ed etichette all'interno dello split train/val/test.
- Aggiorna il file .yaml: Modifica il file di configurazione
.yamlper riflettere la nuova struttura della directory e i nomi delle classi. - Esegui lo script di preelaborazione: Usa uno script Python per riorganizzare il tuo dataset e aggiornare il file
.yamldi conseguenza.
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 ulteriori dettagli, fai riferimento alla nostra guida alla preelaborazione dei dati.
Quali sono i prerequisiti per addestrare un modello YOLO26 su IBM Watsonx?
Prima di iniziare ad addestrare 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, ti serviranno un account Kaggle e una API key.
- 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.