Instalar Ultralytics

Instala o actualiza el ultralytics paquete usando pip ejecutando pip install -U ultralytics. Para obtener más detalles sobre el ultralytics paquete, visita el Índice de paquetes de Python (PyPI).

# Install the ultralytics package from PyPI
pip install ultralytics

También puede instalar ultralytics directamente desde el repositorio de Ultralytics en GitHub. Esto puede ser útil si desea la última versión de desarrollo. Asegúrese de tener instalada la herramienta de línea de comandos Git y, a continuación, ejecute:

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

Conda puede utilizarse como un gestor de paquetes alternativo a pip. Para obtener más información, visite Anaconda. El repositorio de fuentes de Ultralytics para actualizar el paquete conda está disponible en GitHub.

# Install the ultralytics package using conda
conda install -c conda-forge ultralytics

# Install all packages together using conda
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics

Imagen Docker de Conda

Las imágenes de Docker de Ultralytics Conda también están disponibles en DockerHub. Estas imágenes se basan en Miniconda3 y proporciona una forma sencilla de empezar a usar ultralytics en un entorno Conda.

# Set image name as a variable
t=ultralytics/ultralytics:latest-conda

# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t

# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --runtime=nvidia --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --runtime=nvidia --gpus '"device=2,3"' $t # specify GPUs

Clona el repositorio de Ultralytics en GitHub si le interesa contribuir al desarrollo o desea experimentar con el código fuente más reciente. Después de clonar, navegue al directorio e instale el paquete en modo editable -e usando pip.

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

Utilice Docker para ejecutar el ultralytics paquete en un contenedor aislado, lo que garantiza un rendimiento constante en diversos entornos. Al seleccionar uno de los ultralytics de Docker Hub, evita la complejidad de la instalación local y obtiene acceso a un entorno de trabajo verificado. Ultralytics ofrece cinco imágenes Docker principales soportadas, cada una diseñada para una alta compatibilidad y eficiencia:

• Dockerfile: Imagen GPU recomendada para el entrenamiento.
• Dockerfile-arm64: Optimizado para la arquitectura ARM64, adecuado para la implementación en dispositivos como Raspberry Pi y otras plataformas basadas en ARM64.
• Dockerfile-cpu: Versión basada en Ubuntu solo para CPU, adecuada para inferencia y entornos sin GPUs.
• Dockerfile-jetson: Diseñado para dispositivos NVIDIA Jetson, integrando soporte de GPU optimizado para estas plataformas.
• Dockerfile-python: Imagen mínima solo con Python y las dependencias necesarias, ideal para aplicaciones ligeras y desarrollo.
• Dockerfile-conda: Basado en Miniconda3 con una instalación de conda del ultralytics paquete.

Aquí están los comandos para obtener la última imagen y ejecutarla:

# Set image name as a variable
t=ultralytics/ultralytics:latest

# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t

# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --runtime=nvidia --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --runtime=nvidia --gpus '"device=2,3"' $t # specify GPUs

El comando anterior inicializa un contenedor Docker con la última imagen ultralytics . El indicador -it Las flags asignan un pseudo-TTY y mantienen stdin abierto, permitiendo la interacción con el contenedor. El --ipc=host establece el espacio de nombres IPC (Inter-Process Communication) en el host, lo cual es esencial para compartir memoria entre procesos. El indicador --gpus all flag enables access to all available GPUs inside the container, crucial for tasks requiring GPU computation.

Nota: Para trabajar con archivos en tu máquina local dentro del contenedor, utiliza volúmenes de Docker para montar un directorio local en el contenedor:

# Mount local directory to a directory inside the container
sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t

Reemplaza /path/on/host con la ruta del directorio en tu máquina local, y /path/in/container con la ruta deseada dentro del contenedor Docker.

Para un uso avanzado de Docker, explora la Guía de Docker de Ultralytics.

Puede instalar el ultralytics paquete core sin dependencias utilizando pip --no-deps indicador. Esto requiere que instale manualmente todas las dependencias necesarias posteriormente.

1. Instalar ultralytics núcleo:

   pip install ultralytics --no-deps
   

2. Instale las dependencias manualmente: Debes instalar todos los paquetes requeridos que se enumeran en el pyproject.toml archivo, sustituyendo o modificando las versiones según sea necesario. Para el ejemplo de OpenCV sin interfaz gráfica:

   # Install other core dependencies
   pip install torch torchvision numpy matplotlib polars pyyaml pillow psutil requests scipy ultralytics-thop
   
   # Install headless OpenCV instead of the default
   pip install opencv-python-headless
   

Si necesitas modificaciones personalizadas persistentes (como usar siempre opencv-python-headless), puede bifurcar el repositorio de Ultralytics, realizar cambios en pyproject.toml u otro código, e instala desde tu fork.

1. Haz un fork del repositorio de Ultralytics en GitHub a tu propia cuenta de GitHub.
2. Clonar tu bifurcación localmente:

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

3. Crear una nueva rama para tus cambios:

   git checkout -b custom-opencv
   

4. Modificar pyproject.toml: Abrir pyproject.toml en un editor de texto y reemplaza la línea que contiene "opencv-python>=4.6.0" con "opencv-python-headless>=4.6.0" (ajusta la versión según sea necesario).
5. Confirmar y enviar tus cambios:

   git add pyproject.toml
   git commit -m "Switch to opencv-python-headless"
   git push origin custom-opencv
   

6. Instalar usando pip con el git+https sintaxis, apuntando a su branch:

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

Este método asegura que tu conjunto de dependencias personalizado se utilice siempre que instales desde esta URL específica. Consulta el Método 4 para usar esto en un requirements.txt archivo.

De forma similar al método estándar "Git Clone" para el desarrollo, puedes clonar el repositorio localmente, modificar los archivos de dependencia antes de la instalación y, a continuación, instalar en modo editable.

1. Clonar el repositorio de Ultralytics:

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

2. Modificar pyproject.toml: Edita el archivo para realizar los cambios deseados. Por ejemplo, usa sed (en Linux/macOS) o un editor de texto para reemplazar opencv-python con opencv-python-headless. Usando sed (verifica la línea exacta en pyproject.toml primero):

   # Example: Replace the line starting with "opencv-python..."
   # Adapt the pattern carefully based on the current file content
   sed -i'' -e 's/^\s*"opencv-python>=.*",/"opencv-python-headless>=4.8.0",/' pyproject.toml
   

   O editar manualmente pyproject.toml para cambiar "opencv-python>=... a datos "opencv-python-headless>=...".
3. Instalar el paquete en modo editable (-e). Pip ahora usará su pyproject.toml para resolver e instalar las dependencias:

   pip install -e .
   

Este enfoque es útil para probar cambios locales en las dependencias o configuraciones de compilación antes de confirmarlos o para configurar entornos de desarrollo específicos.

Si gestionas las dependencias de tu proyecto utilizando un requirements.txt archivo, puede especificar su bifurcación personalizada de Ultralytics directamente dentro de él. Esto asegura que cualquiera que configure el proyecto obtenga su versión específica con sus dependencias modificadas (como opencv-python-headless).

1. Crear o editar requirements.txt: Añade una línea que apunte a tu fork y branch personalizados (como se preparó en el Método 2).
   requirements.txt

   # Core dependencies
   numpy
   matplotlib
   polars
   pyyaml
   Pillow
   psutil
   requests>=2.23.0
   torch>=1.8.0 # Or specific version/variant
   torchvision>=0.9.0 # Or specific version/variant
   
   # Install ultralytics from a specific git commit or branch
   # Replace YOUR_USERNAME and custom-branch with your details
   git+https://github.com/YOUR_USERNAME/ultralytics.git@custom-branch
   
   # Other project dependencies
   flask
   # ... etc
   

   Nota: No es necesario enumerar las dependencias que ya requiere su ultralytics bifurcación (como opencv-python-headless) aquí, ya que pip los instalará basándose en el fork pyproject.toml.
2. Instalar dependencias del archivo:

   pip install -r requirements.txt
   

Este método se integra perfectamente con los flujos de trabajo estándar de gestión de dependencias de proyectos de python, al tiempo que te permite fijar ultralytics a su fuente Git personalizada.

Ultralytics yolo los comandos utilizan la siguiente sintaxis:

yolo TASK MODE ARGS

Ver todo ARGS en la guía completa de Configuración o con el comando yolo cfg de la CLI.

Entrena un modelo de detección durante 10 épocas con una tasa de aprendizaje inicial de 0.01:

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

Predice un video de YouTube utilizando un modelo de segmentación preentrenado con un tamaño de imagen de 320:

yolo predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320

Validar un modelo de detección preentrenado con un tamaño de lote de 1 y un tamaño de imagen de 640:

yolo val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640

Exporte un modelo de clasificación YOLOv11n al formato ONNX con un tamaño de imagen de 224x128 (no se requiere TASK):

yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128

Contar objetos en un vídeo o transmisión en vivo usando YOLO11:

yolo solutions count show=True

yolo solutions count source="path/to/video.mp4" # specify video file path

Supervisar los ejercicios de entrenamiento utilizando un modelo de pose YOLO11:

yolo solutions workout show=True

yolo solutions workout source="path/to/video.mp4" # specify video file path

# Use keypoints for ab-workouts
yolo solutions workout kpts="[5, 11, 13]" # left side
yolo solutions workout kpts="[6, 12, 14]" # right side

Utilice YOLO11 para contar objetos en una cola o región designada:

yolo solutions queue show=True

yolo solutions queue source="path/to/video.mp4" # specify video file path

yolo solutions queue region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]" # configure queue coordinates

Realice detección de objetos, segmentación de instancias o estimación de poses en un navegador web utilizando Streamlit:

yolo solutions inference

yolo solutions inference model="path/to/model.pt" # use model fine-tuned with Ultralytics Python package

Ejecute comandos especiales para ver la versión, la configuración de la vista, ejecute comprobaciones y más:

yolo help
yolo checks
yolo version
yolo settings
yolo copy-cfg
yolo cfg
yolo solutions help

Utilice python para ver su configuración importando el settings objeto del ultralytics módulo. 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"]

La interfaz de línea de comandos le permite verificar su configuración con:

yolo settings

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

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

Para modificar la configuración mediante la interfaz de línea de comandos:

# Update a setting
yolo settings runs_dir='/path/to/runs'

# Update multiple settings
yolo settings runs_dir='/path/to/runs' tensorboard=False

# Reset settings to default values
yolo settings reset