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 habituales y están transformando la forma de gestionar los datos visuales. Un gran ejemplo es IBM Watsonx, una plataforma avanzada de IA y datos que simplifica el desarrollo, el despliegue y la gestión de modelos de IA. Ofrece un conjunto completo de herramientas 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 con IBM Watsonx. Es una buena opción para empresas interesadas en un entrenamiento de modelos eficiente, el ajuste fino para tareas específicas y la mejora del rendimiento de los modelos con herramientas sólidas y una configuración sencilla. En esta guía, te explicamos el proceso para entrenar YOLO26 con IBM Watsonx, desde la configuración del entorno hasta la evaluación de los modelos entrenados. ¡Empecemos!

¿Qué es IBM Watsonx?#

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

Su interfaz intuitiva y sus funciones de colaboración agilizan el proceso de desarrollo y ayudan a gestionar y desplegar modelos de forma eficiente. Tanto si trabajas en visión artificial, analítica predictiva, 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 principales de IBM Watsonx#

IBM Watsonx consta de tres componentes principales: watsonx.ai, watsonx.data y watsonx.governance. Cada componente ofrece funciones para distintos aspectos de la IA y la gestión de datos. Veámoslos con más detalle.

Watsonx.ai#

Watsonx.ai proporciona herramientas potentes para desarrollar IA y ofrece acceso a modelos personalizados compatibles con IBM, modelos de terceros como Llama 3 y los modelos Granite propios de IBM. Incluye Prompt Lab, para experimentar con instrucciones de IA; Tuning Studio, para mejorar el rendimiento de los modelos con datos etiquetados; y Flows Engine, para simplificar el desarrollo de aplicaciones de IA generativa. También ofrece herramientas completas para automatizar el ciclo de vida de los modelos de IA y conectarse a distintas API y bibliotecas.

Watsonx.data#

Watsonx.data admite despliegues tanto en la nube como locales mediante la integración con IBM Storage Fusion HCI. Su consola intuitiva proporciona acceso centralizado a los datos de distintos entornos y facilita su exploración con SQL estándar. Optimiza las cargas de trabajo con motores de consulta eficientes como Presto y Spark, agiliza la obtención de información de los datos con una capa semántica basada en IA, incluye una base de datos vectorial para mejorar la relevancia de la IA y admite formatos de datos abiertos para compartir fácilmente datos analíticos y de IA.

Watsonx.governance#

Watsonx.governance facilita el cumplimiento normativo al identificar automáticamente los cambios regulatorios y aplicar políticas. Vincula los requisitos con los datos de riesgos internos y proporciona fichas de datos de IA actualizadas. La plataforma ayuda a gestionar los riesgos con alertas y herramientas para detectar problemas como el sesgo y el cambio en la distribución de los datos. También automatiza la supervisión 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 e informes intuitivos.

Cómo entrenar YOLO26 con 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 una cuenta de Kaggle para cargar el conjunto de datos.

Paso 1: Configura el entorno#

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

A continuación, crea un proyecto de watsonx.ai y un Jupyter Notebook.

A continuación, 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 necesarias#

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

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

Para obtener instrucciones detalladas y buenas prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalación de Ultralytics. Si tienes dificultades al instalar los paquetes necesarios para YOLO26, consulta nuestra guía sobre problemas habituales, donde encontrarás soluciones y consejos.

Después, puedes importar los paquetes necesarios.

import ultralytics

ultralytics.checks()

Paso 3: Carga los datos#

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

Podemos cargar el conjunto de datos directamente en el notebook mediante la API de Kaggle. Primero, crea una cuenta gratuita de Kaggle. Cuando hayas creado la cuenta, tendrás que generar una clave de API. Encontrarás las instrucciones para generarla en la documentación de la API de Kaggle, en la sección «Credenciales de API».

Copia y pega tu nombre de usuario y tu clave de API de Kaggle en el siguiente código. Después, ejecútalo para instalar la API y cargar el conjunto de datos en Watsonx.

# Install kaggle
pip install kaggle

Después de instalar Kaggle, podemos cargar el conjunto de datos en 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"))

Después de cargar el conjunto de datos, mostramos y guardamos el directorio de trabajo. También mostramos su contenido para confirmar que el conjunto de datos «trash_ICRA19» se había cargado correctamente.

Si ves «trash_ICRA19» entre el contenido del directorio, significa que se ha cargado correctamente. Deberías ver tres archivos o carpetas: un archivo config.yaml, un directorio videos_for_testing y un directorio dataset. No usaremos el directorio videos_for_testing, así que puedes 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.

Paso 4: Preprocesa los datos#

Por suerte, todas las etiquetas del conjunto de datos de residuos marinos ya están en archivos .txt con formato YOLO. Sin embargo, tenemos que reorganizar la estructura de los directorios de imágenes y etiquetas para ayudar al modelo a procesarlas. Actualmente, el directorio del conjunto de datos cargado tiene esta estructura:

Sin embargo, los modelos YOLO requieren de forma predeterminada que las imágenes y las etiquetas estén separadas en subdirectorios dentro de las particiones train/val/test. Tenemos que reorganizar el directorio con la siguiente estructura:

Para reorganizar el directorio del conjunto de datos, podemos ejecutar el siguiente 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)

A continuación, tenemos que modificar el archivo .yaml del conjunto de datos. Esta es la configuración que usaremos en el archivo .yaml. Los ID de clase empiezan en 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 sustituirlo por la configuración que refleja la nueva estructura de directorios del conjunto de datos. El script usa automáticamente la variable work_dir que definimos antes, así que asegúrate de que apunta a tu conjunto de datos antes de ejecutarlo y deja sin cambios las definiciones de los subdirectorios train, val y 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.")

Paso 5: Entrena el modelo YOLO26#

Ejecuta el siguiente comando para ajustar un modelo YOLO26 predeterminado preentrenado.

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

Aquí tienes un análisis más detallado de los parámetros del comando de entrenamiento del modelo:

• detect: La tarea de visión artificial para la que usas el modelo YOLO y el conjunto de datos especificados.
• train: El modo, que indica el propósito con el que cargas el modelo y los datos especificados. Más adelante, cuando probemos el rendimiento del modelo, usaremos predict.
• epochs: Indica el número de veces que YOLO26 recorrerá todo el conjunto de datos.
• batch: El valor numérico especifica los tamaños de lote del entrenamiento. Los lotes son el número de imágenes que procesa un modelo antes de actualizar sus parámetros.
• plots: Indica a YOLO que genere y guarde gráficos de las métricas de entrenamiento y evaluación de nuestro modelo.

Para comprender en detalle el proceso de entrenamiento del modelo y las prácticas recomendadas, consulta la guía de entrenamiento del modelo YOLO26. Esta guía te ayudará a sacar el máximo partido a tus experimentos y a asegurarte de que utilizas YOLO26 de forma eficaz.

Paso 6: Probar el modelo#

Ya podemos ejecutar inferencias para probar el rendimiento de nuestro modelo ajustado:

!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

Este breve script genera etiquetas predichas para cada imagen del conjunto de prueba, así como nuevos archivos de imagen de salida que superponen el cuadro delimitador predicho a la imagen original.

Las etiquetas .txt predichas de cada imagen se guardan mediante el argumento save_txt=True, y las imágenes de salida con superposiciones de cuadros delimitadores se generan mediante el argumento save=True. El parámetro conf=0.5 indica al modelo que ignore todas las predicciones con un nivel de confianza inferior al 50 %.

Por último, iou=.5 indica al modelo que ignore los cuadros de la misma clase que tengan un solapamiento del 50 % o superior. Esto ayuda a reducir los posibles cuadros duplicados generados para el mismo objeto. Podemos cargar las imágenes con las superposiciones de los cuadros delimitadores predichos para ver el rendimiento de nuestro modelo en algunas imágenes.

# 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 cuadros delimitadores predichos, acompañados de etiquetas con los nombres de clase y niveles de confianza.

Paso 7: Evaluar el modelo#

Podemos generar visualizaciones de la precisión y la exhaustividad del modelo para cada clase. Estas visualizaciones se guardan en el directorio de la ejecución de entrenamiento ({work_dir}/runs/detect/train/). La puntuación de precisión se muestra en BoxP_curve.png:

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

El gráfico de exhaustividad (BoxR_curve.png) muestra una tendencia inversa:

A diferencia de la precisión, la exhaustividad avanza en la dirección opuesta: es mayor en los casos con menor confianza y menor en los casos con mayor confianza. Este es un buen ejemplo del equilibrio entre precisión y exhaustividad en los modelos de clasificación.

Paso 8: Calcular la intersección sobre unión#

Puedes medir la exactitud de la predicción calculando el IoU entre un cuadro delimitador predicho y un cuadro delimitador de referencia del mismo objeto. Consulta el tutorial de IBM sobre el entrenamiento de YOLO26 para obtener más información.

Resumen#

Hemos explorado las principales funciones de IBM Watsonx y cómo entrenar un modelo YOLO26 con IBM Watsonx. También hemos visto cómo IBM Watsonx puede mejorar tus flujos de trabajo de IA con herramientas avanzadas para crear modelos, gestionar datos y garantizar el cumplimiento normativo.

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

Además, no te olvides de consultar la página de la guía de integración de Ultralytics para obtener más información sobre las distintas integraciones disponibles.

Preguntas frecuentes#