{"id":48155,"plugin_id":"plugins_6ac51f0691748191b2d31e8c84d99c62","kind":"skill","collection_source":"plugin_package","comparison_source":null,"observed_at":"2026-10-24T13:35:34.347Z","digest":"2d7f712f6d23f020f60c4313ab4b7ba541e1d5dc999162e81bc0e8143358d4fd","against":null,"payload":{"description":"Use when choosing or comparing Ultralytics models in Platform or code — picking a model family (YOLO26/YOLO11/YOLOv8, YOLO-World, YOLOE, SAM/SAM2/FastSAM, RT-DETR, YOLO-NAS), size (n/s/m/l/x), task variant (-seg, -sem, -cls, -pose, -obb, -depth), pretrained checkpoint, open-vocabulary or promptable detection/segmentation, custom architecture, Platform Explore, or exact weight names and availability.\n","included_files":[{"relative_path":"agents/openai.yaml","size_in_bytes":279},{"relative_path":"weights-catalog.md","size_in_bytes":4421}],"name":"yolo-models","skill_md_contents":"---\nname: yolo-models\ndescription: >\n  Use when choosing or comparing Ultralytics models in Platform or code — picking a model family (YOLO26/YOLO11/YOLOv8, YOLO-World, YOLOE, SAM/SAM2/FastSAM, RT-DETR, YOLO-NAS), size (n/s/m/l/x), task variant (-seg, -sem, -cls, -pose, -obb, -depth), pretrained checkpoint, open-vocabulary or promptable detection/segmentation, custom architecture, Platform Explore, or exact weight names and availability.\n---\n\n# Choosing an Ultralytics model\n\n**Default recommendation: YOLO26, pretrained.** Latest generation, with an optional NMS-free head (`nms=False`) for the fastest CPU inference and simplest deployment. Use YOLO11/YOLOv8 only to match an existing codebase or a deployment target that doesn't support YOLO26 yet. Most official weights auto-download on first use; `sam3.pt` and `sam3.1_multiplex.pt` require manual access and download.\n\n## Choose in Platform\n\nFor the quickest no-code start, click **New Model** in a project. Its **Official** tab lists YOLO26 (recommended), YOLO11, YOLOv8, and YOLOv5 models whose task can train the selected dataset; **My Models** lists your completed or uploaded checkpoints for further fine-tuning. To browse the official models first, open the `@ultralytics` projects under **Projects** in [Platform Explore](https://platform.ultralytics.com/explore).\n\nUse a Platform model page to inspect metrics, test it in **Predict**, export it, deploy it, clone a public model into your workspace, or download its `.pt` weights for the Python/CLI workflows below. See [Platform Models](https://docs.ultralytics.com/platform/train/models) and [Explore](https://docs.ultralytics.com/platform/explore).\n\n## Model = family + size + task suffix\n\n`yolo26` + `n/s/m/l/x` + task suffix → `yolo26s-seg.pt`\n\n| Size | COCO mAP50-95 | Params | T4 TensorRT | Pick for                                   |\n| ---- | ------------- | ------ | ----------- | ------------------------------------------ |\n| n    | 40.9          | 2.4M   | ~1.7 ms     | edge/mobile, CPU realtime, first prototype |\n| s    | 48.6          | 9.5M   | ~2.5 ms     | balanced default for most projects         |\n| m    | 53.1          | 20.4M  | ~4.7 ms     | GPU server, accuracy matters               |\n| l    | 55.0          | 24.8M  | ~6.2 ms     | accuracy-critical, ample GPU               |\n| x    | 57.5          | 55.7M  | ~11.8 ms    | max accuracy, offline/batch                |\n\nStrategy: prototype on `n` to validate the pipeline cheaply, then scale up until accuracy stops paying for the latency. A bigger model never fixes bad labels.\n\n| Suffix   | Task                            | Output               |\n| -------- | ------------------------------- | -------------------- |\n| _(none)_ | detect                          | boxes                |\n| `-seg`   | instance segmentation           | polygons + boxes     |\n| `-sem`   | semantic segmentation (YOLO26+) | per-pixel class mask |\n| `-depth` | monocular depth (YOLO26+)       | depth map            |\n| `-cls`   | classification                  | class probabilities  |\n| `-pose`  | pose/keypoints                  | keypoints + boxes    |\n| `-obb`   | oriented boxes                  | rotated boxes        |\n\nNotes on the newer tasks:\n\n- **semantic** (`-sem`): dataset uses PNG masks via `masks_dir` (default `masks/`) or polygon labels; metric is mIoU.\n- **depth** (`-depth`): targets are scaled uint16 PNG maps (preferred) or floating-point `.npy` maps in meters; metric is delta1. Depth models also expose `model.calibrate(data=...)`, which fits a metric-scale correction; persist it with `model.save(...)`.\n\n## Family cheat sheet\n\n| Family                                | Class                             | When                                                                                                                                                                                                                                                                                    |\n| ------------------------------------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| YOLO26 / YOLO11 / YOLO12 / YOLOv8–v10 | `YOLO(\"yolo26n.pt\")`              | standard closed-set tasks; default choice                                                                                                                                                                                                                                               |\n| YOLO-World                            | `YOLOWorld(\"yolov8s-worldv2.pt\")` | zero-shot detection of arbitrary text classes; `model.set_classes([\"person\", \"helmet\"])`; prefer `-worldv2` (original `-world` weights cannot export)                                                                                                                                   |\n| YOLOE                                 | `YOLOE(\"yoloe-26s-seg.pt\")`       | open-vocabulary detect+segment via text or visual prompts; `set_classes([\"person\", \"helmet\"])`, visual prompts via `predict(..., visual_prompts={\"bboxes\": ..., \"cls\": ...}, predictor=YOLOEVPSegPredictor)` (the default predictor returns boxes only); `-pf` variants are prompt-free |\n| SAM / SAM2 / SAM3 / MobileSAM         | `SAM(\"sam_b.pt\")`                 | promptable segmentation: `predict(source, bboxes=... / points=... / labels=...)`; SAM2/SAM3 add video predictors; SAM3 adds text/exemplar concept segmentation (`SAM3SemanticPredictor`); inference only                                                                                |\n| FastSAM                               | `FastSAM(\"FastSAM-s.pt\")`         | CNN-based segment-anything, much faster than SAM; no training                                                                                                                                                                                                                           |\n| RT-DETR                               | `RTDETR(\"rtdetr-l.pt\")`           | transformer detector, strong accuracy on GPU                                                                                                                                                                                                                                            |\n| YOLO-NAS                              | `NAS(\"yolo_nas_s.pt\")`            | no training (val/predict/export only)                                                                                                                                                                                                                                                   |\n\nAll classes share the same `Model` API (`train/val/predict/track/export/...`) — everything in the other yolo-\\* skills applies to them, with the exceptions noted above.\n\nOpen-vocabulary decision: need arbitrary classes at inference with no training → YOLO-World (detect) or YOLOE (detect+segment, also visual prompts). Need pixel-precise masks from clicks/boxes → SAM family. Need a trained model for a fixed class list → plain YOLO26 fine-tune (faster and more accurate on that closed set).\n\n## Architecture YAMLs (custom models)\n\n`ultralytics/cfg/models/` ships editable architecture definitions (`yolo26.yaml`, `yolo11.yaml`, `yolov8.yaml`, and variants such as `-p2` (small objects), `-p6` (large imgsz), and `-ghost`). Loading `YOLO(\"yolo26n.yaml\")` builds from scratch — scale is picked from the letter in the stem. To customize the architecture but keep pretrained weights where layers match:\n\n```python\nmodel = YOLO(\"yolo26n.yaml\").load(\"yolo26n.pt\")  # transfer matching weights\n```\n\nOnly go here for research/unusual constraints; for normal work fine-tune the stock `.pt`.\n\n## Related pages\n\n- `weights-catalog.md` (this folder) — read for package-known weight patterns and specialized official assets. Do not guess weight names.\n\n## Verify against the installed version\n\nModel availability moves fast. This prints the installed package's known fast-path set; read `weights-catalog.md` before treating an unlisted official asset as invalid:\n\n```bash\npython -c \"from ultralytics.utils.downloads import GITHUB_ASSETS_NAMES; print(*sorted(GITHUB_ASSETS_NAMES), sep='\\\\n')\"\n```\n\nIf a weight 404s or a class import fails, check `yolo checks` and trust the installed-version error.\n"},"changes":[],"summary":"First saved snapshot. No earlier version is available for comparison.","summary_kind":"deterministic","summary_metadata":{}}