A Step-by-Step Guide to Training YOLO11 Models with 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, despliegue y 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.

You can train Ultralytics YOLO11 models using IBM Watsonx. It's a good option for enterprises interested in efficient model training, fine-tuning for specific tasks, and improving model performance with robust tools and a user-friendly setup. In this guide, we'll walk you through the process of training YOLO11 with IBM Watsonx, covering everything from setting up your environment to evaluating your trained models. Let's get started!

¿Qué es IBM Watsonx?

Watsonx is IBM's cloud-based platform designed for commercial generative AI and scientific data. IBM Watsonx's three components - watsonx.ai, watsonx.data, and watsonx.governance - come together to create an end-to-end, trustworthy AI platform that can accelerate AI projects aimed at solving business problems. It provides powerful tools for building, training, and deploying machine learning models and makes it easy to connect with various data sources.

Its user-friendly interface and collaborative capabilities streamline the development process and help with efficient model management and deployment. Whether for computer vision, predictive analytics, natural language processing, or other AI applications, IBM Watsonx provides the tools and support needed to drive innovation.

Características principales de IBM Watsonx

IBM Watsonx está formado por tres componentes principales: watsonx.ai, watsonx.data y watsonx.governance. Cada componente ofrece funciones que atienden a diferentes 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 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 IA generativa. Además, ofrece herramientas completas para automatizar el ciclo de vida del modelo de IA y conectarse a varias API y bibliotecas.

Watsonx.datos

Watsonx.data admite despliegues tanto en la nube como en las instalaciones a través de la integración IBM Storage Fusion HCI. Su consola de fácil uso 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 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 deriva. 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.

How to Train YOLO11 Using IBM Watsonx

You can use IBM Watsonx to accelerate your YOLO11 model training workflow.

Requisitos previos

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

Paso 1: Configura tu entorno

En primer lugar, tendrás que configurar una cuenta IBM para utilizar un Jupyter Notebook. Accede a watsonx.ai utilizando tu cuenta de IBM Cloud.

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

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

Paso 2: Instalar e importar las bibliotecas pertinentes

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

For detailed instructions and best practices related to the installation process, check our Ultralytics Installation guide. While installing the required packages for YOLO11, if you encounter any difficulties, consult our Common Issues guide for solutions and tips.

A continuación, puedes importar los paquetes necesarios.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Paso 3: Cargar los datos

For this tutorial, we will use a marine litter dataset available on Kaggle. With this dataset, we will custom-train a YOLO11 model to detect and classify litter and biological objects in underwater images.

Podemos cargar el conjunto de datos directamente en el cuaderno utilizando la API de Kaggle. En primer lugar, crea una cuenta gratuita en Kaggle. Una vez que hayas creado una cuenta, tendrás que 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, 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"))

Tras 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 "basura_ICRA19" se cargó correctamente.

Si ves "basura_ICRA19" entre los contenidos del directorio, entonces se ha cargado correctamente. Deberías ver tres archivos/carpetas: a config.yaml archivo, un videos_for_testing y un directorio dataset directorio. Ignoraremos el videos_for_testing así que no dudes en borrarlo.

We will use the config.yaml file and the contents of the dataset directory to train our object detection model. Here is a sample image from our marine litter data set.

Paso 4: Preprocesar los datos

Afortunadamente, todas las etiquetas del conjunto de datos de basura marina 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 procesar la imagen y las etiquetas. Ahora mismo, el directorio de nuestro 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. 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. Ésta 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

Ejecuta el siguiente script para borrar el contenido actual de config.yaml y sustituirlo por el contenido anterior que refleja nuestra nueva estructura de directorios del conjunto de datos. Asegúrate de sustituir la parte work_dir de la ruta del directorio raíz en la línea 4 por tu propia ruta del directorio de trabajo que recuperamos antes. Deja las definiciones de los subdirectorios train, val y test. Tampoco cambies {dir_trabajo} en la línea 23 del código.

# Contents of new confg.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.")

Step 5: Train the YOLO11 model

Run the following command-line code to fine tune a pretrained default YOLO11 model.

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

Aquí tienes un vistazo más de cerca a los parámetros del comando de entrenamiento del modelo:

• task: It specifies the computer vision task for which you are using the specified YOLO model and data set.
• Modo: Denota el propósito para el que estás cargando el modelo y los datos especificados. Como estamos entrenando un modelo, se establece en "entrenar". Más adelante, cuando probemos el rendimiento de nuestro modelo, lo pondremos en "predecir".
• epochs: This delimits the number of times YOLO11 will pass through our entire data set.
• batch: The numerical value stipulates the training batch sizes. Batches are the number of images a model processes before it updates its parameters.
• lr0: Specifies the model's initial learning rate.
• gráficos: Indica a YOLO que genere y guarde gráficos de las métricas de entrenamiento y evaluación de nuestro modelo.

For a detailed understanding of the model training process and best practices, refer to the YOLO11 Model Training guide. This guide will help you get the most out of your experiments and ensure you're using YOLO11 effectively.

Paso 6: Probar el modelo

Ahora podemos ejecutar la inferencia para comprobar el rendimiento de nuestro modelo afinado:

!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

This brief script generates predicted labels for each image in our test set, as well as new output image files that overlay the predicted bounding box atop the original image.

Las etiquetas .txt predichas 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 informa al modelo para que ignore todas las predicciones con un nivel de confianza inferior al 50%.

Por último, iou=.5 ordena 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 pruebas con sus cuadros delimitadores predichos, acompañados de etiquetas de nombres de clases y niveles de confianza.

Paso 7: Evaluar el modelo

We can produce visualizations of the model's precision and recall for each class. These visualizations are saved in the home directory, under the train folder. The precision score is displayed in the P_curve.png:

The graph shows an exponential increase in precision as the model's confidence level for predictions increases. However, the model precision has not yet leveled out at a certain confidence level after two epochs.

The recall graph (R_curve.png) displays an inverse trend:

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.

Step 8: Calculating Intersection Over Union

You can measure the prediction accuracy by calculating the IoU between a predicted bounding box and a ground truth bounding box for the same object. Check out IBM's tutorial on training YOLO11 for more details.

Resumen

We explored IBM Watsonx key features, and how to train a YOLO11 model using IBM Watsonx. We also saw how IBM Watsonx can enhance your AI workflows with advanced tools for model building, data management, and compliance.

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

Además, asegúrate de consultar la página de la guía de integraciónUltralytics , para saber más sobre diferentes integraciones interesantes.

PREGUNTAS FRECUENTES

How do I train a YOLO11 model using IBM Watsonx?

To train a YOLO11 model using IBM Watsonx, follow these steps:

1. Configura tu entorno: Crea una cuenta en IBM Cloud y configura un proyecto Watsonx.ai. Utiliza un Jupyter Notebook para tu entorno de codificación.
2. Instalar bibliotecas: Instala las bibliotecas necesarias como torch, opencvy ultralytics.
3. Cargar datos: Utiliza la API de Kaggle para cargar tu conjunto de datos en Watsonx.
4. Preprocesar datos: Organiza tu conjunto de datos en la estructura de directorios requerida y actualiza el .yaml archivo de configuración.
5. Entrenar al modelo: Utiliza la interfaz de línea de comandos YOLO para entrenar tu modelo con parámetros específicos como epochs, batch sizey learning rate.
6. Probar y evaluar: Ejecuta la inferencia para probar el modelo y evaluar su rendimiento utilizando métricas como la precisión y el recuerdo.

For detailed instructions, refer to our YOLO11 Model Training guide.

¿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 el sesgo y la desviación. También incluye cuadros de mando y herramientas de elaboración de informes para la colaboración.

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

Why should I use IBM Watsonx for training Ultralytics YOLO11 models?

IBM Watsonx is an excellent choice for training Ultralytics YOLO11 models due to its comprehensive suite of tools that streamline the AI lifecycle. Key benefits include:

• Escalabilidad: Escala fácilmente tu modelo de formación con los servicios de IBM Cloud.
• Integración: Intégrate sin problemas 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 del modelo.

Learn more about Ultralytics YOLO11 and how to train models using IBM Watsonx in our integration guide.

How can I preprocess my dataset for YOLO11 training on IBM Watsonx?

To preprocess your dataset for YOLO11 training on IBM Watsonx:

1. Organiza los directorios: Asegúrate de que tu conjunto de datos sigue la estructura de directorios YOLO , con subdirectorios separados para las imágenes y las etiquetas dentro de la división tren/val/prueba.
2. Actualizar archivo .yaml: Modifica el .yaml para reflejar la nueva estructura de directorios y nombres de clases.
3. Ejecutar script de preprocesamiento: Utiliza un script Python para reorganizar tu conjunto de datos y actualizarlo. .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, consulta nuestra guía de preprocesamiento de datos.

What are the prerequisites for training a YOLO11 model on IBM Watsonx?

Before you start training a YOLO11 model on IBM Watsonx, ensure you have the following prerequisites:

• Cuenta en IBM Cloud: Crea 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: Configura un entorno Jupyter Notebook dentro de Watsonx.ai para codificar y entrenar modelos.

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

📅 Created 2 months ago ✏️ Updated 12 days ago

Comentarios