Ultralytics YOLO

https://docs.ultralytics.com
Admin
Ultralytics YOLO is a family of real-time object detection and image segmentation models known for...
Tokens:3,922,069
Snippets:21,913
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start training with Python SDK

Source: https://docs.ultralytics.com/platform/api

Python SDK example to start training. Prints the estimated cost display from the response. Returns `402` for low balance and `503` for no capacity.

```python
resp = client.training.start(
    model_id="65f1c0a2b3d4e5f601234599",
    gpu_type="rtx-4090",
    train_args={
        "model": "yolo26n.pt",
        "data": "ul://acme-vision/datasets/warehouse",
        "epochs": 100,
        "imgsz": 640,
        "batch": 16,
    },
)
print(resp["billing"]["estimatedCostDisplay"])
```

--------------------------------

### YOLO27 Quickstart: Python and CLI inference

Source: https://docs.ultralytics.com/models/yolo27

Quickstart example for running inference with a pretrained YOLO27n model after release. The Python snippet loads the model and runs inference on an image; the CLI command performs the same prediction. These examples will not work with the current public package and are intended for use once the models and package support are released.

```python
from ultralytics import YOLO

model = YOLO("yolo27n.pt")  # load a pretrained YOLO27n model
results = model("path/to/bus.jpg")  # run inference
```

```bash
yolo predict model=yolo27n.pt source=path/to/bus.jpg
```

--------------------------------

### Install ultralytics and run YOLO26 prediction

Source: https://docs.ultralytics.com/

Two-command quickstart: install the ultralytics package and run a YOLO26 prediction. The model weights and example image download automatically; the annotated result is saved to the directory the command prints, runs/detect/predict on a first run.

```bash
# Install the ultralytics package from PyPI
pip install ultralytics

```

```bash
# Detect objects in an image with a pretrained YOLO26 model
yolo predict model=yolo26n.pt source='https://github.com/ultralytics/assets/releases/download/v0.0.0/bus.jpg'

```

--------------------------------

### Start training with cURL

Source: https://docs.ultralytics.com/platform/api

cURL example to start a training job. Replace `YOUR_API_KEY` with your key. The response includes billing estimates; returns `402` for insufficient balance and `503` for no GPU capacity.

```bash
curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "modelId": "65f1c0a2b3d4e5f601234599",
    "gpuType": "rtx-4090",
    "trainArgs": {
      "model": "yolo26n.pt",
      "data": "ul://acme-vision/datasets/warehouse",
      "epochs": 100,
      "imgsz": 640,
      "batch": 16
    }
  }' \
  https://platform.ultralytics.com/api/training/start
```

--------------------------------

### Start training response

Source: https://docs.ultralytics.com/platform/api

Example response from the start training endpoint. Shows the job status, GPU type, estimated cost, and billing details.

```json
{
    "modelId": "65f1c0a2b3d4e5f601234599",
    "status": "starting",
    "gpuType": "rtx-4090",
    "estimatedCost": { "pricePerHour": 0.69, "gpuMemoryGb": 24 },
    "billing": {
        "estimatedCostCents": 138,
        "estimatedCostDisplay": "$1.38",
        "balanceCents": 2500
    }
}
```

--------------------------------

### add_callback usage example

Source: https://docs.ultralytics.com/reference/engine/model

Shows how to register a callback for the 'on_train_start' event and then start training. The callback prints a message when training starts.

```python
>>> def on_train_start(trainer):
...     print("Training is starting!")
>>> model = YOLO("yolo26n.pt")
>>> model.add_callback("on_train_start", on_train_start)
>>> model.train(data="coco8.yaml", epochs=1)
```

--------------------------------

### Install SAHI and Ultralytics

Source: https://docs.ultralytics.com/guides/sahi-tiled-inference

Install the latest versions of SAHI and Ultralytics to get started with sliced inference.

```bash
pip install -U ultralytics sahi
```

--------------------------------

### Initialize ClearML SDK

Source: https://docs.ultralytics.com/integrations/clearml

Run this command to start the ClearML SDK setup process. It prompts for credentials to connect your environment to the ClearML server.

```bash
# Initialize your ClearML SDK setup process
clearml-init
```

--------------------------------

### Remote training setup and command

Source: https://docs.ultralytics.com/platform/account/api-keys

Install or update the Ultralytics package on Python>=3.11, then set the API key and start remote training with metric streaming.

```bash
pip install -U ultralytics
```

```bash
export ULTRALYTICS_API_KEY="YOUR_API_KEY"
yolo train model=yolo26n.pt data=coco.yaml project=username/project name=exp1
```

--------------------------------

### Setup: pretrained ResNet-18 in eval mode

Source: https://docs.ultralytics.com/guides/export-non-yolo-models

Sets up a pretrained ResNet-18 from timm in evaluation mode with a random input tensor. Used as the common starting point for all export examples on this page.

```python
import timm
import torch

model = timm.create_model("resnet18", pretrained=True).eval()
im = torch.randn(1, 3, 224, 224)
```

--------------------------------

### Set up environment and install OpenVINO and Ultralytics

Source: https://docs.ultralytics.com/guides/dlstreamer-intel

Creates the demo directory, sets up a Python virtual environment, and installs OpenVINO 2026.2.0 and Ultralytics 8.4.92. Run these commands before exporting the YOLO26 model.

```bash
mkdir -p ~/intel/dlstreamer_demo && cd ~/intel/dlstreamer_demo
python3 -m venv .dls-venv && source .dls-venv/bin/activate
pip install openvino==2026.2.0 ultralytics==8.4.92
```

--------------------------------

### Install Gradio with pip

Source: https://docs.ultralytics.com/integrations/gradio

Installs the Gradio library, which is required to run the interface example.

```bash
pip install gradio
```

--------------------------------

### CLIP.encode_image usage example

Source: https://docs.ultralytics.com/reference/nn/text_model

Example usage of CLIP.encode_image to encode an image and get feature shape.

```python
>>> from ultralytics.nn.text_model import CLIP
>>> from PIL import Image
>>> clip_model = CLIP("ViT-B/32", device="cuda")
>>> image = Image.open("path/to/image.jpg")
>>> image_tensor = clip_model.image_preprocess(image).unsqueeze(0).to("cuda")
>>> features = clip_model.encode_image(image_tensor)
>>> features.shape
torch.Size([1, 512])
```

--------------------------------

### Set up ClearML logging with clearml.browser_login()

Source: https://docs.ultralytics.com/modes/train

Install the clearml package and authenticate via browser login. After running, sign in to the ClearML account in the browser to authenticate the session.

```python
# pip install clearml
import clearml

clearml.browser_login()
```

--------------------------------

### IterableSimpleNamespace usage example

Source: https://docs.ultralytics.com/reference/utils/__init__

Example usage of IterableSimpleNamespace showing iteration over key-value pairs, string representation, and the get method with a default value. The output demonstrates that iteration yields attributes in insertion order and get returns the default when the key is missing.

```python
>>> cfg = IterableSimpleNamespace(a=1, b=2, c=3)
>>> for k, v in cfg:
...     print(f"{k}: {v}")
a: 1
b: 2
c: 3
>>> print(cfg)
a=1
b=2
c=3
>>> cfg.get("b")
2
>>> cfg.get("d", "default")
'default'
```

--------------------------------

### Example: Create ParkingPtsSelection and use GUI

Source: https://docs.ultralytics.com/reference/solutions/parking_management

Example usage of the ParkingPtsSelection class. Creates an instance and then interact with the GUI to upload an image, select parking zones, and save the data.

```python
>>> parking_selector = ParkingPtsSelection()
>>> # Use the GUI to upload an image, select parking zones, and save the data
```

--------------------------------

### Example: Initialize trackers for a predictor object

Source: https://docs.ultralytics.com/reference/trackers/track

Shows how to call on_predict_start with a predictor instance and persist=True to reuse existing trackers.

```python
>>> predictor = SomePredictorClass()
>>> on_predict_start(predictor, persist=True)
```

--------------------------------

### Example: AutoBackend._model_type usage

Source: https://docs.ultralytics.com/reference/nn/autobackend

Example usage of AutoBackend._model_type showing how to get the format string for an ONNX model and assert it equals 'onnx'.

```python
>>> fmt = AutoBackend._model_type("path/to/model.onnx")
>>> assert fmt == "onnx"
```

--------------------------------

### Albumentations usage example

Source: https://docs.ultralytics.com/reference/data/augment

Example usage: instantiate Albumentations with a probability of 0.5 and apply it to a labels dictionary to get augmented labels.

```python
>>> transform = Albumentations(p=0.5)
>>> augmented_labels = transform(labels)
```

--------------------------------

### Install dependencies and run FastAPI server with uv

Source: https://docs.ultralytics.com/guides/vertex-ai-deployment-with-docker

Install dependencies and run the FastAPI server locally using uv. Use these commands to test the server before deploying to Vertex AI.

```bash
# Install dependencies
uv pip install -e .

# Run the FastAPI server directly
uv run src/main.py
```

--------------------------------

### setup_model method

Source: https://docs.ultralytics.com/reference/models/yolo/yoloe/predict

Sets up the model for prediction. Calls super().setup_model(model, verbose=verbose) and sets done_warmup to True.

```python
def setup_model(self, model, verbose: bool = True):
    """Set up the model for prediction.

    Args:
        model (torch.nn.Module): Model to load or use.
        verbose (bool, optional): If True, provides detailed logging.
    """
    super().setup_model(model, verbose=verbose)
    self.done_warmup = True
```

--------------------------------

### setup_model method implementation

Source: https://docs.ultralytics.com/reference/engine/predictor

Initializes a YOLO model with given parameters, sets it to evaluation mode, and compiles it if requested. Uses AutoBackend to load the model and updates the device.

```python
@smart_inference_mode(False)
def setup_model(self, model, verbose: bool = True):
    """Initialize YOLO model with given parameters and set it to evaluation mode.

    Args:
        model (str | Path | torch.nn.Module): Model to load or use.
        verbose (bool): Whether to print verbose output.
    """
    model = deepcopy(model)
    self.model = AutoBackend(
        model=model or self.args.model,
        device=select_device(self.args.device, verbose=verbose),
        dnn=self.args.dnn,
        data=self.args.data,
        fp16=self.args.quantize == 16,
        channels_last=self.args.channels_last,
        fuse=True,
        verbose=verbose,
        end2end=self.args.nms is False,
    )

    self.device = self.model.device  # update device
    self.model.eval()
    self.model = attempt_compile(self.model, device=self.device, mode=self.args.compile)
```

--------------------------------

### Install Ultralytics from GitHub

Source: https://docs.ultralytics.com/help/FAQ

Installs the latest development version of Ultralytics directly from the GitHub repository. Use this to get the most recent features and fixes.

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

--------------------------------

### preprocess usage example

Source: https://docs.ultralytics.com/reference/models/sam/predict

Example usage of preprocess. Creates a Predictor and a random BCHW tensor, then calls preprocess to get the preprocessed image.

```python
>>> predictor = Predictor()
>>> image = torch.rand(1, 3, 640, 640)
>>> preprocessed_image = predictor.preprocess(image)
```

--------------------------------

### Python Quickstart: Load YOLO26n and run inference

Source: https://docs.ultralytics.com/models/yolo26

Loads a pretrained YOLO26n model and runs inference on an image. Requires the ultralytics package.

```python
from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # load a pretrained YOLO26n model
results = model("path/to/bus.jpg")  # run inference
```

--------------------------------

### ParkingManagement.process usage example

Source: https://docs.ultralytics.com/reference/solutions/parking_management

Example usage of the ParkingManagement.process method. It creates a ParkingManagement instance with a JSON file, reads an image, and processes it to get results.

```python
>>> parking_manager = ParkingManagement(json_file="parking_regions.json")
>>> image = cv2.imread("parking_lot.jpg")
>>> results = parking_manager.process(image)
```

--------------------------------

### YOLOEVPDetectPredictor.setup_model

Source: https://docs.ultralytics.com/reference/models/yolo/yoloe/predict

Sets up the model for prediction by calling the parent setup and marking warmup as done.

```APIDOC
## Method `ultralytics.models.yolo.yoloe.predict.YOLOEVPDetectPredictor.setup_model`

### Description
Set up the model for prediction.

### Method
`setup_model(self, model, verbose: bool = True)`

### Parameters
- **model** (torch.nn.Module) - Required - Model to load or use.
- **verbose** (bool, optional) - If True, provides detailed logging. Default: `True`.

### Source Code
```python
def setup_model(self, model, verbose: bool = True):
    """Set up the model for prediction.

    Args:
        model (torch.nn.Module): Model to load or use.
        verbose (bool, optional): If True, provides detailed logging.
    """
    super().setup_model(model, verbose=verbose)
    self.done_warmup = True
```
```

--------------------------------

### CopyPaste usage example

Source: https://docs.ultralytics.com/reference/data/augment

Example usage of the CopyPaste augmentation. Instantiate with a dataset and paste fraction, then call the instance on original labels to get augmented labels.

```python
>>> from ultralytics.data.augment import CopyPaste
>>> dataset = YourDataset(...)  # Your image dataset
>>> copypaste = CopyPaste(dataset, p=0.5)
>>> augmented_labels = copypaste(original_labels)
```

--------------------------------

### Set up Comet logging with comet_ml.login()

Source: https://docs.ultralytics.com/modes/train

Install the comet_ml package and log in to Comet. Requires a Comet account and API key, which must be added to environment variables or the script.

```python
# pip install comet_ml
import comet_ml

comet_ml.login()
```

--------------------------------

### Initialize DetectionTrainer and start training

Source: https://docs.ultralytics.com/reference/engine/trainer

Initialize a task trainer (a BaseTrainer subclass) and start training. This example uses DetectionTrainer with overrides for model, data, and epochs.

```python
>>> from ultralytics.models.yolo.detect import DetectionTrainer
>>> trainer = DetectionTrainer(overrides={"model": "yolo26n.pt", "data": "coco8.yaml", "epochs": 1})
>>> trainer.train()
```
Tokens:
Raw