Install Ultralytics

Install or update the ultralytics package using pip by running pip install -U ultralytics. For more details on the ultralytics package, visit the Python Package Index (PyPI).

# Install the ultralytics package from PyPI
pip install ultralytics

You can also install ultralytics directly from the Ultralytics GitHub repository. This can be useful if you want the latest development version. Ensure you have the Git command-line tool installed, and then run:

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

Conda can be used as an alternative package manager to pip. For more details, visit Anaconda. The Ultralytics feedstock repository for updating the conda package is available at 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

Conda Docker Image

Ultralytics Conda Docker images are also available from DockerHub. These images are based on Miniconda3 and provide a straightforward way to start using ultralytics in a Conda environment.

# 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 --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs

Clone the Ultralytics GitHub repository if you are interested in contributing to development or wish to experiment with the latest source code. After cloning, navigate into the directory and install the package in editable mode -e using 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 .

Use Docker to execute the ultralytics package in an isolated container, ensuring consistent performance across various environments. By selecting one of the official ultralytics images from Docker Hub, you avoid the complexity of local installation and gain access to a verified working environment. Ultralytics offers five main supported Docker images, each designed for high compatibility and efficiency:

• Dockerfile: GPU image recommended for training.
• Dockerfile-arm64: Optimized for ARM64 architecture, suitable for deployment on devices like Raspberry Pi and other ARM64-based platforms.
• Dockerfile-cpu: Ubuntu-based CPU-only version, suitable for inference and environments without GPUs.
• Dockerfile-jetson: Tailored for NVIDIA Jetson devices, integrating GPU support optimized for these platforms.
• Dockerfile-python: Minimal image with just Python and necessary dependencies, ideal for lightweight applications and development.
• Dockerfile-conda: Based on Miniconda3 with a conda installation of the ultralytics package.

Here are the commands to get the latest image and execute it:

# 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 --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs

The above command initializes a Docker container with the latest ultralytics image. The -it flags assign a pseudo-TTY and keep stdin open, allowing interaction with the container. The --ipc=host flag sets the IPC (Inter-Process Communication) namespace to the host, which is essential for sharing memory between processes. The --gpus all flag enables access to all available GPUs inside the container, crucial for tasks requiring GPU computation.

Note: To work with files on your local machine within the container, use Docker volumes to mount a local directory into the container:

# 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

Replace /path/on/host with the directory path on your local machine, and /path/in/container with the desired path inside the Docker container.

For advanced Docker usage, explore the Ultralytics Docker Guide.

Ultralytics yolo commands use the following syntax:

yolo TASK MODE ARGS

See all ARGS in the full Configuration Guide or with the yolo cfg CLI command.

Train a detection model for 10 epochs with an initial learning rate of 0.01:

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

Predict a YouTube video using a pretrained segmentation model at image size 320:

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

Validate a pretrained detection model with a batch size of 1 and image size of 640:

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

Export a YOLOv11n classification model to ONNX format with an image size of 224x128 (no TASK required):

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

Count objects in a video or live stream using YOLO11:

yolo solutions count show=True

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

Monitor workout exercises using a YOLO11 pose model:

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

Use YOLO11 to count objects in a designated queue or region:

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

Perform object detection, instance segmentation, or pose estimation in a web browser using Streamlit:

yolo solutions inference

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

Run special commands to see the version, view settings, run checks, and more:

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

Use Python to view your settings by importing the settings object from the ultralytics module. Print and return settings with these commands:

from ultralytics import settings

# View all settings
print(settings)

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

The command-line interface allows you to check your settings with:

yolo settings

In Python, use the update method on the settings object:

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

To modify settings using the command-line interface:

# 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