Guía paso a paso para entrenar modelos YOLO26 con IBM Watsonx

Hoy en día, las soluciones de visión artificial escalables son cada vez más comunes y están transformando la forma en que gestionamos los datos visuales. Un gran ejemplo es IBM Watsonx, una plataforma avanzada de IA y datos que simplifica el desarrollo, la implementación y la gestión de modelos de IA. Ofrece un conjunto completo para todo el ciclo de vida de la IA y una integración perfecta con los servicios de IBM Cloud.

Puedes entrenar modelos Ultralytics YOLO26 usando IBM Watsonx. Es una buena opción para empresas interesadas en un entrenamiento de modelos eficiente, ajustes precisos para tareas específicas y la mejora del rendimiento del modelo con herramientas sólidas y una configuración intuitiva. En esta guía, te llevaremos a través del proceso de entrenamiento de YOLO26 con IBM Watsonx, cubriendo todo, desde la configuración de tu entorno hasta la evaluación de tus modelos entrenados. ¡Empecemos!

¿Qué es IBM Watsonx?

Watsonx es la plataforma basada en la nube de IBM diseñada para IA generativa comercial y datos científicos. Los tres componentes de IBM Watsonx: watsonx.ai, watsonx.data y watsonx.governance, se unen para crear una plataforma de IA integral y confiable que puede acelerar los proyectos de IA orientados a resolver problemas empresariales. Proporciona herramientas potentes para crear, entrenar e implementar modelos de aprendizaje automático y facilita la conexión con diversas fuentes de datos.

IBM Watsonx AI platform architecture overview

Su interfaz fácil de usar y sus capacidades de colaboración agilizan el proceso de desarrollo y ayudan a una gestión e implementación eficiente de los modelos. Ya sea para visión artificial, análisis predictivo, procesamiento del lenguaje natural u otras aplicaciones de IA, IBM Watsonx proporciona las herramientas y el soporte necesarios para impulsar la innovación.

Características clave de IBM Watsonx

IBM Watsonx está compuesto por tres componentes principales: watsonx.ai, watsonx.data y watsonx.governance. Cada componente ofrece características que cubren diferentes aspectos de la gestión de IA y datos. Echemos un vistazo más de cerca a ellos.

Watsonx.ai

Watsonx.ai proporciona herramientas potentes para el desarrollo de IA y ofrece acceso a modelos personalizados compatibles con IBM, modelos de terceros como Llama 3 y los modelos Granite de IBM. Incluye Prompt Lab para experimentar con prompts de IA, Tuning Studio para mejorar el rendimiento del modelo con datos etiquetados y Flows Engine para simplificar el desarrollo de aplicaciones de IA generativa. Además, ofrece herramientas integrales para automatizar el ciclo de vida de los modelos de IA y conectarse a varias API y bibliotecas.

Watsonx.data

Watsonx.data admite implementaciones tanto en la nube como en local a través de la integración IBM Storage Fusion HCI. Su consola fácil de usar proporciona un acceso centralizado a los datos en todos los entornos y facilita la exploración de datos con SQL común. Optimiza las cargas de trabajo con motores de consulta eficientes como Presto y Spark, acelera la obtención de conocimientos sobre los datos con una capa semántica impulsada por IA, incluye una base de datos vectorial para la relevancia de la IA y admite formatos de datos abiertos para compartir fácilmente analíticas y datos de IA.

Watsonx.governance

Watsonx.governance facilita el cumplimiento al identificar automáticamente los cambios normativos y hacer cumplir las políticas. Vincula los requisitos a los datos de riesgo internos y proporciona hojas informativas de IA actualizadas. La plataforma ayuda a gestionar el riesgo con alertas y herramientas para detectar problemas como sesgo y deriva. También automatiza el monitoreo y la documentación del ciclo de vida de la IA, organiza el desarrollo de IA con un inventario de modelos y mejora la colaboración con paneles y herramientas de informes fáciles de usar.

Cómo entrenar YOLO26 usando IBM Watsonx

Puedes usar IBM Watsonx para acelerar tu flujo de trabajo de entrenamiento de modelos YOLO26.

Requisitos previos

Necesitas una cuenta de IBM Cloud para crear un proyecto de watsonx.ai, y también necesitarás una cuenta de Kaggle para cargar el conjunto de datos.

Paso 1: Configura tu entorno

Primero, necesitarás configurar una cuenta de IBM para usar un Jupyter Notebook. Inicia sesión en watsonx.ai usando tu cuenta de IBM Cloud.

Luego, crea un proyecto de watsonx.ai y un Jupyter Notebook.

Una vez hecho esto, se abrirá un entorno de notebook para que cargues tu conjunto de datos. Puedes usar el código de este tutorial para abordar una tarea sencilla de entrenamiento de un modelo de detección de objetos.

Paso 2: Instala e importa las bibliotecas relevantes

A continuación, puedes instalar e importar las bibliotecas de Python necesarias.

Instalación

# Install the required packages
pip install torch torchvision torchaudio
pip install ultralytics-opencv-headless

Para obtener instrucciones detalladas y mejores prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalación de Ultralytics. Si encuentras alguna dificultad al instalar los paquetes necesarios para YOLO26, consulta nuestra guía de problemas comunes para obtener soluciones y consejos.

Luego, puedes importar los paquetes necesarios.

Importar bibliotecas relevantes

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Paso 3: Carga los datos

Para este tutorial, usaremos un conjunto de datos de residuos marinos disponible en Kaggle. Con este conjunto de datos, entrenaremos de forma personalizada un modelo YOLO26 para detectar y clasificar residuos y objetos biológicos en imágenes submarinas.

Podemos cargar el conjunto de datos directamente en el notebook usando la API de Kaggle. Primero, crea una cuenta gratuita de Kaggle. Una vez que hayas creado una cuenta, necesitarás generar una clave API. Las instrucciones para generar tu clave se pueden encontrar en la documentación de la API de Kaggle en la sección "API credentials".

Copia y pega tu nombre de usuario de Kaggle y tu clave API en el siguiente código. Luego ejecuta el código para instalar la API y cargar el conjunto de datos en Watsonx.

Instalación

# Install kaggle
pip install kaggle

Después de instalar Kaggle, podemos cargar el conjunto de datos en Watsonx.

Cargar los datos

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

Después de cargar el conjunto de datos, imprimimos y guardamos nuestro directorio de trabajo. También hemos impreso el contenido de nuestro directorio de trabajo para confirmar que el conjunto de datos "trash_ICRA19" se cargó correctamente.

Si ves "trash_ICRA19" entre el contenido del directorio, entonces se ha cargado correctamente. Deberías ver tres archivos/carpetas: un archivo config.yaml, un directorio videos_for_testing y un directorio dataset. Ignoraremos el directorio videos_for_testing, así que siéntete libre de eliminarlo.

Usaremos el archivo config.yaml y el contenido del directorio del conjunto de datos para entrenar nuestro modelo de detección de objetos. Aquí tienes una imagen de muestra de nuestro conjunto de datos de residuos marinos.

Marine Litter with Bounding Box

Paso 4: Preprocesa los datos

Afortunadamente, todas las etiquetas en el conjunto de datos de residuos marinos ya tienen el formato de archivos .txt de YOLO. Sin embargo, necesitamos reorganizar la estructura de los directorios de imágenes y etiquetas para ayudar a nuestro modelo a procesar las imágenes y las etiquetas. En este momento, nuestro directorio de conjunto de datos cargado sigue esta estructura:

Loaded Dataset Directory

Pero los modelos YOLO por defecto requieren imágenes y etiquetas separadas en subdirectorios dentro de la división train/val/test. Necesitamos reorganizar el directorio en la siguiente estructura:

YOLO Directory Structure

Para reorganizar el directorio del conjunto de datos, podemos ejecutar el siguiente script:

Preprocesar los datos

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

A continuación, necesitamos modificar el archivo .yaml para el conjunto de datos. Esta es la configuración que usaremos en nuestro archivo .yaml. Los números de ID de clase comienzan desde 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

Ejecuta el siguiente script para eliminar el contenido actual de config.yaml y reemplazarlo con la configuración que refleja nuestra nueva estructura de directorio de conjunto de datos. El script utiliza automáticamente la variable work_dir que definimos anteriormente, así que asegúrate de que apunte a tu conjunto de datos antes de la ejecución y deja las definiciones de los subdirectorios train, val y test sin cambios.

Edita el archivo .yaml

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

Paso 5: Entrena el modelo YOLO26

Ejecuta el siguiente código de línea de comandos para ajustar un modelo YOLO26 preentrenado por defecto.

Entrena el modelo YOLO26

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

Aquí tienes un vistazo más de cerca a los parámetros en el comando de entrenamiento del modelo:

task: Especifica la tarea de visión artificial para la cual estás usando el modelo YOLO y el conjunto de datos especificados.
mode: Denota el propósito para el cual estás cargando el modelo y los datos especificados. Dado que estamos entrenando un modelo, se establece en "train". Más adelante, cuando probemos el rendimiento de nuestro modelo, lo estableceremos en "predict".
epochs: Esto delimita el número de veces que YOLO26 pasará por todo nuestro conjunto de datos.
batch: El valor numérico estipula los tamaños de lote de entrenamiento. Los lotes son la cantidad de imágenes que procesa un modelo antes de actualizar sus parámetros.
lr0: Especifica la tasa de aprendizaje inicial del modelo.
plots: Indica a YOLO que genere y guarde gráficos de las métricas de entrenamiento y evaluación de nuestro modelo.

Para una comprensión detallada del proceso de entrenamiento de modelos y las mejores prácticas, consulta la guía de entrenamiento de modelos YOLO26. Esta guía te ayudará a aprovechar al máximo tus experimentos y a garantizar que estés utilizando YOLO26 de manera eficaz.

Paso 6: Prueba el modelo

Ahora podemos ejecutar la inferencia para probar el rendimiento de nuestro modelo ajustado:

Prueba el modelo YOLO26

!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

Este breve script genera etiquetas predichas para cada imagen en nuestro conjunto de prueba, así como nuevos archivos de imagen de salida que superponen la caja delimitadora predicha sobre la imagen original.

Las etiquetas .txt predichas para cada imagen se guardan a través del argumento save_txt=True y las imágenes de salida con superposiciones de cajas delimitadoras se generan a través del argumento save=True. El parámetro conf=0.5 informa al modelo que ignore todas las predicciones con un nivel de confianza inferior al 50%.

Por último, iou=.5 indica al modelo que ignore las cajas en la misma clase con una superposición del 50% o más. Ayuda a reducir las posibles cajas duplicadas generadas para el mismo objeto. Podemos cargar las imágenes con las superposiciones de cajas delimitadoras predichas para ver cómo funciona nuestro modelo en un puñado de imágenes.

Mostrar predicciones

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

El código anterior muestra diez imágenes del conjunto de prueba con sus cajas delimitadoras predichas, acompañadas de etiquetas de nombre de clase y niveles de confianza.

Paso 7: Evalúa el modelo

Podemos producir visualizaciones de la precisión y recuperación del modelo para cada clase. Estas visualizaciones se guardan en el directorio de inicio, bajo la carpeta train. La puntuación de precisión se muestra en P_curve.png:

Model precision-confidence evaluation curve

El gráfico muestra un aumento exponencial en la precisión a medida que aumenta el nivel de confianza del modelo para las predicciones. Sin embargo, la precisión del modelo aún no se ha estabilizado en un cierto nivel de confianza después de dos épocas.

El gráfico de recuperación (R_curve.png) muestra una tendencia inversa:

Model recall-confidence evaluation curve

A diferencia de la precisión, la recuperación se mueve en la dirección opuesta, mostrando una mayor recuperación con instancias de menor confianza y una menor recuperación con instancias de mayor confianza. Este es un ejemplo adecuado de la compensación entre precisión y recuperación para los modelos de clasificación.

Paso 8: Cálculo de la Intersección sobre Unión

Puedes medir la precisión de la predicción calculando la IoU entre una caja delimitadora predicha y una caja delimitadora de verdad fundamental para el mismo objeto. Echa un vistazo al tutorial de IBM sobre entrenamiento de YOLO26 para obtener más detalles.

Resumen

Exploramos las características clave de IBM Watsonx y cómo entrenar un modelo YOLO26 usando IBM Watsonx. También vimos cómo IBM Watsonx puede mejorar tus flujos de trabajo de IA con herramientas avanzadas para la creación de modelos, gestión de datos y cumplimiento.

Para obtener más detalles sobre el uso, visita la documentación oficial de IBM Watsonx.

Además, asegúrate de revisar la página de la guía de integración de Ultralytics para aprender más sobre diferentes integraciones interesantes.

Preguntas frecuentes

¿Cómo entreno un modelo YOLO26 usando IBM Watsonx?

Para entrenar un modelo YOLO26 usando IBM Watsonx, sigue estos pasos:

Configura tu entorno: Crea una cuenta de IBM Cloud y configura un proyecto de Watsonx.ai. Usa un Jupyter Notebook para tu entorno de codificación.
Instala bibliotecas: Instala las bibliotecas necesarias como torch, opencv y ultralytics.
Carga los datos: Usa la API de Kaggle para cargar tu conjunto de datos en Watsonx.
Preprocesa los datos: Organiza tu conjunto de datos en la estructura de directorio requerida y actualiza el archivo de configuración .yaml.
Entrena el modelo: Usa la interfaz de línea de comandos de YOLO para entrenar tu modelo con parámetros específicos como epochs, batch size y learning rate.
Prueba y evalúa: Ejecuta la inferencia para probar el modelo y evaluar su rendimiento usando métricas como precisión y recuperación.

Para obtener instrucciones detalladas, consulta nuestra guía de entrenamiento de modelos YOLO26.

¿Cuáles son las características clave de IBM Watsonx para el entrenamiento de modelos de IA?

IBM Watsonx ofrece varias características clave para el entrenamiento de modelos de IA:

Watsonx.ai: Proporciona herramientas para el desarrollo de IA, incluyendo acceso a modelos personalizados compatibles con IBM y modelos de terceros como Llama 3. Incluye Prompt Lab, Tuning Studio y Flows Engine para una gestión integral del ciclo de vida de la IA.
Watsonx.data: Admite implementaciones en la nube y en local, ofreciendo acceso centralizado a datos, motores de consulta eficientes como Presto y Spark, y una capa semántica impulsada por IA.
Watsonx.governance: Automatiza el cumplimiento, gestiona el riesgo con alertas y proporciona herramientas para detectar problemas como sesgo y deriva. También incluye paneles y herramientas de informes para la colaboración.

Para obtener más información, visita la documentación oficial de IBM Watsonx.

¿Por qué debería usar IBM Watsonx para entrenar modelos Ultralytics YOLO26?

IBM Watsonx es una excelente opción para entrenar modelos Ultralytics YOLO26 debido a su conjunto integral de herramientas que agilizan el ciclo de vida de la IA. Los beneficios clave incluyen:

Escalabilidad: Escala fácilmente tu entrenamiento de modelos con los servicios de IBM Cloud.
Integración: Intégrate a la perfección con varias fuentes de datos y API.
Interfaz fácil de usar: Simplifica el proceso de desarrollo con una interfaz colaborativa e intuitiva.
Herramientas avanzadas: Acceso a herramientas potentes como Prompt Lab, Tuning Studio y Flows Engine para mejorar el rendimiento del modelo.

Aprende más sobre Ultralytics YOLO26 y cómo entrenar modelos usando IBM Watsonx en nuestra guía de integración.

¿Cómo puedo preprocesar mi conjunto de datos para el entrenamiento de YOLO26 en IBM Watsonx?

Para preprocesar tu conjunto de datos para el entrenamiento de YOLO26 en IBM Watsonx:

Organiza los directorios: Asegúrate de que tu conjunto de datos siga la estructura de directorios de YOLO con subdirectorios separados para imágenes y etiquetas dentro de la división train/val/test.
Actualiza el archivo .yaml: Modifica el archivo de configuración .yaml para reflejar la nueva estructura de directorios y los nombres de las clases.
Ejecuta el script de preprocesamiento: Usa un script de Python para reorganizar tu conjunto de datos y actualizar el archivo .yaml en consecuencia.

Aquí tienes un script de ejemplo para organizar tu conjunto de datos:

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)

Para más detalles, consulta nuestra guía de preprocesamiento de datos.

¿Cuáles son los requisitos previos para entrenar un modelo YOLO26 en IBM Watsonx?

Antes de empezar a entrenar un modelo YOLO26 en IBM Watsonx, asegúrate de cumplir los siguientes requisitos previos:

Cuenta de IBM Cloud: Crea una cuenta en IBM Cloud para acceder a Watsonx.ai.
Cuenta de Kaggle: Para cargar conjuntos de datos, necesitarás una cuenta de Kaggle y una clave API.
Jupyter Notebook: Configura un entorno de Jupyter Notebook en Watsonx.ai para programar y entrenar modelos.

Para obtener más información sobre la configuración de tu entorno, visita nuestra guía de instalación de Ultralytics.

Contributors

GLglenn-jocher¹² RIRizwanMunawar² ONonuralpszr¹ AMambitious-octopus¹ MAMatthewNoyce¹ LALaughing-q¹ ABabirami-vina¹

Created 29 jul 2024Updated el mes pasado