Guía paso a paso para entrenar modelos YOLOv8 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, 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.

Puedes entrenar modelosUltralytics YOLOv8 utilizando IBM Watsonx. Es una buena opción para las empresas interesadas en un entrenamiento eficiente de los modelos, el ajuste fino para tareas específicas y la mejora del rendimiento de los modelos con herramientas sólidas y una configuración fácil de usar. En esta guía, te guiaremos a través del proceso de entrenamiento de YOLOv8 con IBM Watsonx, abarcando desde la configuración de tu entorno hasta la evaluación de tus modelos entrenados. ¡Vamos a empezar!

¿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 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 desplegar modelos de aprendizaje automático 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 computerizada, 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 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.

Cómo entrenar YOLOv8 utilizando IBM Watsonx

Puedes utilizar IBM Watsonx para acelerar tu flujo de trabajo de entrenamiento de modelos YOLOv8 .

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

Para obtener instrucciones detalladas y buenas prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalaciónUltralytics . Mientras instalas los paquetes necesarios para YOLOv8, si encuentras alguna dificultad, consulta nuestra guía de Problemas comunes para encontrar soluciones y consejos.

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

Para este tutorial, utilizaremos un conjunto de datos sobre basura marina disponible en Kaggle. Con este conjunto de datos, entrenaremos a medida un modelo YOLOv8 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 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.

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

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.")

Paso 5: Entrenar el modelo YOLOv8

Ejecuta el siguiente código de línea de comandos para afinar un modelo preentrenado por defecto YOLOv8 .

!yolo task=detect mode=train data={work_dir}/trash_ICRA19/config.yaml model=yolov8s.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:

• tarea: Especifica la tarea de visión por ordenador para la que utilizas el modelo YOLO y el conjunto de datos especificados.
• 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".
• épocas: delimita el número de veces que YOLOv8 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 conocer en detalle el proceso de entrenamiento de modelos y las mejores prácticas, consulta la guíaYOLOv8 Entrenamiento de modelos. Esta guía te ayudará a sacar el máximo partido de tus experimentos y a asegurarte de que utilizas YOLOv8 con eficacia.

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

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 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

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 el archivo 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 (curva_R.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

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

Resumen

Exploramos las características clave de IBM Watsonx, y cómo entrenar un modelo YOLOv8 utilizando IBM Watsonx. También vimos cómo IBM Watsonx puede mejorar tus 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, 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

¿Cómo entreno un modelo YOLOv8 utilizando IBM Watsonx?

Para entrenar un modelo YOLOv8 utilizando IBM Watsonx, sigue estos pasos:

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.

Para obtener instrucciones detalladas, consulta nuestra guía de formación de modelosYOLOv8 .

¿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.

¿Por qué debería utilizar IBM Watsonx para entrenar modelos Ultralytics YOLOv8 ?

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

• 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.

Más información sobre Ultralytics YOLOv8 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 YOLOv8 en IBM Watsonx?

Para preprocesar tu conjunto de datos para el entrenamiento de YOLOv8 en 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.

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

Antes de empezar a entrenar un modelo YOLOv8 en IBM Watsonx, asegúrate de que tienes los siguientes requisitos previos:

• 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 1 month ago ✏️ Updated 9 days ago

Comentarios