Una guía paso a paso para entrenar modelos YOLO11 con IBM Watsonx

Hoy en día, las soluciones escalables de visión artificial 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, 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.

Puede entrenar modelos Ultralytics YOLO11 utilizando IBM Watsonx. Es una buena opción para empresas interesadas en un entrenamiento de modelos eficiente, un ajuste fino para tareas específicas y en mejorar el rendimiento del modelo con herramientas robustas y una configuración fácil de usar. En esta guía, le guiaremos a través del proceso de entrenamiento de YOLO11 con IBM Watsonx, cubriendo todo, desde la configuración de su entorno hasta la evaluación de sus modelos entrenados. ¡Empecemos!

¿Qué es IBM Watsonx?

Watsonx es la plataforma basada en la nube de IBM diseñada para uso comercial IA generativa y datos científicos. Los tres componentes de IBM Watsonx son: 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 destinados a resolver problemas empresariales. Proporciona herramientas potentes para la construcción, el entrenamiento y implementación de modelos de aprendizaje automático y facilita la conexión con varias fuentes de datos.

Su interfaz intuitiva y sus capacidades de colaboración agilizan el proceso de desarrollo y ayudan con la gestión e implementación eficiente de 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 principales de IBM Watsonx

IBM Watsonx se compone de tres componentes principales: watsonx.ai, watsonx.data, y watsonx.governance. Cada componente ofrece características que se adaptan a diferentes aspectos de la IA y la gestión de datos. Echemos un vistazo más de cerca a cada uno de 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 Prompt Lab para experimentar con indicaciones 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 del modelo de IA y conectarse a varias API y bibliotecas.

Watsonx.data

Watsonx.data admite implementaciones tanto en la nube como en entornos locales a través de la integración de IBM Storage Fusion HCI. Su consola intuitiva 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 admite formatos de datos abiertos para facilitar el intercambio de datos de análisis e IA.

Watsonx.governance

Watsonx.governance facilita el cumplimiento normativo al identificar automáticamente los cambios regulatorios y aplicar 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 el sesgo y la deriva. También automatiza la supervisión 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 y herramientas de informes fáciles de usar.

Cómo entrenar YOLO11 usando IBM Watsonx

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

Prerrequisitos

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

Paso 1: Configure Su Entorno

Primero, deberá configurar una cuenta de IBM para usar un Jupyter Notebook. Inicie sesión en watsonx.ai con su cuenta de IBM Cloud.

Luego, cree un proyecto watsonx.ai y un Jupyter Notebook.

Una vez que lo haga, se abrirá un entorno de notebook para que cargue su conjunto de datos. Puede utilizar el código de este tutorial para abordar una tarea sencilla de entrenamiento de modelos de detección de objetos.

Paso 2: Instale e Importe 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 opencv-contrib-python-headless
pip install ultralytics==8.0.196

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

Luego, puede importar los paquetes necesarios.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Paso 3: Cargue los datos

Para este tutorial, utilizaremos un conjunto de datos de basura marina disponible en Kaggle. Con este conjunto de datos, entrenaremos de forma personalizada un modelo YOLO11 para detectar y clasificar la basura y los objetos biológicos en imágenes submarinas.

Podemos cargar el conjunto de datos directamente en el notebook utilizando la API de Kaggle. Primero, cree una cuenta gratuita de Kaggle. Una vez que haya creado una cuenta, deberá generar una clave API. Las instrucciones para generar su clave se pueden encontrar en la documentación de la API de Kaggle en la sección "Credenciales de la API".

Copia y pega tu nombre de usuario y clave API de Kaggle 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 ha cargado correctamente.

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

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

Paso 4: Preprocese los datos

Afortunadamente, todas las etiquetas en el conjunto de datos de basura marina ya están formateadas como 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. Ahora mismo, nuestro directorio de conjuntos de datos cargados 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") 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, debemos 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 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 reemplácelo con el contenido anterior que refleja nuestra nueva estructura de directorio de conjuntos de datos. Asegúrese de reemplazar la parte work_dir de la ruta del directorio raíz en la línea 4 con su propia ruta de directorio de trabajo que recuperamos anteriormente. Deje las definiciones de 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 YOLO11 preentrenado por defecto.

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

Aquí tiene una visión más detallada de los parámetros en el comando de entrenamiento del modelo:

• tarea: Especifica la tarea de visión artificial para la cual está utilizando el modelo YOLO y el conjunto de datos especificados.
• mode: Denota el propósito para el que está 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 YOLO11 pasará por todo nuestro conjunto de datos.
• batch: El valor numérico estipula los tamaños de lote de entrenamiento. Los lotes son el número de imágenes que un modelo procesa 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 del modelo y las mejores prácticas, consulte la guía de entrenamiento del modelo YOLO11. Esta guía le ayudará a sacar el máximo provecho de sus experimentos y a asegurarse de que está utilizando YOLO11 de forma eficaz.

Paso 6: Probar 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 imagen de salida que superponen el cuadro delimitador predicho sobre la imagen original.

Las etiquetas .txt predichas para cada imagen se guardan a través de save_txt=True argumento y las imágenes de salida con superposiciones de cuadros delimitadores se generan a través del 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 los cuadros de la misma clase con una superposición del 50% o más. Ayuda a reducir los posibles cuadros duplicados generados 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 cuadros delimitadores predichos, acompañados de etiquetas de nombre de clase y niveles de confianza.

Paso 7: Evaluar el modelo

Podemos producir visualizaciones de la precisión y la exhaustividad del modelo para cada clase. Estas visualizaciones se guardan en el directorio de inicio, en la carpeta de entrenamiento. La puntuación de precisión se muestra en P_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 cierto nivel de confianza después de dos épocas.

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

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

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

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

Resumen

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

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

Además, asegúrese de consultar la página de la guía de integración de Ultralytics, para obtener más información sobre diferentes integraciones interesantes.

Preguntas frecuentes

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

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

1. Configurar su entorno: Cree una cuenta de IBM Cloud y configure un proyecto de Watsonx.ai. Utilice un Jupyter Notebook para su entorno de codificación.
2. Instalar bibliotecas: Instale las bibliotecas necesarias como torch, opencv, y ultralytics.
3. Cargar datos: Utilice la API de Kaggle para cargar su conjunto de datos en Watsonx.
4. Preprocesar datos: Organice su conjunto de datos en la estructura de directorios requerida y actualice el .yaml archivo de configuración.
5. Entrenar el modelo: Utiliza 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.
6. Probar y evaluar: Ejecute la inferencia para probar el modelo y evaluar su rendimiento utilizando métricas como la precisión y la exhaustividad.

Para obtener instrucciones detalladas, consulta nuestra guía de entrenamiento del modelo YOLO11.

¿Cuáles son las principales características 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 la 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, ofreciendo acceso centralizado a los datos, motores de consulta eficientes como Presto y Spark, y una capa semántica impulsada por la IA.
• Watsonx.governance: Automatiza el cumplimiento, gestiona el riesgo con alertas y proporciona herramientas para detectar problemas como el sesgo y la deriva. También incluye paneles e herramientas de informes para la colaboración.

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

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

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

• Escalabilidad: Escale fácilmente el entrenamiento de su modelo con los servicios de IBM Cloud.
• Integración: Intégrese sin problemas con varias fuentes de datos y API.
• Interfaz fácil de usar: Simplifica el proceso de desarrollo con una interfaz intuitiva y colaborativa.
• Herramientas Avanzadas: Acceso a herramientas potentes como Prompt Lab, Tuning Studio y Flows Engine para mejorar el rendimiento del modelo.

Obtenga más información sobre Ultralytics YOLO11 y cómo entrenar modelos utilizando 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 tu conjunto de datos para el entrenamiento de YOLO11 en IBM Watsonx:

1. Organizar directorios: Asegúrese de que su conjunto de datos siga la estructura de directorios YOLO con subdirectorios separados para imágenes y etiquetas dentro de la división train/val/test.
2. Actualizar el archivo .yaml: Modifique el .yaml archivo de configuración para reflejar la nueva estructura de directorios y los nombres de las clases.
3. Ejecutar Script de Preprocesamiento: Utiliza un script de python para reorganizar tu conjunto de datos y actualizar el .yaml archivo según corresponda.

Aquí tiene un script de ejemplo para organizar su 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 obtener más detalles, consulta nuestra guía de preprocesamiento de datos.

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

Antes de comenzar a entrenar un modelo YOLO11 en IBM Watsonx, asegúrate de tener los siguientes requisitos previos:

• Cuenta de IBM Cloud: Cree una cuenta en IBM Cloud para acceder a Watsonx.ai.
• Cuenta de Kaggle: Para cargar conjuntos de datos, necesitará una cuenta de Kaggle y una clave API.
• Jupyter Notebook: Configure un entorno de Jupyter Notebook dentro de Watsonx.ai para la codificación y el entrenamiento de modelos.

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

📅 Creado hace 1 año ✏️ Actualizado hace 1 mes

Comentarios