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:
- Navigate to your project
- Drag and drop
.ptfiles onto the project page or models sidebar, or click the Upload models icon - Model metadata is parsed automatically from the file
Multiple files can be uploaded simultaneously (up to 3 concurrent).
Supported model formats:
| Format | Extension | Description |
|---|---|---|
| PyTorch | .pt | Native Ultralytics format |
After upload, the platform parses model metadata:
- Task type (detect, segment, semantic, depth, classify, pose, OBB)
- 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:
- Navigate to your project
- Click New Model
- Select base model and dataset
- Configure training parameters
- Choose cloud or local training
- 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[20 Formats]:::out
F --> H[Endpoint]:::out
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef out fill:#9C27B0,color:#fffModel Page Tabs#
Each model page has the following tabs:
| Tab | Content |
|---|---|
| Overview | Model metadata, key metrics, dataset link |
| Train | Training charts, console output, system stats |
| Predict | Interactive browser inference |
| Export | Format conversion with GPU selection |
| Deploy | Endpoint creation and management |
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:
| Chart Group | Metrics |
|---|---|
| Metrics | mAP50, mAP50-95, precision, recall |
| Training Loss | train/box_loss, train/cls_loss, train/dfl_loss |
| Validation Loss | val/box_loss, val/cls_loss, val/dfl_loss |
| Learning Rate | lr/pg0, lr/pg1, lr/pg2 |

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:
| Metric | Description |
|---|---|
| GPU Util | GPU utilization percentage |
| GPU Memory | GPU memory usage |
| GPU Temp | GPU temperature |
| CPU Usage | CPU utilization |
| RAM | System memory usage |
| Disk | Disk usage |

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, depth, classify, pose, OBB)
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 20 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#
When the training run provides them, the Validation subtab also displays performance curves at different confidence thresholds. Available validation plots depend on the artifacts produced by the run.

| Curve | Description |
|---|---|
| Precision-Recall | Trade-off between precision and recall |
| F1-Confidence | F1 score at different confidence levels |
| Precision-Confidence | Precision at different confidence levels |
| Recall-Confidence | Recall at different confidence levels |
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:#fffExport your model to 20 deployment formats:
- Navigate to the Export tab
- Select target format
- Configure export arguments (image size, half precision, dynamic, etc.)
- For GPU-required formats (TensorRT), select a GPU type
- Click Start Export
- Download when complete
Connect Slack alerts to receive a message when an export is ready or fails.

Supported Formats#
The Platform supports export to 20 deployment formats: ONNX, TorchScript, OpenVINO, TensorRT, CoreML, TF SavedModel, TF GraphDef, LiteRT, TF Edge TPU, PaddlePaddle, NCNN, MNN, RKNN, Qualcomm (QNN), IMX500, Axelera, ExecuTorch, DeepX, Hailo, and Huawei Ascend.
Format Selection Guide#
| Target | Recommended Format | Notes |
|---|---|---|
| NVIDIA GPUs | TensorRT | Select the same GPU family as the deployment device |
| NVIDIA Jetson | TensorRT | Select the intended target and check its validation status |
| Intel Hardware | OpenVINO | CPUs, GPUs, and VPUs |
| Apple Devices | CoreML or LiteRT | iOS, macOS, Apple Silicon |
| Android | LiteRT or NCNN | LiteRT (Google's on-device runtime) or NCNN for ARM |
| Web Browsers | LiteRT.js or ONNX | LiteRT.js or ONNX via ONNX Runtime Web |
| Edge Devices | TF Edge TPU or RKNN | Coral and Rockchip (see supported chips) |
| General | ONNX | Works with most runtimes |

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.
| Target selection | API gpuType | Memory | GPU architecture | Python | CUDA | TensorRT | Measured YOLO26n FP16 export | Physical build/load validation |
|---|---|---|---|---|---|---|---|---|
| Jetson Thor T5000 | jetson-thor-t5000 | 128 GB | Blackwell, CC 11.0 | 3.12.3 | 13.2 | 10.16.1.11 | ~1m 46s | Thor in NVIDIA T4000 profile; T5000 candidate |
| Jetson Thor T4000 | jetson-thor-t4000 | 64 GB | Blackwell, CC 11.0 | 3.12.3 | 13.2 | 10.16.1.11 | ~1m 46s | Thor in NVIDIA T4000 profile |
| Jetson AGX Orin 64GB | jetson-agx-orin-64gb | 64 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 7m 15s | Built, loaded, and inferred on AGX Orin 64GB |
| Jetson AGX Orin 32GB | jetson-agx-orin-32gb | 32 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 5m 34s | AGX Orin 64GB build/load; 32GB SKU pending |
| Jetson Orin NX 16GB | jetson-orin-nx-16gb | 16 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 5m 09s | AGX Orin 64GB build/load; NX SKU pending |
| Jetson Orin NX 8GB | jetson-orin-nx-8gb | 8 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 5m 01s | AGX Orin 64GB build/load; NX SKU pending |
| Jetson Orin Nano 8GB Super | jetson-orin-nano-8gb | 8 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 4m 59s | AGX Orin 64GB build/load; Nano SKU pending |
| Jetson Orin Nano 4GB | jetson-orin-nano-4gb | 4 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 5m 01s | AGX Orin 64GB build/load; Nano SKU pending |
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.
Downloaded engines are tied to their build platform, GPU family, TensorRT version, and a compatible CUDA runtime. For Jetson targets, the software versions are shown in the table above. Validate each engine and its memory fit on the deployment device, and perform INT8 calibration there for best results. If the environments do not match, export the engine locally instead. 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:
| Chip | Description |
|---|---|
| RK3588 | High-end edge SoC |
| RK3576 | Mid-range edge SoC |
| RK3568 | Mid-range edge SoC |
| RK3566 | Mid-range edge SoC |
| RK3562 | Entry-level edge SoC |
| RV1103 | Vision processor |
| RV1106 | Vision processor |
| RV1103B | Vision processor |
| RV1106B | Vision processor |
| RK2118 | AI processor |
| RV1126B | Vision processor |
Export Job Lifecycle#
Export jobs progress through the following statuses:
| Status | Description |
|---|---|
| Queued | Export job is waiting to start |
| Starting | Export job is initializing |
| Running | Export is in progress |
| Completed | Export finished — download available |
| Failed | Export failed (see error message) |
| Cancelled | Export was cancelled by the user |
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 or the selected cloud GPU.
Bulk Export Actions#
- Export All: Click
Export Allto start export jobs for all CPU-based formats with default settings. - Delete All Exports: Click
Delete Allto remove all exports for the model.
Format Restrictions#
Some export formats have architecture or task restrictions:
| Format | Restriction |
|---|---|
| IMX500 | Available only for YOLOv8n and YOLO11n; INT8 only |
| Axelera | Detect models only; INT8 only |
| DeepX | INT8 only |
| Hailo | INT8 HEF output; select the target Hailo architecture |
| Huawei | FP16 .om output; Ascend310P1, Ascend310P3, Ascend310B1, and Ascend310B4 targets |
| Qualcomm | Fixed W8A16 quantization; select a supported HTP target. Dragonwing IQ-8275 is supported with name=iq-8275; IQ-615 is unsupported |
- Classification exports do not include NMS.
- CoreML exports with batch sizes greater than
1usedynamic=true. - Unsupported format/model combinations are disabled in the export dialog before you launch.
Clone Model#
Clone a model to a different project:
- Open the model page
- Click Clone Model
- Select the destination project
- Click Clone Model
The model and its weights are copied to the target project.
Download Model#
Download your model weights:
- Navigate to the model's Overview tab
- Click the Download button
- The model's primary
.ptcheckpoint 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.
# Train with a Platform dataset — linking is automatic
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100The 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).
Custom Metadata#
Open More actions and select Information to review two sections:
- Ultralytics Metadata: Read-only Platform details such as the model ID, project, source dataset, task, status, and timestamps
- Custom Metadata: Your own JSON object for evaluation context, release tracking, governance, or other model-specific data
Custom metadata is separate from training-owned model information, environment details, and training arguments. Workspace viewers can inspect it, while members with edit access can replace the object. The serialized metadata object is limited to 500,000 characters, and each top-level key is limited to 128 characters. Save an empty object ({}) to clear custom metadata.
Visibility Settings#
Control who can see your model:
| Setting | Description |
|---|---|
| Private | Only you and workspace members can access |
| Public | Anyone can view on Explore page |
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:
- Click the Delete model trash icon in the model header
- Confirm deletion
Deleted models go to Trash for 30 days. Restore from Settings > Trash.
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 20 export formats
FAQ#
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 7 task types: detect, segment, semantic, depth, classify, pose, and OBB. YOLO11 and YOLOv8 support the same set except semantic segmentation and depth, while YOLOv5 supports detect, segment, and classify.
Yes, download your model weights from the model page:
- Click the download icon on the Overview tab
- The model's primary
.ptcheckpoint downloads automatically - Exported formats can be downloaded from the Export tab
Currently, model comparison is within projects. To compare across projects:
- Clone models to a single project, or
- Export metrics and compare externally
Uploaded
.ptmodel files are limited to 1 GB, and models near that limit may take longer to upload and process.Yes. Choose a compatible model from the official YOLO26, YOLO11, YOLOv8, or YOLOv5 projects, or select one of your own completed or uploaded checkpoints from My Models in the training dialog.