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

Hoy en día, las soluciones escalables de visión por ordenador son cada vez más comunes y están transformando la forma en que manejamos 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 una suite completa para todo el ciclo de vida de la IA y una integración perfecta con los servicios de IBM Cloud.

Puede entrenar modelosUltralytics YOLO11 utilizando IBM Watsonx. Es una buena opción para las empresas interesadas en una formación de modelos eficiente, un ajuste preciso para tareas específicas y la mejora del rendimiento del modelo con herramientas sólidas y una configuración fácil de usar. En esta guía, le guiaremos a través del proceso de formación de YOLO11 con IBM Watsonx, desde la configuración del entorno hasta la evaluación de los modelos formados. Empecemos.

¿Qué es IBM Watsonx?

Watsonx es la plataforma basada en la nube de IBM diseñada para el comercio IA generativa y datos científicos. Los tres componentes de IBM Watsonx - watsonx.ai, watsonx.datay watsonx.governance - se unen para crear una plataforma de IA integral y fiable que puede acelerar los proyectos de IA destinados a resolver problemas empresariales. Proporciona potentes herramientas para construir, entrenar y implantación de modelos de aprendizaje automático y facilita la conexión con diversas fuentes de datos.

Su interfaz fácil de usar y sus funciones de colaboración agilizan el proceso de desarrollo y ayudan a gestionar y desplegar modelos de forma eficiente. Ya sea para visión por ordenador, 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.datay watsonx.governance. Cada componente ofrece funciones que atienden a distintos aspectos de la IA y la gestión de datos. Veámoslos más de cerca.

Watsonx.ai

Watsonx.ai proporciona potentes herramientas 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 instrucciones 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 IA generativa. Además, ofrece herramientas completas para automatizar el ciclo de vida de los modelos de IA y conectarse a diversas API y bibliotecas.

Watsonx.datos

Watsonx.data admite despliegues tanto en cloud como en las instalaciones a través de la integración 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 el conocimiento de los datos con una capa semántica impulsada por IA, incluye una base de datos vectorial para la relevancia de la IA y da soporte a formatos de datos abiertos para compartir fácilmente los datos de analítica e IA.

Watsonx.gobernanza

Watsonx.governance facilita el cumplimiento identificando automáticamente los cambios normativos y aplicando las políticas. Vincula los requisitos con los datos internos de riesgo y proporciona fichas actualizadas de IA. La plataforma ayuda a gestionar el riesgo con alertas y herramientas para detectar problemas como el sesgo y la desviación. 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 cuadros de mando y herramientas de elaboración de informes fáciles de usar.

Cómo entrenar YOLO11 con IBM Watsonx

Puede utilizar IBM Watsonx para acelerar su flujo de trabajo de formación de modelos YOLO11 .

Requisitos previos

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

Paso 1: Configure su entorno

En primer lugar, deberá configurar una cuenta de IBM para utilizar un Jupyter Notebook. Inicie sesión en watsonx.ai con su cuenta de IBM Cloud.

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

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

Paso 2: Instalar e importar las bibliotecas pertinentes

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

# Install the required packages
pip install torch torchvision torchaudio
pip install opencv-contrib-python-headless
pip install ultralytics==8.0.196

Para obtener instrucciones detalladas y buenas prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalaciónUltralytics . Mientras instala los paquetes necesarios para YOLO11, si encuentra alguna dificultad, consulte nuestra guía de problemas comunes para obtener soluciones y consejos.

A continuación, puede importar los paquetes necesarios.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Paso 3: Cargar los datos

Para este tutorial, utilizaremos un conjunto de datos de basura marina disponible en Kaggle. Con este conjunto de datos, entrenaremos a medida un modelo YOLO11 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 API de Kaggle. En primer lugar, crea una cuenta gratuita de Kaggle. Una vez que hayas creado una cuenta, necesitarás generar una clave API. Puedes encontrar instrucciones para generar tu clave en la documentación de la API de Kaggle, en la sección "Credenciales de la API".

Copia y pega tu nombre de usuario de Kaggle y tu clave API en el siguiente código. A continuación, ejecute 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, hemos impreso y guardado 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 ha cargado correctamente.

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

Utilizaremos el config.yaml y el contenido del directorio dataset para entrenar nuestro detección de objetos modelo. He aquí una imagen de muestra de nuestro conjunto de datos sobre basuras marinas.

Paso 4: Preprocesar los datos

Afortunadamente, todas las etiquetas del conjunto de datos de basuras marinas ya están formateadas como archivos .txt de YOLO . Sin embargo, tenemos que reorganizar la estructura de los directorios de imágenes y etiquetas para ayudar a nuestro modelo a procesarlas. Ahora mismo, el directorio de nuestro conjunto de datos cargado sigue esta estructura:

Pero, los modelos YOLO por defecto requieren imágenes y etiquetas separadas en subdirectorios dentro de la división train/val/test. Tenemos que 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") 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, tenemos que modificar el archivo .yaml para el conjunto de datos. Esta es la configuración que utilizaremos en nuestro archivo .yaml. Los números de ID de clase empiezan por 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

Ejecute el siguiente script para borrar el contenido actual de config.yaml y sustitúyalo por el contenido anterior, que refleja la nueva estructura de directorios de nuestro conjunto de datos. Asegúrese de reemplazar la porción work_dir de la ruta del directorio raíz en la línea 4 con su propia ruta del directorio de trabajo que recuperamos anteriormente. Deje las definiciones de los subdirectorios train, val y test. Además, no cambie {work_dir} en la línea 23 del código.

# Contents of new config.yaml file
def update_yaml_file(file_path):
    data = {
        "path": "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: Entrenar el modelo YOLO11

Ejecute el siguiente código de línea de comandos para ajustar un modelo predeterminado preentrenado YOLO11 .

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

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

• tarea: Especifica la tarea de visión por ordenador para la que está utilizando el modelo YOLO y el conjunto de datos especificados.
• Modo: Denota el propósito para el que está cargando el modelo y los datos especificados. Como estamos entrenando un modelo, se establece en "entrenar". Más tarde, cuando probemos el rendimiento de nuestro modelo, lo pondremos en "predecir".
• epochs: delimita el número de veces que YOLO11 pasará por todo nuestro conjunto de datos.
• lote: El valor numérico estipula el tamaño de los lotes de 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.
• gráficos: Indica a YOLO que genere y guarde gráficos de las métricas de entrenamiento y evaluación de nuestro modelo.

Para obtener información detallada sobre el proceso de formación de modelos y las mejores prácticas, consulte la guía de formación de modelosYOLO11 . Esta guía le ayudará a sacar el máximo partido de sus experimentos y a asegurarse de que utiliza YOLO11 con eficacia.

Paso 6: Probar el modelo

Ahora podemos ejecutar la inferencia para comprobar 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 de nuestro conjunto de pruebas, así como nuevos archivos de imagen de salida que superponen el cuadro delimitador predicho sobre la imagen original.

Las etiquetas .txt pronosticadas para cada imagen se guardan mediante la función save_txt=True y las imágenes de salida con superposiciones de cuadros delimitadores se generan mediante el argumento save=True argumento.
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 un solapamiento del 50% o superior. 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 funciona 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 cuadros delimitadores previstos, acompañados de etiquetas de nombres de clase y niveles de confianza.

Paso 7: Evaluar el modelo

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

El gráfico muestra un aumento exponencial de 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 épocas.

El gráfico de recuerdo (R_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 buen ejemplo del equilibrio entre precisión y recuperación en los modelos de clasificación.

Paso 8: Cálculo de la intersección sobre la unión

Puede medir la precisión de la predicción calculando el IoU entre un cuadro delimitador predicho y un cuadro delimitador real para el mismo objeto. Consulte el tutorial de IBM sobre formación YOLO11 para obtener más información.

Resumen

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

Para más detalles sobre su uso, visite la documentación oficial de IBM Watsonx.

Además, no deje de consultar la página de la guía de integraciónUltralytics , para obtener más información sobre diferentes integraciones interesantes.

PREGUNTAS FRECUENTES

¿Cómo se entrena un modelo YOLO11 con IBM Watsonx?

Para entrenar un modelo YOLO11 con IBM Watsonx, siga estos pasos:

1. Configure su entorno: Cree una cuenta de IBM Cloud y configure un proyecto Watsonx.ai. Utilice un Jupyter Notebook para su entorno de codificación.
2. Instalar bibliotecas: Instale las bibliotecas necesarias como torch, opencvy ultralytics.
3. Cargar datos: Utilice la API de Kaggle para cargar su conjunto de datos en Watsonx.
4. Preprocesamiento de datos: Organice su conjunto de datos en la estructura de directorios requerida y actualice el .yaml archivo de configuración.
5. Entrenar el modelo: Utilice la interfaz de línea de comandos YOLO para entrenar su modelo con parámetros específicos como epochs, batch sizey learning rate.
6. Probar y evaluar: Ejecute la inferencia para probar el modelo y evaluar su rendimiento utilizando métricas como la precisión y la recuperación.

Para obtener instrucciones detalladas, consulte nuestra guía de formación de modelosYOLO11 .

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

IBM Watsonx ofrece varias funciones clave para el entrenamiento de modelos de IA:

• Watsonx.ai: Proporciona herramientas para el desarrollo de IA, incluido el 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 las instalaciones, y ofrece acceso centralizado a los datos, motores de consulta eficientes como Presto y Spark, y una capa semántica potenciada por IA.
• Watsonx.governance: Automatiza el cumplimiento, gestiona el riesgo con alertas y proporciona herramientas para detectar problemas como sesgos y desviaciones. También incluye cuadros de mando y herramientas de elaboración de informes para la colaboración.

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

¿Por qué debería utilizar IBM Watsonx para entrenar los modelos de Ultralytics YOLO11 ?

IBM Watsonx es una opción excelente para entrenar modelos de Ultralytics YOLO11 gracias a su completo conjunto de herramientas que agilizan el ciclo de vida de la IA. Entre las principales ventajas se incluyen:

• Escalabilidad: Escale fácilmente su formación de modelos con los servicios de IBM Cloud.
• Integración: Integre a la perfección con diversas 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 potentes herramientas como Prompt Lab, Tuning Studio y Flows Engine para mejorar el rendimiento de los modelos.

Obtenga más información sobre Ultralytics YOLO11 y cómo entrenar modelos con IBM Watsonx en nuestra guía de integración.

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

Para preprocesar su conjunto de datos para el entrenamiento de YOLO11 en IBM Watsonx:

1. Organice los directorios: Asegúrese de que su conjunto de datos sigue la estructura de directorios YOLO con subdirectorios separados para imágenes y etiquetas dentro de la división entrenamiento/val/prueba.
2. Actualización del archivo .yaml: Modificar el .yaml para reflejar la nueva estructura de directorios y nombres de clases.
3. Ejecutar script de preprocesamiento: Utilice un script Python para reorganizar su conjunto de datos y actualizar los .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, consulte nuestra guía de preprocesamiento de datos.

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

Antes de empezar a entrenar un modelo YOLO11 en IBM Watsonx, asegúrese de que dispone de los siguientes requisitos previos:

• Cuenta en IBM Cloud: Cree una cuenta en IBM Cloud para acceder a Watsonx.ai.
• Cuenta Kaggle: Para cargar conjuntos de datos, necesitarás una cuenta de Kaggle y una clave API.
• Cuaderno Jupyter: Configure un entorno Jupyter Notebook dentro de Watsonx.ai para codificar y entrenar modelos.

Para más información sobre cómo configurar su entorno, visite nuestra guía de instalaciónUltralytics .

Creado hace 7 meses ✏️ Actualizado hace 1 mes

Comentarios