{"id":48151,"plugin_id":"plugins_6ac51f0691748191b2d31e8c84d99c62","kind":"skill","collection_source":"plugin_package","comparison_source":null,"observed_at":"2026-10-24T13:35:34.269Z","digest":"12c83ba79e70c51f2ae557de87706e55848b5121e7c2e42255caaece68498bff","against":null,"payload":{"description":"Use for ANY task involving Ultralytics Platform, the ultralytics Python package, yolo CLI, YOLO model weights (.pt), dataset annotation, training, validation, prediction, tracking, export, deployment, or the detect / segment / semantic / depth / classify / pose / OBB vision tasks.\n","included_files":[{"relative_path":"agents/openai.yaml","size_in_bytes":289}],"name":"yolo","skill_md_contents":"---\nname: yolo\ndescription: >\n  Use for ANY task involving Ultralytics Platform, the ultralytics Python package, yolo CLI, YOLO model weights (.pt), dataset annotation, training, validation, prediction, tracking, export, deployment, or the detect / segment / semantic / depth / classify / pose / OBB vision tasks.\n---\n\n# Ultralytics YOLO\n\nRun the same lifecycle on three complementary surfaces:\n\n- **[Ultralytics Platform](https://platform.ultralytics.com)** — the fastest start: upload or clone data, annotate in the browser, train on cloud GPUs, inspect metrics, test predictions, export, and deploy a dedicated endpoint without local setup.\n- **`ultralytics` package / `yolo` CLI** — use local or remote compute, scripts, notebooks, custom pipelines, and exported artifacts directly.\n- **`ul` CLI** (Python 3.11+, installed by `ultralytics` or `ultralytics-platform`) — script the Platform API itself: `ul cloud <resource> <operation> key=value` lists, creates, clones, trains, exports, and deploys Platform resources from a terminal (see `platform-cli`).\n\n`ul cloud train|predict|export` upload local inputs as needed and run on Platform. Training returns after submission; add `watch` to follow and download results. `ul cloud download` uses the printed model URI and waits if needed; Ctrl-C stops waiting without canceling training. All four shortcuts need `ultralytics` installed; the `ul cloud <resource> <operation>` commands do not.\n\n```bash\nul cloud train model=yolo26n.pt data=ul://username/datasets/helmets epochs=100 project=helmets name=exp1 # → run URI and download command\nul cloud download model=ul://username/helmets/exp1                                                       # → weights/best.pt and results\nul cloud predict model=ul://username/helmets/exp1 source=video.mp4                                       # → annotated output\nul cloud export model=ul://username/helmets/exp1 format=onnx                                             # → downloaded artifact\n```\n\nMix them freely. Set `ULTRALYTICS_API_KEY`, use a Platform dataset as `data=ul://username/datasets/dataset-slug`, and set `project=username/project-slug name=experiment` during local training to stream its metrics back to Platform.\n\nThe `yolo` CLI and Python share one API. The CLI grammar is `yolo TASK MODE arg=value ...`, and Python takes the same argument names:\n\n```bash\nyolo detect train data=data.yaml model=yolo26n.pt epochs=100 imgsz=640\n```\n\n```python\nfrom ultralytics import YOLO\n\nmodel = YOLO(\"yolo26n.pt\")\nmodel.train(data=\"data.yaml\", epochs=100, imgsz=640)\n```\n\n- TASK ∈ `detect` `segment` `semantic` `depth` `classify` `pose` `obb` — usually inferred from the weights, so it can be omitted.\n- MODE ∈ `train` `val` `predict` `track` `export` `benchmark`.\n- Install/upgrade: `pip install -U ultralytics`. Environment check: `yolo checks`.\n\n## Whole lifecycle in five commands\n\n```bash\nyolo detect train data=data.yaml model=yolo26n.pt epochs=100 # → runs/detect/train/weights/best.pt\nyolo val model=best.pt data=data.yaml                        # mAP, per-class metrics\nyolo predict model=best.pt source=video.mp4 save=True        # any source: image/dir/URL/RTSP/webcam\nyolo track model=best.pt source=video.mp4                    # + persistent object IDs\nyolo export model=best.pt format=onnx                        # exported model loads back into YOLO()\n```\n\n## Whole lifecycle in Platform\n\n1. Open [Platform](https://platform.ultralytics.com) and choose the data region during onboarding.\n2. Clone a public dataset from **Explore**, or create one under **Annotate** and upload images, videos, an archive, or NDJSON.\n3. Label in the fullscreen editor; use SAM or a compatible YOLO model in **Smart** mode where available.\n4. Create a project, click **New Model**, select the dataset, pretrained model, GPU, and epochs, then monitor the run.\n5. Use the completed model's **Predict**, **Export**, or **Deploy** tab.\n\nStart with the [Platform quickstart](https://docs.ultralytics.com/platform/quickstart). Use the stage skill below for both Platform and package details.\n\n## Route before coding\n\nRead the skill for the stage you're working on BEFORE writing code — each contains exact formats, argument tables with defaults, recipes, and symptom→fix tables. A request spanning stages (\"train and deploy\") → read each relevant skill.\n\n| Working on                                                                                                                                                          | Skill            |\n| ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- |\n| choosing a model family/size/task, YOLO26 vs YOLO11, YOLO-World/YOLOE, SAM, RT-DETR                                                                                 | `yolo-models`    |\n| data.yaml, labels, annotation conversion, auto-labeling, dataset analysis/errors, splits                                                                            | `yolo-datasets`  |\n| training, fine-tuning, hyperparameters, augmentation, OOM / NaN / low mAP, reading runs                                                                             | `yolo-training`  |\n| hyperparameter tuning, Ray Tune, systematic model improvement, \"autotraining\"                                                                                       | `yolo-tuning`    |\n| predict on images/video/streams, Results API, tracking IDs, counting/heatmaps/Solutions                                                                             | `yolo-inference` |\n| ONNX / TensorRT / CoreML / Core AI / OpenVINO / LiteRT / NCNN / NPUs, quantization, benchmarking                                                                    | `yolo-export`    |\n| Platform API from a terminal: `ul cloud <resource> <operation>` commands, `ultralytics-platform`, scripted changes to resources, trash, deployments, and cloud runs | `platform-cli`   |\n\n## CLI specifics\n\nSpecial commands (no TASK/MODE):\n\n```bash\nyolo help   # full syntax reference\nyolo checks # env report: version, torch, CUDA, disk — run when anything is weird\nyolo version\nyolo settings # view; `yolo settings key=value` to set; `yolo settings reset`\n# keys incl. datasets_dir, runs_dir, wandb, mlflow, tensorboard, ...\nyolo cfg            # print every default argument (the ground truth for arg names)\nyolo copy-cfg       # copy default.yaml → default_copy.yaml to customize, use with cfg=\nyolo solutions help # prebuilt apps: count, heatmap, speed, ... (see yolo-inference)\n```\n\nParsing rules that matter:\n\n- Args are `key=value`, no `--` flags. A leading `--` and trailing commas are stripped with a warning; spaces around `=` are merged.\n- A bare boolean arg sets it True: `yolo predict ... show` ≡ `show=True`.\n- `cfg=custom.yaml` loads the file's values: CLI arguments before or after it win, and missing keys still use built-in defaults (start with `yolo copy-cfg`).\n- Missing args are auto-filled with warnings (sample source, task-default data/model, `format=torchscript`).\n- Model stem selects the architecture: `rtdetr-*` → RT-DETR, `sam_*`/`sam2*`/`sam3*`/`mobile_sam` → SAM, `FastSAM-*` → FastSAM, `yolo_nas_*` → NAS, `yoloe-*`/`*-world*` → promptable YOLO (accepts `classes=\"person, bus\"`), everything else → YOLO.\n\n## Global directives\n\n1. **Validate the dataset before training** — run the task-appropriate checks in `yolo-datasets`, then a 1-epoch smoke test and inspect `runs/<task>/train/train_batch0.jpg`: annotations or targets must match each image.\n2. **Always fine-tune from pretrained `.pt`** — never `pretrained=False`, never a YAML architecture from scratch, unless the user is explicitly doing research.\n3. **`stream=True` for videos/streams** in Python predict/track — the default list mode OOMs on long videos.\n4. **Use `best.pt`** (not `last.pt`) from `runs/<task>/<name>/weights/` after training.\n5. **After export, verify parity**: `yolo val` the exported artifact against the `.pt` baseline.\n6. **Prefer built-ins over custom code**: dataset converters and checkers (`ultralytics.data`), trackers, and Solutions modules replace whole categories of hand-written glue.\n7. **Trust the installed version over memory** — if an argument is rejected, the API has moved: `yolo cfg` and the error text list valid arguments, and `yolo checks` shows the version. Prefer them over any table in these skills.\n"},"changes":[],"summary":"First saved snapshot. No earlier version is available for comparison.","summary_kind":"deterministic","summary_metadata":{}}