Empezar

Solución de problemas habituales de YOLO

YOLO common training and deployment issues

Esta guía aborda los problemas más habituales que encontrarás al trabajar con Ultralytics YOLO26, organizados según dónde se producen: instalación, entrenamiento del modelo, predicción e implementación. Ve directamente a la categoría que corresponda a tu error o consulta las preguntas frecuentes para encontrar respuestas rápidas. Cada entrada describe el problema y una solución concreta que puedes aplicar directamente.



Ver: Problemas habituales de Ultralytics YOLO26 | Errores de instalación y problemas al entrenar modelos

Problemas habituales#

Errores de instalación#

Los errores de instalación pueden deberse a distintos motivos, como versiones incompatibles, dependencias ausentes o una configuración incorrecta del entorno. Primero, comprueba lo siguiente:

  • Usas Python 3.8 o una versión posterior.
  • Tienes instalada una versión compatible de PyTorch (1.8 o posterior).
  • Usas un entorno virtual para evitar conflictos.
  • Sigue paso a paso la guía oficial de instalación.

Además, aquí tienes soluciones a problemas de instalación habituales.

Mantén Ultralytics y sus dependencias actualizados

Muchos errores de importación, GPU y exportación se solucionan simplemente actualizando. Ejecuta pip install -U ultralytics y confirma que las versiones de PyTorch y CUDA son compatibles antes de investigar más a fondo.

Errores de importación o problemas con dependencias#

Si aparecen errores al importar YOLO26 o tienes conflictos entre dependencias, prueba estos pasos:

  • Instalación limpia: Empezar con una instalación limpia puede resolver problemas inesperados, especialmente después de actualizaciones que modifican la estructura o las funciones del paquete.
  • Actualiza con regularidad: Usa la versión más reciente de la biblioteca, ya que las versiones anteriores podrían no ser compatibles con las actualizaciones recientes.
  • Comprueba las dependencias: Verifica que todas las dependencias necesarias estén instaladas correctamente y tengan versiones compatibles.
  • Revisa los cambios: Si has instalado una versión anterior, consulta la documentación oficial o el registro de cambios para entender las modificaciones importantes de la estructura.

Ejecutar YOLO26 en una GPU#

Si tienes problemas para ejecutar YOLO26 en una GPU, prueba estos pasos para solucionarlos:

  • Verifica la compatibilidad y la instalación de CUDA: Asegúrate de que tu GPU sea compatible con CUDA y de que CUDA esté instalado correctamente. Usa el comando nvidia-smi para comprobar el estado de tu GPU NVIDIA y la versión de CUDA.
  • Comprueba la integración de PyTorch y CUDA: asegúrate de que PyTorch pueda utilizar CUDA ejecutando import torch; print(torch.cuda.is_available()) en un terminal de Python. Si devuelve True, PyTorch está configurado para usar CUDA.
  • Activación del entorno: Asegúrate de estar en el entorno correcto, donde estén instalados todos los paquetes necesarios.
  • Actualiza tus paquetes: Es posible que los paquetes obsoletos no sean compatibles con tu GPU. Mantenlos actualizados.
  • Configuración del programa: Comprueba si tu código solicita el uso de la GPU. Puedes establecer el argumento device al ejecutar el entrenamiento o la predicción (por ejemplo, device=0).
GPU antiguas y cuDNN 9.11.0+

La compatibilidad con arquitecturas de GPU anteriores a Turing —con una capacidad de cálculo (SM) inferior a 7.5, como la GTX 1080 Ti— se eliminó en cuDNN 9.11.0. Si tienes una GPU antigua, quizá necesites una compilación de PyTorch compilada con una versión anterior de CUDA/cuDNN. Comprueba tu configuración con:

import torch

cap = torch.cuda.get_device_capability(0) if torch.cuda.is_available() else (0, 0)
cudnn = torch.backends.cudnn.version() or 0
ok = "not compatible" if cudnn >= 91100 and (cap[0] < 7 or (cap[0] == 7 and cap[1] < 5)) else "should be ok"
print(f"Compute capability: SM {cap[0]}.{cap[1]}, cuDNN: {cudnn} => {ok}")

Problemas con el entrenamiento del modelo#

A continuación se describen problemas habituales de entrenamiento y sus soluciones.

Verificación de los ajustes de configuración#

Problema: No tienes claro si los ajustes de configuración del archivo .yaml se aplican correctamente durante el entrenamiento del modelo.

Solución: Los ajustes del conjunto de datos y los del entrenamiento se encuentran en distintos archivos .yaml y se pasan mediante argumentos diferentes de model.train(). Para asegurarte de que estos ajustes se aplican correctamente, sigue estos pasos:

  • Confirma que las rutas a tus archivos .yaml sean correctas.

  • Pasa la configuración .yaml del conjunto de datos (rutas, nombres de clases y particiones) como argumento data, y una configuración personalizada .yaml para el entrenamiento (por ejemplo, epochs o lr0) como argumento cfg. Los argumentos que se pasan directamente a model.train() tienen prioridad sobre ambos:

    model.train(data="/path/to/your/data.yaml", cfg="/path/to/your/cfg.yaml", batch=4)

Acelerar el entrenamiento con varias GPU#

Problema: El entrenamiento es lento con una sola GPU y quieres acelerarlo usando varias GPU.

Solución: Aumentar el tamaño del lote puede acelerar el entrenamiento, pero es fundamental tener en cuenta la capacidad de memoria de la GPU. Para acelerar el entrenamiento con varias GPU, sigue estos pasos:

  • Asegúrate de tener varias GPU disponibles.

  • Establece el argumento device en una lista de índices de GPU, por ejemplo, device=[0,1,2,3].

  • Aumenta el tamaño del lote según corresponda para aprovechar al máximo las varias GPU sin superar los límites de memoria.

  • Modifica el comando de entrenamiento para usar varias GPU:

    # # Ajusta el tamaño del lote y otros parámetros según sea necesario para optimizar la velocidad del entrenamiento
    model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])

Parámetros que hay que supervisar continuamente#

Problema: Quieres saber qué parámetros debes supervisar continuamente durante el entrenamiento, además de la pérdida.

Solución: Aunque la pérdida es una métrica fundamental que debes supervisar, también es importante seguir otras métricas para optimizar el rendimiento del modelo. Algunas métricas clave que debes supervisar durante el entrenamiento son:

Puedes consultar estas métricas en los registros de entrenamiento o usar herramientas como TensorBoard o Weights & Biases para visualizarlas. La parada temprana con el argumento de entrenamiento patience (el valor predeterminado es 100 épocas sin mejoras en la validación) ayuda a evitar épocas innecesarias y el sobreajuste.

Herramientas para seguir el progreso del entrenamiento#

Problema: Buscas recomendaciones de herramientas para seguir el progreso del entrenamiento.

Solución: Para seguir y visualizar el progreso del entrenamiento, puedes plantearte usar las siguientes herramientas:

  • TensorBoard: TensorBoard es una opción popular para visualizar métricas de entrenamiento, como la pérdida, la exactitud y otras. Puedes integrarlo en el proceso de entrenamiento de YOLO26.
  • Comet: Comet ofrece un amplio conjunto de herramientas para el seguimiento y la comparación de experimentos. Te permite seguir métricas, hiperparámetros e incluso los pesos del modelo. También es fácil integrarlo con los modelos YOLO, lo que te ofrece una visión completa del ciclo del experimento.
  • Ultralytics Platform: Ultralytics Platform registra las ejecuciones de entrenamiento de YOLO junto con tus conjuntos de datos y modelos, para que puedas comparar métricas y colaborar con tu equipo desde un mismo lugar.

Cómo comprobar si el entrenamiento se está ejecutando en la GPU#

Problema: el valor de device en los registros de entrenamiento es null y no sabes si el entrenamiento se está ejecutando en la GPU.

Solución: un valor de device para null suele indicar que el proceso de entrenamiento está configurado para seleccionar automáticamente una GPU disponible, que es el comportamiento predeterminado. Para entrenar en una GPU concreta, establece el argumento device al iniciar el entrenamiento. device es un argumento de entrenamiento, así que establecerlo en .yaml del conjunto de datos no tendrá ningún efecto:

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n.pt")

# # Usa la GPU 0; device=[0, 1] para varias GPU, device="cpu" para la CPU
model.train(data="path/to/data.yaml", device=0)

No pierdas de vista la carpeta runs para consultar los registros y las métricas, y supervisar eficazmente el progreso del entrenamiento.

Aspectos clave para entrenar modelos de forma eficaz#

Si tienes problemas relacionados con el entrenamiento del modelo, ten en cuenta lo siguiente.

Formato del conjunto de datos y etiquetas

  • Importancia: La base de cualquier modelo de aprendizaje automático está en la calidad y el formato de los datos con los que se entrena.
  • Recomendación: Asegúrate de que tu conjunto de datos personalizado y las etiquetas asociadas respeten el formato esperado. Es fundamental comprobar que las anotaciones sean precisas y de alta calidad. Las anotaciones incorrectas o deficientes pueden desviar el proceso de aprendizaje del modelo y dar lugar a resultados impredecibles.

Convergencia del modelo

  • Importancia: Lograr la convergencia del modelo garantiza que este haya aprendido lo suficiente a partir de los datos de entrenamiento.
  • Recomendación: al entrenar un modelo «desde cero», es fundamental asegurarse de que alcance un nivel de convergencia satisfactorio. Esto puede requerir un entrenamiento más prolongado y más épocas que cuando se ajusta el modelo existente.

Tasa de aprendizaje y tamaño del lote

  • Importancia: estos hiperparámetros determinan cómo actualiza el modelo sus pesos durante el entrenamiento.
  • Recomendación: evalúa periódicamente si la tasa de aprendizaje y el tamaño de lote elegidos se ajustan a tu conjunto de datos concreto, y plantéate el ajuste de hiperparámetros para buscar valores mejores. Los parámetros que no se adaptan a las características del conjunto de datos pueden perjudicar el rendimiento del modelo.

Distribución de clases

  • Importancia: La distribución de clases de tu conjunto de datos puede influir en las tendencias de predicción del modelo.
  • Recomendación: Evalúa periódicamente la distribución de clases de tu conjunto de datos, por ejemplo, con un script de auditoría de conjuntos de datos. Si hay un desequilibrio de clases, existe el riesgo de que el modelo desarrolle un sesgo hacia la clase más frecuente. Este sesgo puede apreciarse en la matriz de confusión, donde el modelo podría predecir predominantemente la clase mayoritaria.

Comprobación cruzada con pesos preentrenados

  • Importancia: Aprovechar pesos preentrenados puede proporcionar una base sólida para entrenar el modelo, especialmente cuando hay pocos datos.
  • Recomendación: como paso de diagnóstico, plantéate entrenar el modelo con los mismos datos, pero inicializándolo con pesos preentrenados. Si este enfoque genera una matriz de confusión bien formada, podría indicar que el modelo entrenado «desde cero» necesita más entrenamiento o ajustes.

A continuación se describen los problemas habituales que surgen al hacer predicciones con el modelo y cómo solucionarlos.

Obtener predicciones de cuadros delimitadores con tu modelo personalizado YOLO26#

Problema: Al hacer predicciones con un modelo YOLO26 personalizado, pueden surgir dificultades con el formato y la visualización de las coordenadas de los cuadros delimitadores.

Solución:

  • Formato de coordenadas: YOLO26 proporciona las coordenadas de las cajas delimitadoras en valores absolutos de píxeles. Para convertirlas a coordenadas relativas (entre 0 y 1), debes dividirlas por las dimensiones de la imagen. Por ejemplo, si la imagen mide 640x640:

    # Convierte las coordenadas absolutas en coordenadas relativas
    x1 = x1 / 640  # Divide las coordenadas x por el ancho de la imagen
    x2 = x2 / 640
    y1 = y1 / 640  # Divide las coordenadas y por la altura de la imagen
    y2 = y2 / 640

    También puedes usar los atributos boxes.xyxyn o boxes.xywhn de cada resultado, que ya devuelven coordenadas normalizadas.

  • Nombre del archivo: Para obtener el nombre del archivo de la imagen sobre la que haces la predicción, lee la ruta del archivo de imagen del atributo path de cada objeto de resultado (por ejemplo, result.path) dentro del bucle de predicción.

Filtrar objetos en las predicciones de YOLO26#

Problema: Dificultades para filtrar y mostrar únicamente determinados objetos en los resultados de predicción al ejecutar YOLO26 con la biblioteca Ultralytics.

Solución: para detectar clases concretas, usa el argumento classes para especificar las clases que quieres incluir en la salida. Por ejemplo, para detectar solo coches (índice de clase 2 en COCO):

yolo segment predict model=yolo26n-seg.pt source='path/to/car.mp4' show=True classes=2

Entender las métricas de precisión en YOLO26#

Problema: confusión sobre la diferencia entre la precisión de las cajas, la precisión de las máscaras y la precisión de la matriz de confusión en YOLO26.

Solución: la precisión de las cajas mide la exactitud de las cajas delimitadoras predichas en comparación con las cajas de referencia reales, usando IoU (intersección sobre la unión) como métrica. La precisión de las máscaras evalúa la concordancia entre las máscaras de segmentación predichas y las máscaras de referencia en la clasificación de objetos píxel a píxel. En cambio, la precisión de la matriz de confusión se centra en la exactitud general de la clasificación en todas las clases y no tiene en cuenta la precisión geométrica de las predicciones. Es importante tener en cuenta que una caja delimitadora puede ser geométricamente precisa (verdadero positivo) aunque la predicción de clase sea incorrecta, lo que genera diferencias entre la precisión de las cajas y la precisión de la matriz de confusión. Estas métricas evalúan aspectos distintos del rendimiento del modelo y reflejan la necesidad de usar métricas de evaluación diferentes según la tarea.

Extraer las dimensiones de los objetos en YOLO26#

Problema: dificultad para obtener la anchura y la altura de los objetos detectados en YOLO26, especialmente cuando se detectan varios objetos en una imagen.

Solución: Para obtener las dimensiones de los cuadros delimitadores, primero usa el modelo Ultralytics YOLO26 para predecir objetos en una imagen. Después, extrae la información sobre el ancho y la altura de los cuadros delimitadores de los resultados de la predicción.

from ultralytics import YOLO

# Load a pretrained YOLO26 model
model = YOLO("yolo26n.pt")

# Specify the source image
source = "https://ultralytics.com/images/bus.jpg"

# Make predictions
results = model.predict(source, save=True, imgsz=320, conf=0.25)

# Extract bounding box dimensions
boxes = results[0].boxes.xywh.cpu()
for box in boxes:
    x, y, w, h = box
    print(f"Width of Box: {w}, Height of Box: {h}")

Problemas de implementación#

Problemas de implementación en GPU#

Problema: desplegar modelos en un entorno con varias GPU puede provocar a veces un comportamiento inesperado, como un uso inusual de la memoria o resultados incoherentes entre GPU.

Solución: comprueba si se está inicializando la GPU predeterminada. Algunos frameworks, como PyTorch, pueden inicializar operaciones de CUDA en una GPU predeterminada antes de pasar a las GPU designadas. Para evitar inicializaciones predeterminadas inesperadas, especifica directamente la GPU durante el despliegue y la predicción. Después, usa herramientas para supervisar en tiempo real la utilización de la GPU y el uso de memoria, e identificar anomalías. Asegúrate también de usar la versión más reciente del framework o la biblioteca.

Problemas al convertir o exportar modelos#

Problema: Durante la conversión o exportación de modelos de aprendizaje automático a distintos formatos o plataformas, pueden producirse errores o comportamientos inesperados.

Solución: Consulta los formatos compatibles y las opciones de cada formato en la documentación del modo de exportación y, a continuación, sigue estas comprobaciones:

  • Comprobación de compatibilidad: Asegúrate de utilizar versiones de bibliotecas y frameworks que sean compatibles entre sí. Las versiones incompatibles pueden provocar errores inesperados durante la conversión.
  • Restablecimiento del entorno: Si utilizas un entorno interactivo como Jupyter o Colab, considera la posibilidad de reiniciarlo después de hacer cambios importantes o instalar componentes. Empezar desde cero puede resolver algunos problemas subyacentes.
  • Documentación oficial: Consulta siempre la documentación oficial de la herramienta o biblioteca que utilizas para la conversión. A menudo incluye directrices específicas y buenas prácticas para exportar modelos.
  • Ayuda de la comunidad: Consulta el repositorio oficial de la biblioteca o el framework para ver si otros usuarios han informado de problemas similares. Es posible que los responsables del mantenimiento o la comunidad hayan ofrecido soluciones o alternativas en los hilos de debate.
  • Actualiza con regularidad: Asegúrate de utilizar la versión más reciente de la herramienta o biblioteca. Los desarrolladores publican actualizaciones con frecuencia para corregir errores conocidos o mejorar la funcionalidad.
  • Haz pruebas de forma incremental: Antes de realizar una conversión completa, prueba el proceso con un modelo o conjunto de datos más pequeño para identificar posibles problemas cuanto antes.

Comunidad y asistencia#

Obtén ayuda y comparte soluciones a través de estos canales y recursos.

Foros y canales de ayuda#

Problemas de GitHub: El repositorio de Ultralytics en GitHub tiene una pestaña de problemas donde puedes hacer preguntas, informar de errores y sugerir nuevas funciones. La comunidad y las personas responsables del mantenimiento participan activamente, así que es un buen lugar para obtener ayuda con problemas concretos.

Servidor de Discord de Ultralytics: Ultralytics tiene un servidor de Discord donde puedes interactuar con otros usuarios y con el equipo de desarrollo.

Documentación y recursos oficiales#

Documentación de Ultralytics YOLO26: La documentación oficial ofrece una visión general completa de YOLO26, junto con guías de instalación, uso y resolución de problemas.

Conclusión#

La mayoría de los problemas de YOLO26 se deben a unas pocas causas: incompatibilidades entre versiones, formato del conjunto de datos y configuración de la GPU. Si aquí no se aborda un error, busca en la pestaña GitHub Issues o pregunta en el servidor de Discord; es probable que alguien ya lo haya resuelto. Si tienes problemas más complejos de entrenamiento, consulta la guía Consejos para entrenar modelos, que ofrece recomendaciones prácticas para obtener mejores resultados en tus proyectos de visión artificial.

Preguntas frecuentes#

  • Los errores de instalación suelen deberse a problemas de compatibilidad o a dependencias que faltan. Asegúrate de usar Python 3.8 o posterior y de tener instalado PyTorch 1.8 o posterior. Es recomendable utilizar entornos virtuales para evitar conflictos. Para consultar una guía de instalación paso a paso, sigue nuestra guía oficial de instalación. Si se producen errores de importación, prueba a hacer una instalación limpia o actualiza la biblioteca a la versión más reciente.

  • El entrenamiento en una sola GPU puede ser lento por el gran tamaño de los lotes o la falta de memoria. Para acelerar el entrenamiento, utiliza varias GPU. Asegúrate de que el sistema tenga varias GPU disponibles y configura el argumento device, por ejemplo, device=[0,1,2,3]. Aumenta el tamaño del lote según corresponda para aprovechar al máximo las GPU sin superar los límites de memoria. Ejemplo de comando:

    model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])
  • Si el valor de device aparece como null en los registros de entrenamiento, normalmente significa que el proceso de entrenamiento está configurado para seleccionar automáticamente una GPU disponible. Para asignar explícitamente una GPU concreta, pasa el argumento device al iniciar el entrenamiento; por ejemplo, yolo train data=path/to/data.yaml device=0 para la primera GPU. Ejecuta nvidia-smi para confirmar la configuración de CUDA.

  • Puedes gestionar eficazmente el seguimiento y la visualización del progreso del entrenamiento con herramientas como TensorBoard, Comet y Ultralytics Platform. Estas herramientas permiten registrar y visualizar métricas como la pérdida, la precisión, la exhaustividad y mAP. Aplicar la parada temprana basándose en estas métricas también puede ayudar a obtener mejores resultados de entrenamiento.

  • Asegúrate de que el conjunto de datos y las etiquetas se ajustan al formato esperado. Comprueba que las anotaciones sean precisas y de alta calidad. Si tienes algún problema, consulta la guía Recopilación y anotación de datos para conocer las buenas prácticas. Para obtener orientación más específica sobre conjuntos de datos, consulta la sección Conjuntos de datos de la documentación.

Comentarios70

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  1. puzzlemindgamesGitHub

    I’ve been working on a browser-based puzzle solver project using Ultralytics YOLO for board and block detection. The model performs quite well locally, but I’m facing some inconsistent detection behavior after deployment and wanted to ask if anyone has experienced something similar.

    Current Stack: • YOLO (Ultralytics) • FastAPI • OpenCV • Python • Deployed on a low-memory cloud instance

    Issue: The model detects larger blocks correctly, but occasionally misses: • tightly packed shapes • small edge blocks • partially overlapping pieces • low-contrast screenshots from mobile devices This mostly happens on compressed screenshots uploaded by users.

    Current Inference Setup: from ultralytics import YOLO

    model = YOLO("best.pt")

    results = model.predict( source=image, imgsz=512, conf=0.35, max_det=100, verbose=False )

    Things I Already Tried • increasing imgsz • lowering confidence threshold • image sharpening with OpenCV • grayscale preprocessing • CLAHE contrast enhancement • retraining with more difficult samples

    Another Problem Memory usage spikes heavily during multiple inference requests. I solved most of it by forcing: WEB_CONCURRENCY=1 and reducing worker duplication, but I’m still curious if there’s a cleaner optimization strategy specifically for lightweight YOLO deployments.

    My Current Observation YOLO performs extremely well on clear geometric patterns, but puzzle-game screenshots seem tricky because: • blocks are visually similar • spacing is minimal • compression artifacts affect edges • mobile screenshots vary massively between devices

    Question Has anyone optimized YOLO specifically for: • grid-based games • puzzle detection • small repeated objects • mobile screenshot analysis

    Would love to hear: • pre-processing suggestions • augmentation ideas • lightweight deployment optimizations • whether segmentation models performed better for you

    For context, this is part of an AI-powered Block Blast solving project I’ve been experimenting with: https://www.aiblockblastsolver.com/ Appreciate any insights from people who’ve worked with similar detection challenges.

    1. Glenn JocherUltralytics

      For tightly packed small objects on compressed mobile screenshots, seg models often outperform pure detect, and the biggest gains usually come from training/inference at higher resolution plus augmentations that mimic JPEG artifacts, blur, scaling, and low contrast from real uploads; for deployment, keep one loaded model per process, warm it up, and use streaming-style inference to limit memory spikes, and if you can share a few failing images plus yolo checks in GitHub Discussions we can help narrow it down further—see Troubleshooting Common YOLO Issues, deployment best practices, and this small object mAP guide.

      1
    2. puzzlemindgamesGitHub

      Thanks for the detailed insights especially the point about segmentation models potentially outperforming pure detection for tightly packed puzzle objects.

      I’ve already started experimenting with stronger augmentation pipelines focused on: • JPEG compression artifacts • motion blur • brightness/contrast variation • slight perspective distortion and surprisingly, that alone improved small-shape consistency more than lowering confidence thresholds did. Furthermore, will explore the related guides and get back here if needed.

      Really appreciate the guidance.

    3. Glenn JocherUltralytics

      Good to hear that helped; the next thing I’d test is size-aware validation plus image tiling for training/inference, since tiny edge pieces often improve more from preserved spatial detail than from further conf tuning alone, and Model Evaluation Insights has a useful section on that.

  2. Mz-HanGitHub

    Hello, I am using the trained yolov26s-seg.pt for small object segmentation. When I set max-det to a value greater than 500, an error occurs. Would you have time to help me with this? Thank you very much!

    torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate4.95GiB (GPU 0;23.99 GiB total capacity;17.39 GiB already allocated; 0 bytes free; 17.65 GiB reserved in total by PyTorch) If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF

    1. Glenn JocherUltralytics

      That error is expected when max_det is pushed very high for segmentation—memory scales with the number of kept detections (and masks), so max_det>500 can OOM on a 24GB GPU; best next steps are to raise conf, lower imgsz, or keep max_det lower (see the GPU/OOM notes in YOLO common issues troubleshooting). If you think it’s a bug, please paste a text (not screenshot) minimal repro command plus yolo checks output as described in Minimum Reproducible Example.

      yolo task=segment mode=predict model=yolo26s-seg.pt source=your.mp4 imgsz=640 conf=0.4 max_det=300 half=True device=0
      yolo checks

      If reserved memory is much larger than allocated, also try setting this before running Python (then restart your session/kernel):

      export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128
  3. EvelynStockardGitHub

    Troubleshooting common YOLO issues involves checking model configuration, image input size, and environment setup to ensure smooth performance. Many users face errors during training or inference while working with https://yolov8.org/ due to version mismatches or incorrect paths.

  4. dvdfaceGitHub

    I ran into a problem. when I started training by yolo cli, after yolo read train and val dataset, it quited, I can only saw many python process in background, but their cpu usage was zero, gpu usage was zero?

    what's happened? How to figure it out?

    I have tried use python script instead , the same problem occured.

    how to tackle it?

    1. Glenn JocherUltralytics

      @dvdface this sounds like a DataLoader multiprocessing issue that can cause training to hang. Try these solutions in order:

      1. Disable multiprocessing workers by adding workers=0 to your training command:

        yolo train model=yolo11n.pt data=dataset.yaml workers=0
      2. Check your environment - ensure you're using the latest ultralytics version:

        pip install -U ultralytics
      3. Verify GPU setup - test if CUDA is working properly:

        import torch
        print(torch.cuda.is_available())
      4. Try a fresh environment - create a new virtual environment and reinstall dependencies if the above doesn't work.

      The workers=0 fix usually resolves hanging issues during training initialization. Let me know if this helps!

  5. sjocnjfjdGitHub

    I have looled  the issue  guides,but I can not find what I  want to solve my problem

    ---Original--- From: "Glenn @.> Date: Sat, Dec 7, 2024 01:27 AM To: @.>; Cc: @.@.>; Subject: Re: [ultralytics/ultralytics] zh/guides/yolo-common-issues/(Discussion #11739)

    @sjocnjfjd your YAML file seems mostly correct, but be cautious with the file path formatting. Replace D:python新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml with a properly formatted path (e.g., D:/python/新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml). Ensure all dataset paths are accessible and the Roboflow url is valid. If issues persist, refer to the YOLO Common Issues guide for troubleshooting.

    — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were mentioned.Message ID: @.***>

    1. Glenn JocherUltralytics

      @sjocnjfjd thank you for your comment. If you've already reviewed the issue guides and couldn't find a solution, please provide specific details about your problem, such as the error message or unexpected behavior you're encountering. This will help us assist you more effectively. Additionally, you can reference the YOLO Common Issues guide for further troubleshooting. Let us know how we can assist!

  6. sjocnjfjdGitHub

    it is my.yaml: path: D:python新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml train: images/train val: images/val test: images/test

    nc: 1 names: ['hakusen']

    roboflow:   workspace: kitazonoken   project: hakusenninnshiki   version: 2   license: CC BY 4.0   url: https://universe.roboflow.com/kitazonoken/hakusenninnshiki/dataset/2 is it right ?

    ---Original--- From: "Glenn @.> Date: Fri, Dec 6, 2024 23:59 PM To: @.>; Cc: @.@.>; Subject: Re: [ultralytics/ultralytics] zh/guides/yolo-common-issues/(Discussion #11739)

    @sjocnjfjd the error indicates a file path issue. Ensure your data parameter points to the correct yaml file and check that the dataset paths defined in the yaml file are valid and accessible. For guidance on dataset preparation and troubleshooting, refer to YOLO Common Issues. Let us know if you need further clarification!

    — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were mentioned.Message ID: @.***>

    1. Glenn JocherUltralytics

      @sjocnjfjd your YAML file seems mostly correct, but be cautious with the file path formatting. Replace D:python新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml with a properly formatted path (e.g., D:/python/新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml). Ensure all dataset paths are accessible and the Roboflow url is valid. If issues persist, refer to the YOLO Common Issues guide for troubleshooting.

  7. sjocnjfjdGitHub

    100 epochs completed in 0.146 hours. Optimizer stripped from runs/detect/train/weights/last.pt, 5.5MB Optimizer stripped from runs/detect/train/weights/best.pt, 5.5MB

    Validating runs/detect/train/weights/best.pt... Ultralytics 8.3.44 🚀 Python-3.10.12 torch-2.5.1+cu121 CUDA:0 (Tesla T4, 15102MiB) YOLO11n summary (fused): 238 layers, 2,582,347 parameters, 0 gradients, 6.3 GFLOPs

    FileNotFoundError Traceback (most recent call last) in <cell line: 4>() 2 3 model = YOLO('https://hub.ultralytics.com/models/kYDnuTY9JD3hHyFdnc5T') ----> 4 results = model.train(data='"D://python//新建文件夹 (2)//hakusenninnshiki.v2i.yolov11//lane.yaml"', project='runs/train', name='exp', epochs=100)

    6 frames /usr/local/lib/python3.10/dist-packages/ultralytics/data/utils.py in check_det_dataset(dataset, autodownload) 327 else: 328 m += f"\nNote dataset download directory is '{DATASETS_DIR}'. You can update this in '{SETTINGS_FILE}'" --> 329 raise FileNotFoundError(m) 330 t = time.time() 331 r = None # success

    FileNotFoundError: Dataset '/content/datasets/lane/lane.yaml' images not found ⚠️, missing path '/content/datasets/D:python新/建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml/images/val' Note dataset download directory is '/content/datasets'. You can update this in '/root/.config/Ultralytics/settings.json' why can i deploy

    1. Glenn JocherUltralytics

      @sjocnjfjd the error indicates a file path issue. Ensure your data parameter points to the correct yaml file and check that the dataset paths defined in the yaml file are valid and accessible. For guidance on dataset preparation and troubleshooting, refer to YOLO Common Issues. Let us know if you need further clarification!

  8. tylerfrisinger01GitHub

    is it possible that YOLOv11 will take a lot longer to train compared to YOLOv8? My model is currently doing about 1 epoch every hour and a half. I currently have it so it will do 300 epochs as recommended on the training page. Should i switch to YOLOv8 instead?

    1. tylerfrisinger01GitHub

      Is there anything I can do to increase the speed of training either v8 or v11? At this point I’m concerned it may take days. Should I only do 100 epochs the first training round and then train it again at 100? And again and again?

  9. xsvebmxGitHub

    Please help (

    cmd> yolo task=detect mode=train model=yolov8s.pt data=data_custom.yaml epochs=50 imgsz=640 batch=8

    train: Scanning X:\Desktop\NNXTSSS\train\labels.cache... 1 images, 12 backgrounds, 0 corrupt: 100%|██████████| 12/12 [00:00<?, ?it/s] WARNING ⚠️ No labels found in X:\Desktop\NNXTSSS\train\labels.cache, training may not work correctly. See https://docs.ultralytics.com/datasets for dataset formatting guidance. val: Scanning X:\Desktop\NNXTSSS\val\labels.cache... 0 images, 5 backgrounds, 0 corrupt: 100%|██████████| 5/5 [00:00<?, ?it/s] WARNING ⚠️ No labels found in X:\Desktop\NNXTSSS\val\labels.cache, training may not work correctly. See https://docs.ultralytics.com/datasets for dataset formatting guidance. Plotting labels to runs\detect\train7\labels.jpg... zero-size array to reduction operation maximum which has no identity

    WARNING ⚠️ no labels found in detect set, can not compute metrics without labels

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       2/50      2.02G          0      210.6          0          0        640: 100%|██████████| 2/2 [00:02<00:00,  1.45s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95):   0%|          | 0/1 [00:00<?, ?it/s]

    files

    data_custom.yaml

    val: X:/Desktop/NNXTSSS/val
    nc: 1
    
    names: ["hat"]```
    1. Glenn JocherUltralytics

      @xsvebmx it seems like there are no labels found in your dataset, which is causing the training issues. Please ensure that your label files are correctly formatted and located in the specified directories. You can refer to the dataset formatting guide at https://docs.ultralytics.com/datasets for more details. If the issue persists, double-check the paths in your data_custom.yaml file to ensure they point to the correct locations.

      1
    2. xsvebmxGitHub

      I was stupid , I compiled the data set incorrectly, and because of this, an error was issued, Thank you for support😁 (i wanna sleep😭)

  10. ManojShakyaGitHub

    Subject: Issue with False Object Detections in YOLOv8 Pre-Trained Model

    Dear Ultralytics Team,

    I am encountering an issue while using a pre-trained YOLOv8 model for object detection. When I input an image containing two objects, such as a cat and a dog, the model unexpectedly detects multiple other objects like a keyboard, sheep, car, train, bus, and more—none of which are actually present in the image and with 100 percentage probability score.

    Could you please provide guidance on how to resolve this issue? Any advice or recommendations would be greatly appreciated.

    1. Glenn JocherUltralytics

      @ManojShakya thank you for reaching out. It sounds like there might be an issue with the model's confidence threshold or potential data inconsistencies. First, ensure you're using the latest version of the YOLOv8 package. If the issue persists, try adjusting the confidence threshold to filter out low-confidence detections. Additionally, verify that your input images and annotations are correctly formatted. For more detailed troubleshooting, please refer to our Common Issues Guide.