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

Hoy en día, las computer vision solutions 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 fluida con los servicios de IBM Cloud.

Puedes entrenar Ultralytics YOLO26 models utilizando IBM Watsonx. Es una buena opción para las empresas interesadas en un model training eficiente, el ajuste fino para tareas específicas y la mejora del model performance con herramientas robustas y una configuración fácil de usar. En esta guía, te guiaremos a través del proceso de entrenamiento de YOLO26 con IBM Watsonx, cubriendo desde la configuración de tu entorno hasta la evaluación de tus modelos entrenados. ¡Comencemos!

¿Qué es IBM Watsonx?#

Watsonx es la plataforma basada en la nube de IBM diseñada para la generative AI 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 confiable que puede acelerar los proyectos de IA orientados a resolver problemas empresariales. Proporciona herramientas potentes para crear, entrenar y deploying machine learning models, 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 lograr una gestión e implementación de modelos eficientes. Ya sea para la visión artificial, el análisis predictivo, el natural language processing 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 consta de tres componentes principales: watsonx.ai, watsonx.data y watsonx.governance. Cada componente ofrece características que atienden a diferentes aspectos de la IA y la gestión de 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 propios modelos Granite de IBM. Incluye el Prompt Lab para experimentar con indicaciones de IA, el Tuning Studio para mejorar el rendimiento del modelo con datos etiquetados y el Flows Engine para simplificar el desarrollo de aplicaciones de generación de IA. Asimismo, ofrece herramientas integrales para automatizar el ciclo de vida del modelo de IA y conectarse a varias API y bibliotecas.

Watsonx.data#

Watsonx.data admite implementaciones tanto en la nube como locales a través de la integración de IBM Storage Fusion HCI. Su consola fácil de usar proporciona 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 información 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 normativo al identificar automáticamente los cambios regulatorios y aplicar políticas. Vincula los requisitos con los datos de riesgo internos y proporciona hojas de datos de IA actualizadas. La plataforma ayuda a gestionar el riesgo con alertas y herramientas para detectar problemas como el bias and drift. También automatiza el seguimiento y la documentación del ciclo de vida de la IA, organiza el desarrollo de la IA con un inventario de modelos y mejora la colaboración con paneles de control fáciles de usar y herramientas de informes.

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 IBM Cloud account 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, deberás configurar una cuenta de IBM para usar un Jupyter Notebook. Inicia sesión en watsonx.ai utilizando tu cuenta de IBM Cloud.

A continuación, crea un watsonx.ai project 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 pertinentes#

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 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 ver soluciones y consejos.

Luego, puedes importar los paquetes necesarios.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Paso 3: Carga los datos#

Para este tutorial, utilizaremos un marine litter dataset disponible en Kaggle. Con este conjunto de datos, entrenaremos de forma personalizada un modelo YOLO26 para detectar y clasificar basura y objetos biológicos en imágenes submarinas.

Podemos cargar el conjunto de datos directamente en el cuaderno utilizando la Kaggle API. Primero, crea una cuenta de Kaggle gratuita. Una vez que hayas creado una cuenta, deberás generar una clave API. Las instrucciones para generar tu clave se pueden encontrar en la Kaggle API documentation bajo 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.

# 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, 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 los contenidos del directorio, significa que 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 object detection. Aquí tienes una imagen de muestra de nuestro conjunto de datos de basura marina.

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 la imagen y las etiquetas. En este momento, nuestro directorio del conjunto de datos cargado sigue esta estructura:

Pero los modelos YOLO requieren por defecto imágenes y etiquetas separadas en subdirectorios dentro de la división train/val/test. Necesitamos reorganizar el directorio en 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, debemos 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 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 los contenidos actuales de config.yaml y reemplazarlos con la configuración que refleja la estructura del directorio de nuestro nuevo 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 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 predeterminado previamente entrenado.

!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 detallado a los parámetros en el comando de entrenamiento del modelo:

• task: Especifica la tarea de computer vision para la cual estás utilizando el modelo YOLO y el conjunto de datos especificados.
• mode: Denota el propósito para el que 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 la cantidad de veces que YOLO26 pasará por todo nuestro conjunto de datos.
• batch: El valor numérico estipula los batch sizes de entrenamiento. Los lotes son la cantidad de imágenes que procesa un modelo antes de actualizar sus parámetros.
• lr0: Especifica la learning rate 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 comprender en detalle el proceso de entrenamiento del modelo y las mejores prácticas, consulta la YOLO26 Model Training guide. Esta guía te ayudará a aprovechar al máximo tus experimentos y a garantizar que utilices YOLO26 de manera eficaz.

Paso 6: Prueba el modelo#

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

!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 imágenes de salida que superponen la bounding box 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 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 las cajas de la misma clase con una superposición del 50% o mayor. Esto ayuda a reducir las posibles cajas duplicadas generadas para el mismo objeto. Podemos cargar las imágenes con superposiciones de cuadros delimitadores predichos para ver cómo se comporta nuestro modelo en un puñado de 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 cajas delimitadoras predichas, acompañadas de etiquetas con nombres de clase y niveles de confianza.

Paso 7: Evalúa el modelo#

Podemos producir visualizaciones de la precision y el recall del modelo para cada clase. Estas visualizaciones se guardan en el directorio de 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 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 determinado nivel de confianza después de dos epochs.

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

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 apto del equilibrio entre precisión y recuperación para los modelos de clasificación.

Paso 8: Cálculo de la Intersection Over Union#

Puedes medir la accuracy de la predicción calculando la IoU entre un cuadro delimitador predicho y un cuadro delimitador de verdad de terreno para el mismo objeto. Consulta el IBM's tutorial on training 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 construcción de modelos, la gestión de datos y el cumplimiento.

Para obtener más detalles sobre el uso, visita la IBM Watsonx official documentation.

Asimismo, asegúrate de consultar la página de la Ultralytics integration guide page para obtener más información sobre las diferentes integraciones interesantes.

FAQ#