Instalar Ultralytics

Ultralytics ofrece varios métodos de instalación, incluidos pip, conda y Docker. Puedes instalar YOLO a través del ultralytics paquete pip para la última versión estable, o clonando el Ultralytics GitHub repository para la versión más actual. Docker es también una opción para ejecutar el paquete en un contenedor aislado, lo que evita la instalación local.

Watch: Ultralytics YOLO Quick Start Guide

Instalar

![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ultralytics?logo=python&logoColor=gold)

Instala o actualiza el ultralytics paquete usando pip ejecutando pip install -U ultralytics. Para más detalles sobre el ultralytics paquete, visita el Python Package Index (PyPI).

# Install or upgrade the ultralytics package from PyPI
pip install -U ultralytics

También puedes instalar ultralytics directamente desde el Ultralytics GitHub repository. Esto puede ser útil si quieres la última versión de desarrollo. Asegúrate de tener la herramienta de línea de comandos Git instalada, y luego ejecuta:

# Install the ultralytics package from GitHub
pip install git+https://github.com/ultralytics/ultralytics.git@main

Consulta el archivo ultralytics pyproject.toml para obtener una lista de dependencias. Ten en cuenta que todos los ejemplos anteriores instalan todas las dependencias necesarias.

Consejo

PyTorch los requisitos varían según el sistema operativo y los requisitos de CUDA, así que instala PyTorch primero siguiendo las instrucciones en PyTorch.

PyTorch installation selector for different platforms

Instalación en servidor headless

Para entornos de servidor sin pantalla (p. ej., VMs en la nube, contenedores Docker, pipelines CI/CD), usa el ultralytics-opencv-headless paquete. Esto es idéntico al paquete estándar ultralytics pero depende de opencv-python-headless en lugar de opencv-python, evitando dependencias de GUI innecesarias y posibles errores de libGL.

Instalación Headless

pip install ultralytics-opencv-headless

Ambos paquetes proporcionan la misma funcionalidad y API. La variante headless simplemente excluye los componentes de GUI de OpenCV que requieren bibliotecas de visualización.

Instalación avanzada

Aunque los métodos de instalación estándar cubren la mayoría de los casos de uso, puede que necesites una configuración más a medida para desarrollo o configuraciones personalizadas.

Métodos avanzados

Si necesitas modificaciones personalizadas persistentes, puedes hacer un fork del repositorio de Ultralytics, realizar cambios en pyproject.toml u otro código, e instalar desde tu fork.

Fork el Ultralytics GitHub repository a tu propia cuenta de GitHub.

Clona tu fork localmente:

git clone https://github.com/YOUR_USERNAME/ultralytics.git
cd ultralytics

Crea una nueva rama para tus cambios:
```
git checkout -b my-custom-branch
```
Realiza tus modificaciones en pyproject.toml u otros archivos según sea necesario.

Haz commit y push de tus cambios:

git add .
git commit -m "My custom changes"
git push origin my-custom-branch

Instalar usando pip con la sintaxis git+https, apuntando a tu rama:

pip install git+https://github.com/YOUR_USERNAME/ultralytics.git@my-custom-branch

Usa Ultralytics con CLI

La interfaz de línea de comandos (CLI) de Ultralytics permite comandos sencillos de una sola línea sin necesidad de un entorno Python. La CLI no requiere personalización ni código Python; ejecuta todas las tareas desde la terminal con el comando yolo. Para más información sobre el uso de YOLO desde la línea de comandos, consulta la Guía de CLI.

Ejemplo

Los comandos de Ultralytics yolo utilizan la siguiente sintaxis:

yolo TASK MODE ARGS

TASK (opcional) es uno de (detect, segment, classify, pose, obb)
MODE (requerido) es uno de (train, val, predict, export, track, benchmark)
ARGS (opcional) son pares arg=value como imgsz=640 que sobrescriben los valores predeterminados.

Consulta todos los ARGS en la Guía de configuración completa o con el comando yolo cfg de la CLI.

Advertencia

Los argumentos deben pasarse como pares arg=value, separados por un signo = y delimitados por espacios. No uses prefijos de argumento -- ni comas , entre argumentos.

yolo predict model=yolo26n.pt imgsz=640 conf=0.25 ✅
yolo predict model yolo26n.pt imgsz 640 conf 0.25 ❌ (falta =)
yolo predict model=yolo26n.pt, imgsz=640, conf=0.25 ❌ (no uses ,)
yolo predict --model yolo26n.pt --imgsz 640 --conf 0.25 ❌ (no uses --)
yolo solution model=yolo26n.pt imgsz=640 conf=0.25 ❌ (usa solutions, no solution)

Guía de CLI

Usa Ultralytics con Python

La interfaz Python de Ultralytics YOLO ofrece una integración perfecta en proyectos Python, facilitando la carga, ejecución y procesamiento de las salidas del modelo. Diseñada para la simplicidad, la interfaz Python permite a los usuarios implementar rápidamente object detection, segmentación y clasificación. Esto convierte a la interfaz Python de YOLO en una herramienta invaluable para incorporar estas funcionalidades en proyectos Python.

Por ejemplo, los usuarios pueden cargar un modelo, entrenarlo, evaluar su rendimiento y exportarlo al formato ONNX con solo unas pocas líneas de código. Explora la Guía de Python para aprender más sobre el uso de YOLO en tus proyectos Python.

Ejemplo

from ultralytics import YOLO

# Create a new YOLO model from scratch
model = YOLO("yolo26n.yaml")

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo26n.pt")

# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.yaml", epochs=3)

# Evaluate the model's performance on the validation set
results = model.val()

# Perform object detection on an image using the model
results = model("https://ultralytics.com/images/bus.jpg")

# Export the model to ONNX format
success = model.export(format="onnx")

Guía de Python

Configuración de Ultralytics

La biblioteca Ultralytics incluye un SettingsManager para un control detallado sobre los experimentos, permitiendo a los usuarios acceder y modificar la configuración fácilmente. Almacenada en un archivo JSON dentro del directorio de configuración del usuario del entorno, esta configuración puede verse o modificarse en el entorno Python o a través de la interfaz de línea de comandos (CLI).

Inspeccionar configuración

Para ver la configuración actual:

Ver configuración

Usa Python para ver tu configuración importando el objeto settings desde el módulo ultralytics. Imprime y devuelve la configuración con estos comandos:

from ultralytics import settings

# View all settings
print(settings)

# Return a specific setting
value = settings["runs_dir"]

Modificación de ajustes

Ultralytics facilita la modificación de los ajustes de las siguientes formas:

Actualizar ajustes

En Python, utiliza el método update en el objeto settings :

from ultralytics import settings

# Update a setting
settings.update({"runs_dir": "/path/to/runs"})

# Update multiple settings
settings.update({"runs_dir": "/path/to/runs", "tensorboard": False})

# Reset settings to default values
settings.reset()

Comprender los ajustes

La siguiente tabla ofrece una visión general de los ajustes configurables dentro de Ultralytics, incluyendo valores de ejemplo, tipos de datos y descripciones.

Nombre	Valor de ejemplo	Tipo de dato	Descripción
`settings_version`	`'0.0.4'`	`str`	Los comandos de Ultralytics settings versión (distinta de la versión pip de Ultralytics)
`datasets_dir`	`'/path/to/datasets'`	`str`	Directorio donde se almacenan los datasets
`weights_dir`	`'/path/to/weights'`	`str`	Directorio donde se almacenan los pesos de los modelos
`runs_dir`	`'/path/to/runs'`	`str`	Directorio donde se almacenan las ejecuciones de los experimentos
`uuid`	`'a1b2c3d4'`	`str`	Identificador único para los ajustes actuales
`sync`	`True`	`bool`	Opción para sincronizar analíticas y fallos con la Ultralytics Platform
`api_key`	`''`	`str`	Ultralytics Platform API Key
`clearml`	`True`	`bool`	Opción para usar ClearML logging
`comet`	`True`	`bool`	Opción para usar Comet ML para el seguimiento y visualización de experimentos
`dvc`	`True`	`bool`	Opción para usar DVC para el seguimiento de experimentos y control de versiones
`hub`	`True`	`bool`	Opción para usar Ultralytics Platform integración
`mlflow`	`True`	`bool`	Opción para usar MLFlow para el seguimiento de experimentos
`neptune`	`True`	`bool`	Opción para usar Neptune para el seguimiento de experimentos
`raytune`	`True`	`bool`	Opción para usar Ray Tune para ajuste de hiperparámetros
`tensorboard`	`True`	`bool`	Opción para usar TensorBoard para visualización
`wandb`	`True`	`bool`	Opción para usar Weights & Biases logging
`vscode_msg`	`True`	`bool`	Cuando se detecta un terminal de VS Code, permite activar una solicitud para descargar la extensión Ultralytics-Snippets.

Revisa estos ajustes a medida que avances en tus proyectos o experimentos para asegurar una configuración óptima.

Preguntas frecuentes

¿Cómo instalo Ultralytics usando pip?

Instala Ultralytics con pip usando:

pip install -U ultralytics

Esto instala la última versión estable del paquete ultralytics desde PyPI. Para instalar la versión de desarrollo directamente desde GitHub:

pip install git+https://github.com/ultralytics/ultralytics.git

Asegúrate de que la herramienta de línea de comandos Git esté instalada en tu sistema.

¿Puedo instalar Ultralytics YOLO usando conda?

Sí, instala Ultralytics YOLO usando conda con:

conda install -c conda-forge ultralytics

Este método es una gran alternativa a pip, garantizando la compatibilidad con otros paquetes. Para entornos CUDA, instala ultralytics, pytorch, y pytorch-cuda juntos para resolver conflictos:

conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics

Para más instrucciones, consulta la Conda quickstart guide.

¿Cuáles son las ventajas de usar Docker para ejecutar Ultralytics YOLO?

Docker proporciona un entorno aislado y consistente para Ultralytics YOLO, garantizando un rendimiento fluido en todos los sistemas y evitando complejidades de instalación local. Las imágenes oficiales de Docker están disponibles en Docker Hub, con variantes para GPU, CPU, ARM64, NVIDIA Jetson, y Conda. Para descargar y ejecutar la última imagen:

# Pull the latest ultralytics image from Docker Hub
sudo docker pull ultralytics/ultralytics:latest

# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --runtime=nvidia --gpus all ultralytics/ultralytics:latest

Para instrucciones detalladas sobre Docker, consulta la Docker quickstart guide.

¿Cómo clono el repositorio de Ultralytics para el desarrollo?

Clona el repositorio de Ultralytics y configura un entorno de desarrollo con:

# Clone the ultralytics repository
git clone https://github.com/ultralytics/ultralytics

# Navigate to the cloned directory
cd ultralytics

# Install the package in editable mode for development
pip install -e .

Esto permite realizar contribuciones al proyecto o experimentar con el código fuente más reciente. Para más detalles, visita la Ultralytics GitHub repository.

¿Por qué debería usar la CLI de Ultralytics YOLO?

La CLI de Ultralytics YOLO simplifica la ejecución de tareas de detección de objetos sin necesidad de código Python, permitiendo comandos de una sola línea para entrenamiento, validación y predicción directamente desde tu terminal. La sintaxis básica es:

yolo TASK MODE ARGS

Por ejemplo, para entrenar un modelo de detección:

yolo train data=coco8.yaml model=yolo26n.pt epochs=10 lr0=0.01

Explora más comandos y ejemplos de uso en la Guía de CLI.