Models

Ultralytics Platform provides comprehensive model management for training, analyzing, and deploying YOLO models. Upload pretrained models or train new ones directly on the platform.

Upload Model

Upload existing model weights to the platform:

1. Navigate to your project
2. Drag and drop .pt files onto the project page or models sidebar
3. Model metadata is parsed automatically from the file

Multiple files can be uploaded simultaneously (up to 3 concurrent).

Supported model formats:

After upload, the platform parses model metadata:

• Task type (detect, segment, semantic, pose, OBB, classify)
• Architecture (YOLO26n, YOLO26s, etc.)
• Class names and count
• Input size and parameters
• Training results and metrics (if present in checkpoint)

Train Model

Train a new model directly on the platform:

1. Navigate to your project
2. Click New Model
3. Select base model and dataset
4. Configure training parameters
5. Choose cloud or local training
6. Start training

See Cloud Training for detailed instructions.

Model Lifecycle

graph LR
    A[Upload .pt]:::start --> B[Overview]:::proc
    C[Train]:::start --> B
    B --> D[Predict]:::proc
    B --> E[Export]:::proc
    B --> F[Deploy]:::proc
    E --> G[19+ Formats]:::out
    F --> H[Endpoint]:::out

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff

Model Page Tabs

Each model page has the following tabs:

Overview Tab

Displays model metadata and key metrics:

• Model name (editable), status badge, task type
• Final metrics (mAP50, mAP50-95, precision, recall)
• Metric sparkline charts showing training progression
• Training arguments (epochs, batch size, image size, etc.)
• Dataset link (when trained with a Platform dataset)
• Download button for model weights

Train Tab

The Train tab has three subtabs:

Charts Subtab

Interactive training metric charts showing loss curves and performance metrics over epochs:

Console Subtab

Live console output from the training process:

• Real-time log streaming during training
• Epoch progress bars and validation results
• Error detection with highlighted error banners
• ANSI color support for formatted output

System Subtab

GPU and system metrics during training:

Predict Tab

Run interactive inference directly in the browser:

• Upload an image, use example images, or use webcam
• Results display with bounding boxes, masks, semantic class maps, or keypoints
• Auto-inference when an image is provided
• Supports all task types (detect, segment, semantic, pose, OBB, classify)

!!! tip "Quick Testing"

The Predict tab runs inference on Ultralytics Cloud, so you don't need a local GPU. Results are displayed with interactive overlays matching the model's task type.

Export Tab

Export your model to 19+ deployment formats. See Export Model below and the core Export mode guide for full details.

Deploy Tab

Create and manage dedicated inference endpoints. See Deployments for details.

Validation Plots

After training completes, view detailed validation analysis:

Confusion Matrix

Interactive heatmap showing prediction accuracy per class:

PR/F1 Curves

Performance curves at different confidence thresholds:

Export Model

graph LR
    A[Select Format]:::start --> B[Configure Args]:::proc
    B --> C[Export]:::proc
    C --> D{GPU Required?}:::decide
    D -->|Yes| E[Cloud GPU Export]:::proc
    D -->|No| F[CPU Export]:::proc
    E --> G[Download]:::out
    F --> G

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff

Export your model to 19+ deployment formats:

1. Navigate to the Export tab
2. Select target format
3. Configure export arguments (image size, half precision, dynamic, etc.)
4. For GPU-required formats (TensorRT), select a GPU type
5. Click Export
6. Download when complete

Supported Formats

The Platform supports export to 19+ deployment formats: ONNX, TorchScript, OpenVINO, TensorRT, CoreML, TF SavedModel, TF GraphDef, LiteRT, TF Edge TPU, PaddlePaddle, NCNN, MNN, RKNN, Qualcomm (QNN), IMX500, Axelera, ExecuTorch, and DeepX.

Format Selection Guide

NVIDIA Jetson TensorRT Targets

Ultralytics Platform offers the following Jetson target selections for TensorRT .engine exports. As of July 2026, the Jetson export workers use JetPack 7.2 / L4T r39.2, Python 3.12.3, NVIDIA PyTorch 2.12.0a0 (26.04 build), CUDA 13.2, and TensorRT 10.16.1.11 inside the export container.

The timings are single observed end-to-end production routing tests from July 2026, rounded to the nearest second; they are reference measurements, not an SLA or per-SKU performance benchmark. Both Thor selections are built on a T5000 Developer Kit in NVIDIA's T4000 compatibility profile. The six Orin routes are built on an AGX Orin 64GB, where every resulting engine was loaded and run. Because TensorRT engines are tied to the build GPU and software stack, the smaller-Orin artifacts are candidates until they load and infer on their listed SKUs. Test memory fit on smaller Orin SKUs and perform INT8 calibration on the target device for best results. See the NVIDIA Jetson guide and TensorRT integration guide for local deployment details.

RKNN Chip Support

When exporting to RKNN format, select your target Rockchip device:

Export Job Lifecycle

Export jobs progress through the following statuses:

!!! tip "Export Time"

Export time varies by format and build host. TensorRT exports may take several minutes because TensorRT profiles and tunes the engine on the physical GPU shown in the [Jetson validation table](#nvidia-jetson-tensorrt-targets) or the selected cloud GPU.

Bulk Export Actions

• Export All: Click Export All to start export jobs for all CPU-based formats with default settings.
• Delete All Exports: Click Delete All to remove all exports for the model.

Format Restrictions

Some export formats have architecture or task restrictions:

!!! note "Additional Export Rules"

- Classification exports do not include NMS.
- CoreML exports with batch sizes greater than `1` use `dynamic=true`.
- Unsupported format/model combinations are disabled in the export dialog before you launch.

Clone Model

Clone a model to a different project:

1. Open the model page
2. Click the Clone button
3. Select the destination project
4. Click Clone

The model and its weights are copied to the target project.

Download Model

Download your model weights:

1. Navigate to the model's Overview tab
2. Click the Download button
3. The original .pt file downloads automatically

Exported formats can be downloaded from the Export tab after export completes.

Dataset Linking

Models can be linked to their source dataset:

• View which dataset was used for training
• Click the dataset card on the Overview tab to navigate to it
• Track data lineage

When training with Platform datasets using the ul:// URI format, linking is automatic.

!!! example "Dataset URI Format"

```bash
# Train with a Platform dataset — linking is automatic
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100
```

The `ul://` scheme resolves to your Platform dataset. The trained model's Overview tab will show a link back to this dataset (see [Using Platform Datasets](../api/index.md#using-platform-datasets)).

Visibility Settings

Control who can see your model:

To change visibility, click the visibility badge (e.g., private or public) in the page header. Visibility is set at the project level, so this controls all models in the project. Switching to private takes effect immediately. Switching to public shows a confirmation dialog before applying.

Delete Model

Remove a model you no longer need:

1. Open model actions menu
2. Click Delete
3. Confirm deletion

!!! note "Trash and Restore"

Deleted models go to Trash for 30 days. Restore from [Settings > Trash](../account/trash.md).

See Also

• Inference: Test models in the browser with the Predict tab
• Endpoints: Deploy models to production with dedicated endpoints
• Cloud Training: Configure and run training jobs on cloud GPUs
• Export Formats: Full guide to all 19+ export formats

FAQ

What model architectures are supported?

Ultralytics Platform fully supports all YOLO architectures with dedicated projects:

• YOLO26: n, s, m, l, x variants (latest, recommended) — platform.ultralytics.com/ultralytics/yolo26
• YOLO11: n, s, m, l, x variants — platform.ultralytics.com/ultralytics/yolo11
• YOLOv8: n, s, m, l, x variants — platform.ultralytics.com/ultralytics/yolov8
• YOLOv5: n, s, m, l, x variants — platform.ultralytics.com/ultralytics/yolov5

YOLO26 supports 6 task types: detect, segment, semantic, pose, OBB, and classify. YOLO11 and YOLOv8 support the same set except semantic segmentation, while YOLOv5 supports detect, segment, and classify.

Can I download my trained model?

Yes, download your model weights from the model page:

1. Click the download icon on the Overview tab
2. The original .pt file downloads automatically
3. Exported formats can be downloaded from the Export tab

How do I compare models across projects?

Currently, model comparison is within projects. To compare across projects:

1. Clone models to a single project, or
2. Export metrics and compare externally

What's the maximum model size?

Uploaded .pt model files are limited to 1 GB, and models near that limit may take longer to upload and process.

Can I fine-tune pretrained models?

Yes! You can use any of the official YOLO26 models as a base, or select one of your own completed models from the model selector in the training dialog. The Platform supports fine-tuning from any uploaded checkpoint.