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 en que gestionamos 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 fluida con los servicios de IBM Cloud.

Puedes entrenar modelos Ultralytics YOLO26 con IBM Watsonx. Es una buena opción para las empresas interesadas en un entrenamiento de modelos eficiente, el ajuste fino para tareas específicas y la mejora del rendimiento de los modelos mediante herramientas sólidas y una configuración fácil de usar. En esta guía, te explicaremos 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 basada 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— se combinan para crear una plataforma de IA integral y fiable que puede acelerar los proyectos de IA destinados a resolver problemas empresariales. Proporciona herramientas potentes para crear, entrenar y desplegar modelos de machine learning, y facilita la conexión con diversas fuentes de datos.

Su interfaz fácil de usar y sus capacidades de colaboración agilizan el proceso de desarrollo y ayudan a gestionar y desplegar modelos de forma eficiente. 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.

Funciones principales de IBM Watsonx#

IBM Watsonx consta de tres componentes principales: watsonx.ai, watsonx.data y watsonx.governance. Cada componente ofrece funciones adaptadas a 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 el desarrollo de IA y ofrece acceso a modelos personalizados compatibles con IBM, modelos de terceros como Llama 3 y los propios modelos Granite de IBM. Incluye Prompt Lab para experimentar con prompts 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 diversas 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 fácil de usar proporciona acceso centralizado a los datos en distintos entornos y facilita su exploración mediante SQL estándar. Optimiza las cargas de trabajo con motores de consultas eficientes como Presto y Spark, acelera la obtención de información mediante una capa semántica basada en IA, incluye una base de datos vectorial para 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 internos de riesgo y proporciona fichas técnicas de IA actualizadas. La plataforma ayuda a gestionar el riesgo mediante alertas y herramientas para detectar problemas como el sesgo y el drift. También automatiza la supervisión y documentación del ciclo de vida de la IA, organiza el desarrollo de IA mediante un inventario de modelos y mejora la colaboración con paneles y herramientas de generación de informes fáciles de usar.

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 necesitarás una cuenta de Kaggle para cargar el conjunto de datos.

Paso 1: configura tu 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.

Cuando lo hayas hecho, se abrirá un entorno de notebook para que cargues tus 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.

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

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

Después, puedes importar los paquetes necesarios.

import ultralytics

ultralytics.checks()

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 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 generar la clave 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 de API en el código siguiente. Después, ejecuta el código 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 nuestro 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. Ignoraremos 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. Esta es una imagen de ejemplo 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 tienen el formato de archivos .txt de YOLO. Sin embargo, tenemos que reorganizar la estructura de los directorios de imágenes y etiquetas para ayudar al modelo a procesar las imágenes y las etiquetas. Actualmente, el directorio del conjunto de datos cargado tiene esta estructura:

Sin embargo, los modelos YOLO requieren de forma predeterminada imágenes y etiquetas separadas en subdirectorios dentro de la división 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 nuestro archivo .yaml. Los números de ID de las clases 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 código de línea de comandos para ajustar un modelo YOLO26 preentrenado predeterminado.

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

Estos son los parámetros del comando de entrenamiento del modelo con más detalle:

• detect: La tarea de visión artificial para la que utilizas 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 tarde, cuando pruebes el rendimiento del modelo, utilizarás predict.
• epochs: Delimita el número de veces que YOLO26 recorrerá todo el conjunto de datos.
• batch: El valor numérico establece 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.
• 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 del modelo.

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

Paso 6: prueba el modelo#

Ahora podemos ejecutar la inferencia para probar el rendimiento del 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 sobre la imagen original.

Las etiquetas .txt predichas para 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 con una superposición 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 comprobar el rendimiento del modelo en varias 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 las clases y niveles de confianza.

Paso 7: evalúa el modelo#

Podemos generar visualizaciones de la precisión y la exhaustividad de 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 de las predicciones del modelo. Sin embargo, la precisión del modelo aún no se ha estabilizado en un nivel de confianza concreto después de 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 ejemplo claro del compromiso entre precisión y exhaustividad en los modelos de clasificación.

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

Puedes medir la precisión de las predicciones 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 funciones principales 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 dejes de consultar la página de la guía de integraciones de Ultralytics para obtener más información sobre otras integraciones interesantes.

Preguntas frecuentes#