Link to this sectionGuía paso a paso para entrenar modelos YOLO26 con IBM Watsonx#
Hoy en día, las soluciones de visión artificial 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 perfecta con los servicios de IBM Cloud.
Puedes entrenar modelos Ultralytics YOLO26 usando IBM Watsonx. Es una buena opción para empresas interesadas en un entrenamiento de modelos eficiente, ajustes precisos para tareas específicas y la mejora del rendimiento del modelo con herramientas robustas y una configuración fácil de usar. En esta guía, te llevaremos a través del proceso de entrenamiento de YOLO26 con IBM Watsonx, cubriendo todo, desde la configuración de tu entorno hasta la evaluación de tus modelos entrenados. ¡Empecemos!
Link to this section¿Qué es IBM Watsonx?#
Watsonx es la plataforma de IBM basada en la nube diseñada para IA generativa comercial y 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 destinados a resolver problemas empresariales. Proporciona herramientas potentes para construir, entrenar e implementar modelos de machine learning 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 una gestión e implementación eficiente de los modelos. Ya sea para visión artificial, análisis predictivo, procesamiento de lenguaje natural u otras aplicaciones de IA, IBM Watsonx proporciona las herramientas y el soporte necesarios para impulsar la innovación.
Link to this sectionCaracterísticas clave de IBM Watsonx#
IBM Watsonx está compuesto por tres componentes principales: watsonx.ai, watsonx.data y watsonx.governance. Cada componente ofrece funciones que satisfacen diferentes aspectos de la gestión de datos y la IA. Echemos un vistazo más de cerca a ellos.
Link to this sectionWatsonx.ai#
Watsonx.ai proporciona herramientas potentes para el desarrollo de IA y ofrece acceso a modelos personalizados respaldados por IBM, modelos de terceros como Llama 3 y los propios modelos Granite de IBM. Incluye Prompt Lab para experimentar con prompts 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.
Link to this sectionWatsonx.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.
Link to this sectionWatsonx.governance#
Watsonx.governance facilita el cumplimiento mediante la identificación automática de cambios normativos y la aplicación de políticas. Vincula los requisitos a los datos de riesgo internos y proporciona hojas de datos de IA actualizadas. La plataforma ayuda a gestionar los riesgos con alertas y herramientas para detectar problemas como sesgos y derivas. También automatiza el seguimiento y la documentación del ciclo de vida de la IA, organiza el desarrollo de IA con un inventario de modelos y mejora la colaboración con paneles y herramientas de informes fáciles de usar.
Link to this sectionCómo entrenar YOLO26 usando IBM Watsonx#
Puedes usar IBM Watsonx para acelerar tu flujo de trabajo de entrenamiento de modelos YOLO26.
Link to this sectionRequisitos previos#
Necesitas una cuenta de IBM Cloud para crear un proyecto de watsonx.ai, y también necesitarás una cuenta de Kaggle para cargar el conjunto de datos.
Link to this sectionPaso 1: Configura tu entorno#
Primero, deberás configurar una cuenta de IBM para usar un Jupyter Notebook. Inicia sesión en watsonx.ai usando tu cuenta de IBM Cloud.
Luego, crea un proyecto de watsonx.ai 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.
Link to this sectionPaso 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-headlessPara instrucciones detalladas y mejores prácticas relacionadas con el proceso de instalación, consulta nuestra Guía de instalación de Ultralytics. Mientras instalas los paquetes requeridos para YOLO26, si encuentras alguna dificultad, consulta nuestra Guía de problemas comunes para obtener soluciones y consejos.
Luego, puedes importar los paquetes necesarios.
# Import ultralytics
import ultralytics
ultralytics.checks()
# Import packages to retrieve and display image filesLink to this sectionPaso 3: Carga los datos#
Para este tutorial, usaremos un conjunto de datos de residuos marinos disponible en Kaggle. Con este conjunto de datos, entrenaremos un modelo YOLO26 personalizado para detectar y clasificar basura y objetos biológicos en imágenes submarinas.
Podemos cargar el conjunto de datos directamente en el notebook usando la API de Kaggle. Primero, crea una cuenta gratuita de Kaggle. Una vez que hayas creado una cuenta, necesitarás generar una clave API. Las instrucciones para generar tu clave se pueden encontrar en la documentación de la API de Kaggle 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 kaggleDespué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 el contenido del directorio, entonces 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 detección de objetos. Aquí hay una imagen de muestra de nuestro conjunto de datos de residuos marinos.
Link to this sectionPaso 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") 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 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: rovEjecuta el siguiente script para eliminar el contenido actual de config.yaml y reemplazarlo con la configuración que refleja nuestra nueva estructura de directorio del 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 las definiciones de los subdirectorios train, val y test sin cambios.
# 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.")Link to this sectionPaso 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=TrueAquí tienes un vistazo más detallado a los parámetros en el comando de entrenamiento del modelo:
- task: Especifica la tarea de visión artificial para la que 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 tamaños de lote de entrenamiento. Los lotes son la cantidad de imágenes que procesa un modelo 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 de modelos y las mejores prácticas, consulta la guía de entrenamiento de modelos YOLO26. Esta guía te ayudará a aprovechar al máximo tus experimentos y a asegurarte de que utilizas YOLO26 de manera efectiva.
Link to this sectionPaso 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=TrueEste breve script genera etiquetas predichas para cada imagen en nuestro conjunto de prueba, así como nuevos archivos de imagen de salida que superponen la caja delimitadora predicha sobre la imagen original.
Las etiquetas .txt predichas para cada imagen se guardan mediante el argumento save_txt=True y las imágenes de salida con superposiciones de cajas delimitadoras se generan mediante el argumento save=True.
El parámetro conf=0.5 informa al modelo de 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 más. Ayuda a reducir posibles cajas duplicadas generadas para el mismo objeto.
Podemos cargar las imágenes con las cajas delimitadoras predichas superpuestas 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 cajas delimitadoras predichas, acompañadas de etiquetas con nombres de clase y niveles de confianza.
Link to this sectionPaso 7: Evalúa el modelo#
Podemos generar visualizaciones de la precision y la exhaustividad del modelo para cada clase. Estas visualizaciones se guardan en el directorio de la 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 cierto nivel de confianza después de dos épocas.
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.
Link to this sectionPaso 8: Cálculo de la Intersección sobre Unión#
Puedes medir la precisión de la predicción calculando el IoU entre una caja delimitadora predicha y una caja delimitadora de verdad fundamental para el mismo objeto. Consulta el tutorial de IBM sobre el entrenamiento de YOLO26 para obtener más detalles.
Link to this sectionResumen#
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 documentación oficial de IBM Watsonx.
Además, asegúrate de consultar la página de la guía de integración de Ultralytics para obtener más información sobre diferentes integraciones interesantes.
Link to this sectionFAQ#
Link to this section¿Cómo entreno un modelo YOLO26 usando IBM Watsonx?#
Para entrenar un modelo YOLO26 usando IBM Watsonx, sigue estos pasos:
- Configura tu entorno: Crea una cuenta de IBM Cloud y configura un proyecto de Watsonx.ai. Usa un Jupyter Notebook para tu entorno de codificación.
- Instala bibliotecas: Instala las bibliotecas necesarias como
torch,opencvyultralytics. - Carga datos: Usa la API de Kaggle para cargar tu conjunto de datos en Watsonx.
- Preprocesa datos: Organiza tu conjunto de datos en la estructura de directorio requerida y actualiza el archivo de configuración
.yaml. - Entrena el modelo: Usa la interfaz de línea de comandos de YOLO para entrenar tu modelo con parámetros específicos como
epochs,batch sizeylearning rate. - Prueba y evalúa: Ejecuta la inferencia para probar el modelo y evaluar su rendimiento usando métricas como precisión y recuperación.
Para obtener instrucciones detalladas, consulta nuestra guía de entrenamiento de modelos YOLO26.
Link to this section¿Cuáles son las características clave 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 IA, incluido el acceso a modelos personalizados respaldados por 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 locales, ofreciendo acceso centralizado a datos, motores de consulta eficientes como Presto y Spark, y una capa semántica impulsada por IA.
- Watsonx.governance: Automatiza el cumplimiento, gestiona riesgos con alertas y proporciona herramientas para detectar problemas como sesgos y derivas. También incluye paneles y herramientas de informes para la colaboración.
Para obtener más información, visita la documentación oficial de IBM Watsonx.
Link to this section¿Por qué debería usar IBM Watsonx para entrenar modelos Ultralytics YOLO26?#
IBM Watsonx es una excelente opción para entrenar modelos Ultralytics YOLO26 debido a su conjunto completo de herramientas que agilizan el ciclo de vida de la IA. Los beneficios clave incluyen:
- Escalabilidad: Escala fácilmente el entrenamiento de tu modelo con los servicios de IBM Cloud.
- Integración: Integra perfectamente con varias 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 herramientas potentes como Prompt Lab, Tuning Studio y Flows Engine para mejorar el rendimiento del modelo.
Obtén más información sobre Ultralytics YOLO26 y cómo entrenar modelos usando IBM Watsonx en nuestra guía de integración.
Link to this section¿Cómo puedo preprocesar mi conjunto de datos para el entrenamiento de YOLO26 en IBM Watsonx?#
Para preprocesar tu conjunto de datos para el entrenamiento de YOLO26 en IBM Watsonx:
- Organiza directorios: Asegúrate de que tu conjunto de datos siga la estructura de directorio de YOLO con subdirectorios separados para imágenes y etiquetas dentro de la división train/val/test.
- Actualiza el archivo .yaml: Modifica el archivo de configuración
.yamlpara reflejar la nueva estructura de directorios y nombres de clase. - Ejecuta el script de preprocesamiento: Usa un script de Python para reorganizar tu conjunto de datos y actualizar el archivo
.yamlen consecuencia.
Aquí tienes un script de muestra 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 obtener más detalles, consulta nuestra guía de preprocesamiento de datos.
Link to this section¿Cuáles son los requisitos previos para entrenar un modelo YOLO26 en IBM Watsonx?#
Antes de empezar a entrenar un modelo YOLO26 en IBM Watsonx, asegúrate de tener los siguientes requisitos previos:
- Cuenta de IBM Cloud: Crea una cuenta en IBM Cloud para acceder a Watsonx.ai.
- Cuenta de Kaggle: Para cargar conjuntos de datos, necesitarás una cuenta de Kaggle y una clave API.
- Jupyter Notebook: Configura un entorno de Jupyter Notebook dentro de Watsonx.ai para programar y entrenar modelos.
Para obtener más información sobre la configuración de tu entorno, visita nuestra guía de instalación de Ultralytics.