Ultralytics provides various installation methods including pip, conda, and Docker. Install YOLOv8 via the
ultralytics pip package for the latest stable release or by cloning the Ultralytics GitHub repository for the most up-to-date version. Docker can be used to execute the package in an isolated container, avoiding local installation.
Watch: Ultralytics YOLO Quick Start Guide
ultralytics package using pip, or update an existing installation by running
pip install -U ultralytics. Visit the Python Package Index (PyPI) for more details on the
ultralytics package: https://pypi.org/project/ultralytics/.
You can also install the
ultralytics package directly from the GitHub repository. This might be useful if you want the latest development version. Make sure to have the Git command-line tool installed on your system. The
@main command installs the
main branch and may be modified to another branch, i.e.
@my-branch, or removed entirely to default to
Conda is an alternative package manager to pip which may also be used for installation. Visit Anaconda for more details at https://anaconda.org/conda-forge/ultralytics. Ultralytics feedstock repository for updating the conda package is at https://github.com/conda-forge/ultralytics-feedstock/.
If you are installing in a CUDA environment best practice is to install
pytorch-cuda in the same command to allow the conda package manager to resolve any conflicts, or else to install
pytorch-cuda last to allow it override the CPU-specific
pytorch package if necessary.
Conda Docker Image
# 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
ultralytics repository if you are interested in contributing to the 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.
Utilize Docker to effortlessly execute the
ultralytics package in an isolated container, ensuring consistent and smooth performance across various environments. By choosing one of the official
ultralytics images from Docker Hub, you not only avoid the complexity of local installation but also benefit from access to a verified working environment. Ultralytics offers 5 main supported Docker images, each designed to provide high compatibility and efficiency for different platforms and use cases:
- Dockerfile: GPU image recommended for training.
- Dockerfile-arm64: Optimized for ARM64 architecture, allowing 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 conda installation of ultralytics package.
Below 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 flag assigns a pseudo-TTY and maintains stdin open, enabling you to interact 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, which is crucial for tasks that require GPU computation.
Note: To work with files on your local machine within the container, use Docker volumes for mounting a local directory into the container:
/path/on/host with the directory path on your local machine, and
/path/in/container with the desired path inside the Docker container for accessibility.
For advanced Docker usage, feel free to explore the Ultralytics Docker Guide.
ultralytics requirements.txt file for a list of dependencies. Note that all examples above install all required dependencies.
PyTorch requirements vary by operating system and CUDA requirements, so it's recommended to install PyTorch first following instructions at https://pytorch.org/get-started/locally.
Use Ultralytics with CLI
The Ultralytics command line interface (CLI) allows for simple single-line commands without the need for a Python environment. CLI requires no customization or Python code. You can simply run all tasks from the terminal with the
yolo command. Check out the CLI Guide to learn more about using YOLOv8 from the command line.
yolo commands use the following syntax:
TASK(optional) is one of (detect, segment, classify, pose)
MODE(required) is one of (train, val, predict, export, track)
imgsz=640that override defaults.
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
Predict a YouTube video using a pretrained segmentation model at image size 320:
Val a pretrained detection model at batch-size 1 and image size 640:
Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
Arguments must be passed as
arg=val pairs, split by an equals
= sign and delimited by spaces between pairs. Do not use
-- argument prefixes or commas
, between arguments.
yolo predict model=yolov8n.pt imgsz=640 conf=0.25✅
yolo predict model yolov8n.pt imgsz 640 conf 0.25❌ (missing
yolo predict model=yolov8n.pt, imgsz=640, conf=0.25❌ (do not use
yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25❌ (do not use
Use Ultralytics with Python
YOLOv8's Python interface allows for seamless integration into your Python projects, making it easy to load, run, and process the model's output. Designed with simplicity and ease of use in mind, the Python interface enables users to quickly implement object detection, segmentation, and classification in their projects. This makes YOLOv8's Python interface an invaluable tool for anyone looking to incorporate these functionalities into their Python projects.
For example, users can load a model, train it, evaluate its performance on a validation set, and even export it to ONNX format with just a few lines of code. Check out the Python Guide to learn more about using YOLOv8 within your Python projects.
from ultralytics import YOLO # Create a new YOLO model from scratch model = YOLO('yolov8n.yaml') # Load a pretrained YOLO model (recommended for training) model = YOLO('yolov8n.pt') # Train the model using the 'coco128.yaml' dataset for 3 epochs results = model.train(data='coco128.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')
The Ultralytics library provides a powerful settings management system to enable fine-grained control over your experiments. By making use of the
SettingsManager housed within the
ultralytics.utils module, users can readily access and alter their settings. These are stored in a YAML file and can be viewed or modified either directly within the Python environment or via the Command-Line Interface (CLI).
To gain insight into the current configuration of your settings, you can view them directly:
You can use Python to view your settings. Start by importing the
settings object from the
ultralytics module. Print and return settings using the following commands:
Ultralytics allows users to easily modify their settings. Changes can be performed in the following ways:
Within the Python environment, call the
update method on the
settings object to change your settings:
If you prefer using the command-line interface, the following commands will allow you to modify your settings:
The table below provides an overview of the settings available for adjustment within Ultralytics. Each setting is outlined along with an example value, the data type, and a brief description.
|Name||Example Value||Data Type||Description|
||Ultralytics settings version (different from Ultralytics pip version)|
||The directory where the datasets are stored|
||The directory where the model weights are stored|
||The directory where the experiment runs are stored|
||The unique identifier for the current settings|
||Whether to sync analytics and crashes to HUB|
||Ultralytics HUB API Key|
||Whether to use ClearML logging|
||Whether to use Comet ML for experiment tracking and visualization|
||Whether to use DVC for experiment tracking and version control|
||Whether to use Ultralytics HUB integration|
||Whether to use MLFlow for experiment tracking|
||Whether to use Neptune for experiment tracking|
||Whether to use Ray Tune for hyperparameter tuning|
||Whether to use TensorBoard for visualization|
||Whether to use Weights & Biases logging|
As you navigate through your projects or experiments, be sure to revisit these settings to ensure that they are optimally configured for your needs.
Created 2023-11-12, Updated 2023-12-10
Authors: firstname.lastname@example.org (2), glenn-jocher (4), Laughing-q (1), AyushExel (1)