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 or upgrade the ultralytics package from PyPI
pip install -U 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 Ultralytics Conda Docker también están disponibles en Docker Hub. 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 La flag permite el acceso a todas las GPUs disponibles dentro del contenedor, crucial para tareas que requieren computación mediante GPU.

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 --runtime=nvidia --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.

Si necesita modificaciones personalizadas persistentes, puede bifurcar el 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 my-custom-branch
   

4. Realice sus modificaciones. a datos pyproject.toml u otros archivos según sea necesario.
5. Confirmar y enviar tus cambios:

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

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

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

Clona el repositorio localmente, modifica los archivos según sea necesario e instala en modo editable.

1. Clonar el repositorio de Ultralytics:

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

2. Realice sus modificaciones. a datos pyproject.toml u otros archivos según sea necesario.
3. Instalar el paquete en modo editable (-e). Pip utilizará tu pyproject.toml para resolver las dependencias:

   pip install -e .
   

Este enfoque es útil para desarrollar o probar cambios locales antes de confirmarlos.

Especifique una Ultralytics personalizada Ultralytics en su requirements.txt archivo para garantizar instalaciones coherentes en todo tu equipo.

# Install ultralytics from a specific git branch
git+https://github.com/YOUR_USERNAME/ultralytics.git@my-custom-branch

# Other project dependencies
flask

Instala las dependencias desde el archivo:

pip install -r requirements.txt

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

Exporta un modelo de clasificación YOLO11n 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