ultralytics 8.4.41 Fix SAM3 FP ghost IDs in video tracking (#24249)

Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com>
Co-authored-by: Ultralytics Assistant <135830346+UltralyticsAssistant@users.noreply.github.com>
Co-authored-by: Jing Qiu <61612323+Laughing-q@users.noreply.github.com>
Co-authored-by: Glenn Jocher <glenn.jocher@ultralytics.com>

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
       fail-fast: false
       matrix:
         # Temporarily disable windows-latest due to https://github.com/ultralytics/ultralytics/actions/runs/13020330819/job/36319338854?pr=18921
-        os: [ubuntu-latest, macos-26, ubuntu-24.04-arm]
+        os: [cpu-latest, macos-26, ubuntu-24.04-arm]
         python: ["3.12"]
         model: [yolo26n]
     steps:
@@ -74,22 +74,22 @@ jobs:
           uv pip list
       - name: Benchmark DetectionModel
         shell: bash
-        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}.pt' imgsz=160 verbose=0.218
+        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}.pt' imgsz=160 verbose=0.216
       - name: Benchmark ClassificationModel
         shell: bash
         run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-cls.pt' imgsz=160 verbose=0.249
       - name: Benchmark YOLOWorld DetectionModel
         shell: bash
-        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/yolov8s-worldv2.pt' imgsz=160 verbose=0.337
+        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/yolov8s-worldv2.pt' imgsz=160 verbose=0.335
       - name: Benchmark SegmentationModel
         shell: bash
-        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-seg.pt' imgsz=160 verbose=0.230
+        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-seg.pt' imgsz=160 verbose=0.229
       - name: Benchmark PoseModel
         shell: bash
-        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-pose.pt' imgsz=160 verbose=0.194
+        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-pose.pt' imgsz=160 verbose=0.185
       - name: Benchmark OBBModel
         shell: bash
-        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-obb.pt' imgsz=160 verbose=0.372
+        run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-obb.pt' imgsz=160 verbose=0.371
       - name: Merge Coverage Reports
         run: |
           coverage xml -o coverage-benchmarks.xml
@@ -345,17 +345,17 @@ jobs:
           yolo checks
           uv pip list
       - name: Benchmark DetectionModel
-        run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n.pt' imgsz=160 verbose=0.218
+        run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n.pt' imgsz=160 verbose=0.216
       - name: Benchmark ClassificationModel
         run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-cls.pt' imgsz=160 verbose=0.249
       - name: Benchmark YOLOWorld DetectionModel
-        run: python -m ultralytics.cfg.__init__ benchmark model='yolov8s-worldv2.pt' imgsz=160 verbose=0.337
+        run: python -m ultralytics.cfg.__init__ benchmark model='yolov8s-worldv2.pt' imgsz=160 verbose=0.335
       - name: Benchmark SegmentationModel
-        run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-seg.pt' imgsz=160 verbose=0.230
+        run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-seg.pt' imgsz=160 verbose=0.229
       - name: Benchmark PoseModel
-        run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-pose.pt' imgsz=160 verbose=0.194
+        run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-pose.pt' imgsz=160 verbose=0.185
       - name: Benchmark OBBModel
-        run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-obb.pt' imgsz=160 verbose=0.372
+        run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-obb.pt' imgsz=160 verbose=0.371
       - name: Benchmark Summary
         run: |
           cat benchmarks.log
@@ -435,7 +435,7 @@ jobs:
           channel-priority: true
           activate-environment: anaconda-client-env
       - name: Install Ultralytics package from conda-forge
-        run: conda install -c pytorch -c conda-forge pytorch-cpu torchvision ultralytics "openvino!=2026.0.0"
+        run: conda install -c pytorch -c conda-forge pytorch-cpu torchvision ultralytics "openvino<2026"
       - name: Install pip packages
         run: uv pip install pytest
       - name: Check environment

.github/workflows/docker.yml

@@ -118,24 +118,42 @@ jobs:
         uses: docker/setup-buildx-action@v4
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v4
+        uses: ultralytics/actions/retry@main
+        env:
+          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}
         with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          run: |
+            if ! out=$(printf '%s' "$DOCKERHUB_TOKEN" | docker login -u "$DOCKERHUB_USERNAME" --password-stdin 2>&1); then
+              printf '%s\n' "$out" >&2
+              exit 1
+            fi
+            echo "Logged in to docker.io"
 
       - name: Login to GHCR
-        uses: docker/login-action@v4
+        uses: ultralytics/actions/retry@main
+        env:
+          GHCR_USERNAME: ${{ github.repository_owner }}
+          GHCR_TOKEN: ${{ secrets._GITHUB_TOKEN }}
         with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets._GITHUB_TOKEN }}
+          run: |
+            if ! out=$(printf '%s' "$GHCR_TOKEN" | docker login ghcr.io -u "$GHCR_USERNAME" --password-stdin 2>&1); then
+              printf '%s\n' "$out" >&2
+              exit 1
+            fi
+            echo "Logged in to ghcr.io"
 
       - name: Login to NVIDIA NGC
-        uses: docker/login-action@v4
+        uses: ultralytics/actions/retry@main
+        env:
+          NVIDIA_NGC_API_KEY: ${{ secrets.NVIDIA_NGC_API_KEY }}
         with:
-          registry: nvcr.io
-          username: $oauthtoken
-          password: ${{ secrets.NVIDIA_NGC_API_KEY }}
+          run: |
+            if ! out=$(printf '%s' "$NVIDIA_NGC_API_KEY" | docker login nvcr.io -u '$oauthtoken' --password-stdin 2>&1); then
+              printf '%s\n' "$out" >&2
+              exit 1
+            fi
+            echo "Logged in to nvcr.io"
 
       - name: Retrieve Ultralytics version
         id: get_version
@@ -227,7 +245,7 @@ jobs:
 
       - name: Run Benchmarks
         if: (github.event_name == 'push' || github.event.inputs[matrix.dockerfile] == 'true') && (matrix.platforms == 'linux/amd64' || matrix.dockerfile == 'Dockerfile-arm64') && matrix.dockerfile != 'Dockerfile' && matrix.dockerfile != 'Dockerfile-conda'
-        run: docker run ultralytics/ultralytics:${{ (matrix.tags == 'latest-python' && 'latest-python-export') || (matrix.tags == 'latest' && 'latest-export') || matrix.tags }} yolo benchmark model=yolo26n.pt imgsz=160 verbose=0.218
+        run: docker run ultralytics/ultralytics:${{ (matrix.tags == 'latest-python' && 'latest-python-export') || (matrix.tags == 'latest' && 'latest-export') || matrix.tags }} yolo benchmark model=yolo26n.pt imgsz=160 verbose=0.216
 
       - name: Push All Images
         if: github.event_name == 'push' || (github.event.inputs[matrix.dockerfile] == 'true' && github.event.inputs.push == 'true')

.github/workflows/links.yml

@@ -35,6 +35,7 @@ jobs:
           timeout_minutes: 60
           retry_delay_seconds: 1800
           retries: 2
+          backoff: fixed
           run: |
             lychee \
             --scheme https \
@@ -70,6 +71,7 @@ jobs:
           timeout_minutes: 60
           retry_delay_seconds: 1800
           retries: 2
+          backoff: fixed
           run: |
             lychee \
             --scheme https \

CONTRIBUTING.md

@@ -29,9 +29,9 @@ First-time contributors are expected to submit small, well-scoped pull requests.
 
 #### Established Contributors
 
-Pull requests from established contributors generally receive higher review priority. Actions and results are fundamental to the [Ultralytics Mission & Values](https://handbook.ultralytics.com/mission-vision-values/). There is no specific threshold to becoming an 'established contributor' as it's impossible to fit all individuals to the same standard. The Ultralytics Team notices those who make consistent, high-quality contributions that follow the Ultralytics standards.
+Pull requests from established contributors generally receive higher review priority. Actions and results are fundamental to the [Ultralytics Mission & Values](https://handbook.ultralytics.com/mission-vision-values). There is no specific threshold to becoming an 'established contributor' as it's impossible to fit all individuals to the same standard. The Ultralytics Team notices those who make consistent, high-quality contributions that follow the Ultralytics standards.
 
-Following our [contributing guidelines](./CONTRIBUTING.md) and [our Development Workflow](https://handbook.ultralytics.com/workflows/development/) is the best way to improve your chances for your work to be reviewed, accepted, and/or recognized; this is not a guarantee. In addition, contributors with a strong track record of meaningful contributions to notable open-source projects may be treated as established contributors, even if they are technically first-time contributors to Ultralytics.
+Following our [contributing guidelines](./CONTRIBUTING.md) and [our Development Workflow](https://handbook.ultralytics.com/workflows/development) is the best way to improve your chances for your work to be reviewed, accepted, and/or recognized; this is not a guarantee. In addition, contributors with a strong track record of meaningful contributions to notable open-source projects may be treated as established contributors, even if they are technically first-time contributors to Ultralytics.
 
 #### Feature PRs
 
@@ -156,11 +156,11 @@ We highly value bug reports as they help us improve the quality and reliability
 
 Ultralytics uses the [GNU Affero General Public License v3.0 (AGPL-3.0)](https://www.ultralytics.com/legal/agpl-3-0-software-license) for its repositories. This license promotes [openness](https://en.wikipedia.org/wiki/Openness), [transparency](https://www.ultralytics.com/glossary/transparency-in-ai), and [collaborative improvement](https://en.wikipedia.org/wiki/Collaborative_software) in software development. It ensures that all users have the freedom to use, modify, and share the software, fostering a strong community of collaboration and innovation.
 
-We encourage all contributors to familiarize themselves with the terms of the [AGPL-3.0 license](https://opensource.org/license/agpl-v3) to contribute effectively and ethically to the Ultralytics open-source community.
+We encourage all contributors to familiarize themselves with the terms of the [AGPL-3.0 license](https://opensource.org/license/agpl-3.0) to contribute effectively and ethically to the Ultralytics open-source community.
 
 ## 🌍 Open-Sourcing Your YOLO Project Under AGPL-3.0
 
-Using Ultralytics YOLO models or code in your project? The [AGPL-3.0 license](https://opensource.org/license/agpl-v3) requires that your entire derivative work also be open-sourced under AGPL-3.0. This ensures modifications and larger projects built upon open-source foundations remain open.
+Using Ultralytics YOLO models or code in your project? The [AGPL-3.0 license](https://opensource.org/license/agpl-3.0) requires that your entire derivative work also be open-sourced under AGPL-3.0. This ensures modifications and larger projects built upon open-source foundations remain open.
 
 ### Why AGPL-3.0 Compliance Matters
 
@@ -179,7 +179,7 @@ Complying means making the **complete corresponding source code** of your projec
    - **Use Ultralytics Template:** Start with the [Ultralytics template repository](https://github.com/ultralytics/template) for a clean, modular setup integrating YOLO.
 
 2. **License Your Project:**
-   - Add a `LICENSE` file containing the full text of the [AGPL-3.0 license](https://opensource.org/license/agpl-v3).
+   - Add a `LICENSE` file containing the full text of the [AGPL-3.0 license](https://opensource.org/license/agpl-3.0).
    - Add a notice at the top of each source file indicating the license.
 
 3. **Publish Your Source Code:**

README.md

@@ -252,7 +252,7 @@ We look forward to your contributions to help make the Ultralytics ecosystem eve
 
 Ultralytics offers two licensing options to suit different needs:
 
-- **AGPL-3.0 License**: This [OSI-approved](https://opensource.org/license/agpl-v3) open-source license is perfect for students, researchers, and enthusiasts. It encourages open collaboration and knowledge sharing. See the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file for full details.
+- **AGPL-3.0 License**: This [OSI-approved](https://opensource.org/license/agpl-3.0) open-source license is perfect for students, researchers, and enthusiasts. It encourages open collaboration and knowledge sharing. See the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file for full details.
 - **Ultralytics Enterprise License**: Designed for commercial use, this license allows for the seamless integration of Ultralytics software and AI models into commercial products and services, bypassing the open-source requirements of AGPL-3.0. If your use case involves commercial deployment, please contact us via [Ultralytics Licensing](https://www.ultralytics.com/license).
 
 ## 📞 Contact

README.zh-CN.md

@@ -252,7 +252,7 @@ Ultralytics 支持广泛的 YOLO 模型，从早期的版本如 [YOLOv3](https:/
 
 Ultralytics 提供两种许可选项以满足不同需求：
 
-- **AGPL-3.0 许可证**：这种经 [OSI 批准](https://opensource.org/license/agpl-v3)的开源许可证非常适合学生、研究人员和爱好者。它鼓励开放协作和知识共享。有关完整详细信息，请参阅 [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) 文件。
+- **AGPL-3.0 许可证**：这种经 [OSI 批准](https://opensource.org/license/agpl-3.0)的开源许可证非常适合学生、研究人员和爱好者。它鼓励开放协作和知识共享。有关完整详细信息，请参阅 [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) 文件。
 - **Ultralytics 企业许可证**：专为商业用途设计，此许可证允许将 Ultralytics 软件和 AI 模型无缝集成到商业产品和服务中，绕过 AGPL-3.0 的开源要求。如果您的使用场景涉及商业部署，请通过 [Ultralytics 授权许可](https://www.ultralytics.com/license)与我们联系。
 
 ## 📞 联系方式

docker/Dockerfile-jetson-jetpack5

@@ -41,8 +41,8 @@ RUN sed -i 's/^\( *"tensorflowjs\)>=.*\(".*\)/\1>=3.9.0\2/' pyproject.toml && \
 # Pip install onnxruntime-gpu, torch, torchvision and ultralytics, then remove build files
 RUN uv pip install --system \
     https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.18.0-cp38-cp38-linux_aarch64.whl \
-    https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.2.0-cp38-cp38-linux_aarch64.whl \
-    https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.17.2+c1d70fe-cp38-cp38-linux_aarch64.whl && \
+    https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl \
+    https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.16.2+c6f3977-cp38-cp38-linux_aarch64.whl && \
     # Need lower version of 'numpy' for TensorRT export
     uv pip install --system numpy==1.23.5 && \
     uv pip install --system -e ".[export]" && \

docs/en/datasets/classify/caltech256.md

@@ -10,13 +10,13 @@ The [Caltech-256](https://data.caltech.edu/records/nyy15-4j048) dataset is an ex
 
 <p align="center">
   <br>
-  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/isc06_9qnM0"
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/Y7cfNkqSdMg"
     title="YouTube video player" frameborder="0"
     allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
     allowfullscreen>
   </iframe>
   <br>
-  <strong>Watch:</strong> How to Train <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> Model using Caltech-256 Dataset with Ultralytics Platform
+  <strong>Watch:</strong> How to Train <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> Model using Caltech-256 Dataset with Ultralytics YOLO26
 </p>
 
 !!! note "Automatic Data Splitting"

docs/en/datasets/detect/open-images-v7.md

@@ -146,7 +146,7 @@ Illustrations of the dataset help provide insights into its richness:
 
 - **Open Images V7**: This image exemplifies the depth and detail of annotations available, including bounding boxes, relationships, and segmentation masks.
 
-Researchers can gain invaluable insights into the array of computer vision challenges that the dataset addresses, from basic object detection to intricate relationship identification. The [diversity of annotations](https://docs.ultralytics.com/datasets/explorer/) makes Open Images V7 particularly valuable for developing models that can understand complex visual scenes.
+Researchers can gain invaluable insights into the array of computer vision challenges that the dataset addresses, from basic object detection to intricate relationship identification. The diversity of annotations makes Open Images V7 particularly valuable for developing models that can understand complex visual scenes.
 
 ## Citations and Acknowledgments
 

docs/en/datasets/detect/tt100k.md

@@ -8,7 +8,7 @@ keywords: TT100K, Tsinghua-Tencent 100K, traffic sign detection, YOLO26, dataset
 
 The [Tsinghua-Tencent 100K (TT100K)](https://cg.cs.tsinghua.edu.cn/traffic-sign/) is a large-scale traffic sign benchmark dataset created from 100,000 Tencent Street View panoramas. This dataset is specifically designed for traffic sign detection and classification in real-world conditions, providing researchers and developers with a comprehensive resource for building robust traffic sign recognition systems.
 
-The dataset contains **100,000 images** with over **30,000 traffic sign instances** across **221 different categories**. These images capture large variations in illuminance, weather conditions, viewing angles, and distances, making it ideal for training models that need to perform reliably in diverse real-world scenarios.
+The dataset contains **100,000 images** with over **30,000 traffic sign instances** across **221 annotation categories**. The original paper applies a 100-instance threshold per class for supervised training, yielding a commonly used **45-class** subset; however, the provided Ultralytics dataset configuration retains all **221 annotated categories**, many of which are very sparse. These images capture large variations in illuminance, weather conditions, viewing angles, and distances, making it ideal for training models that need to perform reliably in diverse real-world scenarios.
 
 This dataset is particularly valuable for:
 

docs/en/datasets/explorer/api.md

@@ -8,7 +8,7 @@ keywords: Ultralytics, Explorer API, dataset exploration, SQL queries, similarit
 
 !!! warning "Community Note ⚠️"
 
-    As of **`ultralytics>=8.3.10`**, Ultralytics Explorer support is deprecated. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
+    As of **`ultralytics>=8.3.12`**, Ultralytics Explorer has been removed. To use Explorer, install `pip install ultralytics==8.3.11`. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
 
 ## Introduction
 
@@ -331,13 +331,6 @@ Start creating your own CV dataset exploration reports using the Explorer API. F
 
 Try our [GUI Demo](dashboard.md) based on Explorer API
 
-## Coming Soon
-
-- [ ] Merge specific labels from datasets. Example - Import all `person` labels from COCO and `car` labels from Cityscapes
-- [ ] Remove images that have a higher similarity index than the given threshold
-- [ ] Automatically persist new datasets after merging/removing entries
-- [ ] Advanced Dataset Visualizations
-
 ## FAQ
 
 ### What is the Ultralytics Explorer API used for?

docs/en/datasets/explorer/dashboard.md

@@ -8,7 +8,7 @@ keywords: Ultralytics Explorer GUI, semantic search, vector similarity, SQL quer
 
 !!! warning "Community Note ⚠️"
 
-    As of **`ultralytics>=8.3.10`**, Ultralytics Explorer support is deprecated. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
+    As of **`ultralytics>=8.3.12`**, Ultralytics Explorer has been removed. To use Explorer, install `pip install ultralytics==8.3.11`. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
 
 Explorer GUI is built on the [Ultralytics Explorer API](api.md). It allows you to run semantic/vector similarity search, SQL queries, and natural language queries using the Ask AI feature powered by LLMs.
 

docs/en/datasets/explorer/explorer.md

@@ -45,7 +45,7 @@ Install `ultralytics` and run `yolo explorer` in your terminal to run custom que
 
 !!! warning "Community Note ⚠️"
 
-    As of **`ultralytics>=8.3.10`**, Ultralytics Explorer support is deprecated. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
+    As of **`ultralytics>=8.3.12`**, Ultralytics Explorer has been removed. To use Explorer, install `pip install ultralytics==8.3.11`. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
 
 ## Setup
 

docs/en/datasets/explorer/index.md

@@ -8,7 +8,7 @@ keywords: Ultralytics Explorer, CV datasets, semantic search, SQL queries, vecto
 
 !!! warning "Community Note ⚠️"
 
-    As of **`ultralytics>=8.3.10`**, Ultralytics Explorer support is deprecated. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
+    As of **`ultralytics>=8.3.12`**, Ultralytics Explorer has been removed. To use Explorer, install `pip install ultralytics==8.3.11`. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
 
 <p>
     <img width="1709" alt="Ultralytics Explorer dataset visualization GUI" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/explorer-dashboard-screenshot-1.avif">
@@ -39,7 +39,7 @@ pip install ultralytics[explorer]
 
 !!! tip
 
-    Explorer works on embedding/semantic search & SQL querying and is powered by [LanceDB](https://lancedb.com/) serverless vector database. Unlike traditional in-memory DBs, it is persisted on disk without sacrificing performance, so you can scale locally to large datasets like COCO without running out of memory.
+    Explorer works on embedding/semantic search & SQL querying and is powered by [LanceDB](https://www.lancedb.com/) serverless vector database. Unlike traditional in-memory DBs, it is persisted on disk without sacrificing performance, so you can scale locally to large datasets like COCO without running out of memory.
 
 ## Explorer API
 
@@ -68,7 +68,7 @@ yolo explorer
 
 ### What is Ultralytics Explorer and how can it help with CV datasets?
 
-Ultralytics Explorer is a powerful tool designed for exploring [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) (CV) datasets through semantic search, SQL queries, vector similarity search, and even natural language. This versatile tool provides both a GUI and a Python API, allowing users to seamlessly interact with their datasets. By leveraging technologies like [LanceDB](https://lancedb.com/), Ultralytics Explorer ensures efficient, scalable access to large datasets without excessive memory usage. Whether you're performing detailed dataset analysis or exploring data patterns, Ultralytics Explorer streamlines the entire process.
+Ultralytics Explorer is a powerful tool designed for exploring [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) (CV) datasets through semantic search, SQL queries, vector similarity search, and even natural language. This versatile tool provides both a GUI and a Python API, allowing users to seamlessly interact with their datasets. By leveraging technologies like [LanceDB](https://www.lancedb.com/), Ultralytics Explorer ensures efficient, scalable access to large datasets without excessive memory usage. Whether you're performing detailed dataset analysis or exploring data patterns, Ultralytics Explorer streamlines the entire process.
 
 Learn more about the [Explorer API](api.md).
 
@@ -80,7 +80,7 @@ To manually install the optional dependencies needed for Ultralytics Explorer, y
 pip install ultralytics[explorer]
 ```
 
-These dependencies are essential for the full functionality of semantic search and SQL querying. By including libraries powered by [LanceDB](https://lancedb.com/), the installation ensures that the database operations remain efficient and scalable, even for large datasets like [COCO](../detect/coco.md).
+These dependencies are essential for the full functionality of semantic search and SQL querying. By including libraries powered by [LanceDB](https://www.lancedb.com/), the installation ensures that the database operations remain efficient and scalable, even for large datasets like [COCO](../detect/coco.md).
 
 ### How can I use the GUI version of Ultralytics Explorer?
 

docs/en/datasets/pose/index.md

@@ -195,7 +195,7 @@ To add your dataset:
 
 ### What is the purpose of the dataset YAML file in Ultralytics YOLO?
 
-The dataset YAML file in Ultralytics YOLO defines the dataset and model configuration for training. It specifies paths to training, validation, and test images, keypoint shapes, class names, and other configuration options. This structured format helps streamline [dataset management](https://docs.ultralytics.com/datasets/explorer/) and model training. Here is an example YAML format:
+The dataset YAML file in Ultralytics YOLO defines the dataset and model configuration for training. It specifies paths to training, validation, and test images, keypoint shapes, class names, and other configuration options. This structured format helps streamline dataset management and model training. Here is an example YAML format:
 
 ```yaml
 --8<-- "ultralytics/cfg/datasets/coco8-pose.yaml"

docs/en/guides/custom-trainer.md

@@ -93,6 +93,7 @@ This logs the mean F1 score across all classes and a per-class breakdown after e
     | Attribute | Description |
     |---|---|
     | `f1` | F1 score per class |
+    | `image_metrics` | Per-image metrics dictionary with precision, recall, F1, TP, FP, and FN |
     | `p` | Precision per class |
     | `r` | Recall per class |
     | `ap50` | AP at IoU 0.5 per class |

docs/en/guides/data-collection-and-annotation.md

@@ -106,7 +106,7 @@ Let's say you are ready to annotate now. There are several open-source tools ava
   <img width="100%" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/labelme-instance-segmentation-annotation.avif" alt="LabelMe annotation tool for instance segmentation">
 </p>
 
-These open-source tools are budget-friendly and provide a range of features to meet different annotation needs.
+These open-source tools are budget-friendly and provide a range of features to meet different annotation needs. [Ultralytics Platform](https://platform.ultralytics.com) also provides a built-in [annotation editor](../platform/data/annotation.md) supporting all YOLO task types (detection, segmentation, pose, OBB, and classification) with SAM-powered smart annotation for spatial tasks.
 
 ### Some More Things to Consider Before Annotating Data
 

docs/en/guides/deepstream-nvidia-jetson.md

@@ -36,9 +36,10 @@ Before you start to follow this guide:
 
 - Visit our documentation, [Quick Start Guide: NVIDIA Jetson with Ultralytics YOLO26](nvidia-jetson.md) to set up your NVIDIA Jetson device with Ultralytics YOLO26
 - Install [DeepStream SDK](https://developer.nvidia.com/deepstream-getting-started) according to the JetPack version
-    - For JetPack 4.6.4, install [DeepStream 6.0.1](https://docs.nvidia.com/metropolis/deepstream/6.0.1/dev-guide/text/DS_Quickstart.html)
-    - For JetPack 5.1.3, install [DeepStream 6.3](https://docs.nvidia.com/metropolis/deepstream/6.3/dev-guide/text/DS_Quickstart.html)
-    - For JetPack 6.1, install [DeepStream 7.1](https://docs.nvidia.com/metropolis/deepstream/7.0/dev-guide/text/DS_Overview.html)
+    - For JetPack 4.6.4, install [DeepStream 6.0.1](https://archive.docs.nvidia.com/metropolis/deepstream/6.0.1/dev-guide/text/DS_Quickstart.html)
+    - For JetPack 5.1.3, install [DeepStream 6.3](https://archive.docs.nvidia.com/metropolis/deepstream/6.3/dev-guide/text/DS_Quickstart.html)
+    - For JetPack 6.1, install [DeepStream 7.1](https://docs.nvidia.com/metropolis/deepstream/7.1/text/DS_Overview.html)
+    - For JetPack 7.1, install [DeepStream 9.0](https://docs.nvidia.com/metropolis/deepstream/9.0/text/DS_Overview.html)
 
 !!! tip
 

docs/en/guides/finetuning-guide.md

@@ -0,0 +1,190 @@
+---
+comments: true
+description: Learn how to fine-tune YOLO26 on a custom dataset with pretrained weights. Complete guide covering transfer learning, layer freezing, optimizer selection, two-stage training, and troubleshooting common issues like low mAP and catastrophic forgetting.
+keywords: fine-tune YOLO, finetune YOLO custom dataset, YOLO transfer learning, YOLO26 fine-tuning, freeze layers YOLO, pretrained YOLO custom data, YOLO training from scratch vs fine-tuning, catastrophic forgetting YOLO, two-stage fine-tuning, YOLO optimizer selection, fine-tune object detection model, custom object detection training, YOLO freeze backbone, how to finetune YOLO26
+---
+
+# How to Fine-Tune YOLO on a Custom Dataset
+
+[Fine-tuning](https://www.ultralytics.com/glossary/fine-tuning) adapts a pretrained model to recognize new classes by starting from learned weights rather than random initialization. Instead of training from scratch for hundreds of epochs, fine-tuning leverages pretrained [COCO](../datasets/detect/coco.md) features and converges on custom data in a fraction of the time.
+
+This guide covers fine-tuning [YOLO26](../models/yolo26.md) on custom datasets, from basic usage to advanced techniques like [layer freezing](#freezing-layers) and [two-stage training](#two-stage-fine-tuning).
+
+## Fine-Tuning vs Training from Scratch
+
+A pretrained model has already learned general visual features - edge detection, texture recognition, shape understanding - from millions of images. [Transfer learning](https://www.ultralytics.com/glossary/transfer-learning) through fine-tuning reuses that knowledge and only teaches the model what the new classes look like, which is why it converges faster and requires less data. Training from scratch discards all of that and forces the model to learn everything from pixel-level patterns up, which demands significantly more resources.
+
+|                       | Fine-Tuning                                          | Training from Scratch                                                 |
+| --------------------- | ---------------------------------------------------- | --------------------------------------------------------------------- |
+| **Starting weights**  | Pretrained on COCO (80 classes)                      | Random initialization                                                 |
+| **Command**           | `YOLO("yolo26n.pt")`                                 | `YOLO("yolo26n.yaml")`                                                |
+| **Convergence**       | Faster - backbone is already trained                 | Slower - all layers learn from zero                                   |
+| **Data requirements** | Lower - pretrained features compensate for less data | Higher - model must learn all features from the dataset alone         |
+| **When to use**       | Custom classes with natural images                   | Domains fundamentally different from COCO (medical, satellite, radar) |
+
+!!! tip "Fine-tuning requires no extra code"
+
+    When a `.pt` file is loaded with `YOLO("yolo26n.pt")`, the pretrained weights are stored in the model. Calling `.train(data="custom.yaml")` after that automatically transfers all compatible weights to the new model architecture, reinitializes any layers that don't match (such as the detection head when the number of classes differs), and begins training. No manual weight loading, layer manipulation, or custom transfer learning code is required.
+
+### How Pretrained Weight Transfer Works
+
+When a pretrained model is fine-tuned on a dataset with a different number of classes (for example, COCO's 80 classes to 5 custom classes), Ultralytics performs shape-aware weight transfer:
+
+1. **Backbone and neck transfer fully** - these layers extract general visual features and their shapes are independent of the number of classes.
+2. **Detection head is partially reinitialized** - the classification output layers (`cv3`, `one2one_cv3`) have shapes tied to the class count (80 vs 5), so they cannot transfer and are randomly initialized. Box regression layers (`cv2`, `one2one_cv2`) in the head have fixed shapes regardless of class count, so they transfer normally.
+3. **The vast majority of weights transfer** when changing class count. Only the classification-specific layers in the detection head are reinitialized - the backbone, neck, and box regression branches remain intact.
+
+For datasets with the same number of classes as the pretrained model (for example, fine-tuning COCO-pretrained weights on another 80-class dataset), 100% of weights transfer including the detection head.
+
+## Basic Fine-Tuning Example
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        model = YOLO("yolo26n.pt")  # load pretrained model
+        model.train(data="path/to/data.yaml", epochs=50, imgsz=640)
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo detect train model=yolo26n.pt data=path/to/data.yaml epochs=50 imgsz=640
+        ```
+
+### Choosing a Model Size
+
+Larger models have more capacity but also more parameters to update, which can increase the risk of overfitting when training data is limited. Starting with a smaller model (YOLO26n or YOLO26s) and scaling up only if validation metrics plateau is a practical approach. The optimal model size depends on the complexity of the task, the number of classes, the diversity of the dataset, and the hardware available for deployment. See the full [YOLO26 model page](../models/yolo26.md) for available sizes and performance benchmarks.
+
+## Optimizer and Learning Rate Selection
+
+The default `optimizer=auto` setting selects the optimizer and learning rate based on the total number of training iterations:
+
+- **< 10,000 iterations** (small datasets or few epochs): AdamW with a low, auto-calculated learning rate
+- **> 10,000 iterations** (large datasets): [MuSGD](../reference/optim/muon.md) (a hybrid Muon+SGD optimizer) with lr=0.01
+
+For most fine-tuning tasks, the default setting works well without any manual tuning. Consider setting the optimizer explicitly when:
+
+- **Training is unstable** (loss spikes or diverges): try `optimizer=AdamW, lr0=0.001` for more stable convergence
+- **Fine-tuning a large model on a small dataset**: a lower learning rate like `lr0=0.001` helps preserve pretrained features
+
+!!! warning "Auto optimizer overrides manual lr0"
+
+    When `optimizer=auto`, the `lr0` and `momentum` values are ignored. To control the learning rate manually, set the optimizer explicitly: `optimizer=SGD, lr0=0.005`.
+
+## Freezing Layers
+
+Freezing prevents specific layers from updating during training. This speeds up training and reduces [overfitting](https://www.ultralytics.com/glossary/overfitting) when the dataset is small relative to the model capacity.
+
+The `freeze` parameter accepts either an integer or a list. An integer `freeze=10` freezes the first 10 layers (0 through 9, which corresponds to the backbone in YOLO26). A list can contain layer indices like `freeze=[0, 3, 5]` for partial backbone freezing, or module name strings like `freeze=["23.cv2"]` for fine-grained control over specific branches within a layer.
+
+!!! example
+
+    === "Freeze backbone"
+
+        ```python
+        model.train(data="custom.yaml", epochs=50, freeze=10)
+        ```
+
+    === "Freeze specific layers"
+
+        ```python
+        model.train(data="custom.yaml", epochs=50, freeze=[0, 1, 2, 3, 4])
+        ```
+
+    === "Freeze by module name"
+
+        ```python
+        # Freeze the box regression branch of the detection head
+        model.train(data="custom.yaml", epochs=50, freeze=["23.cv2"])
+        ```
+
+The right freeze depth depends on how similar the target domain is to the pretrained data and how much training data is available:
+
+| Scenario                      | Recommendation          | Rationale                                                   |
+| ----------------------------- | ----------------------- | ----------------------------------------------------------- |
+| Large dataset, similar domain | `freeze=None` (default) | Enough data to adapt all layers without overfitting         |
+| Small dataset, similar domain | `freeze=10`             | Preserves backbone features, reduces trainable parameters   |
+| Very small dataset            | `freeze=23`             | Only the detection head trains, minimizing overfitting risk |
+| Domain far from COCO          | `freeze=None`           | Backbone features may not transfer well and need retraining |
+
+Freeze depth can also be treated as a hyperparameter - trying a few values (0, 5, 10) and comparing validation mAP is a practical way to find the best setting for a specific dataset.
+
+## Key Hyperparameters for Fine-Tuning
+
+Fine-tuning generally requires fewer hyperparameter adjustments than training from scratch. The parameters that matter most are:
+
+- **`epochs`**: Fine-tuning converges faster than training from scratch. Start with a moderate value and use `patience` to stop early when validation metrics plateau.
+- **`patience`**: The default of 100 is designed for long training runs. Reducing this to 10-20 avoids wasting time on runs that have already converged.
+- **`warmup_epochs`**: The default warmup (3 epochs) gradually increases the learning rate from zero, which prevents large gradient updates from damaging pretrained features in early iterations. Keeping the default is recommended even for fine-tuning.
+
+For the full list of training parameters, see the [training configuration reference](../usage/cfg.md).
+
+## Two-Stage Fine-Tuning
+
+Two-stage fine-tuning splits training into two phases. The first stage freezes the backbone and trains only the neck and head, allowing the detection layers to adapt to the new classes without disrupting pretrained features. The second stage unfreezes all layers and trains the full model with a lower learning rate to refine the backbone for the target domain.
+
+This approach is particularly useful when the target domain differs significantly from COCO (medical images, aerial imagery, microscopy), where the backbone may need adaptation but training everything at once causes instability. For automatic unfreezing with a callback-based approach, see [Freezing and Unfreezing the Backbone](custom-trainer.md#freezing-and-unfreezing-the-backbone).
+
+!!! example "Two-stage fine-tuning"
+
+    ```python
+    from ultralytics import YOLO
+
+    # Stage 1: freeze backbone, train head and neck
+    model = YOLO("yolo26n.pt")
+    model.train(data="custom.yaml", epochs=20, freeze=10, name="stage1", exist_ok=True)
+
+    # Stage 2: unfreeze all, fine-tune with lower lr
+    model = YOLO("runs/detect/stage1/weights/best.pt")
+    model.train(data="custom.yaml", epochs=30, lr0=0.001, name="stage2", exist_ok=True)
+    ```
+
+## Common Pitfalls
+
+### Model produces no predictions
+
+- **Insufficient training data**: training with very few samples is the most common cause - the model cannot learn or generalize from too little data. Ensure enough diverse examples per class before investigating other causes.
+- **Check dataset paths**: incorrect paths in `data.yaml` silently produce zero labels. Run `yolo detect val model=yolo26n.pt data=your_data.yaml` before training to confirm labels load correctly.
+- **Lower confidence threshold**: if predictions exist but are filtered out, try `conf=0.1` during inference.
+- **Verify class count**: ensure `nc` in `data.yaml` matches the actual number of classes in the label files.
+
+### Validation mAP plateaus early
+
+- **Add more data**: fine-tuning benefits significantly from additional training data, especially diverse examples with varied angles, lighting, and backgrounds.
+- **Check class balance**: underrepresented classes will have low AP. Use `cls_pw` to apply inverse frequency class weighting (start with `cls_pw=0.25` for moderate imbalance, increase to `1.0` for severe imbalance).
+- **Reduce augmentation**: for very small datasets, heavy augmentation can hurt more than it helps. Try `mosaic=0.5` or `mosaic=0.0`.
+- **Increase resolution**: for datasets with small objects, try `imgsz=1280` to preserve detail.
+
+### Performance degrades on original classes after fine-tuning
+
+This is known as catastrophic forgetting - the model loses previously learned knowledge when fine-tuned exclusively on new data. Forgetting is mostly unavoidable without including original dataset images alongside new data. To mitigate this:
+
+- **Merge datasets**: include examples of the original classes alongside the new classes during fine-tuning. This is the only reliable way to prevent forgetting.
+- **Freeze backbone and neck**: freezing both the backbone and neck so only the detection head trains helps for short fine-tuning runs with a very low learning rate.
+- **Train for fewer epochs**: the longer the model trains on new data exclusively, the more forgetting increases.
+
+## FAQ
+
+### How many images do I need to fine-tune YOLO?
+
+There is no fixed minimum - results depend on the complexity of the task, the number of classes, and how similar the domain is to COCO. More diverse images (varied lighting, angles, backgrounds) matter more than raw quantity. Start with what you have and scale up if validation metrics are insufficient.
+
+### How do I fine-tune YOLO26 on a custom dataset?
+
+Load a pretrained `.pt` file and call `.train()` with the path to a custom `data.yaml`. Ultralytics automatically handles [weight transfer](https://www.ultralytics.com/glossary/transfer-learning), detection head reinitialization, and optimizer selection. See the [Basic Fine-Tuning](#basic-fine-tuning-example) section for the complete code example.
+
+### Why is my fine-tuned YOLO model not detecting anything?
+
+The most common causes are incorrect paths in `data.yaml` (which silently produces zero labels), a mismatch between `nc` in the YAML and the actual label files, or a confidence threshold that is too high. See [Common Pitfalls](#model-produces-no-predictions) for a full troubleshooting checklist.
+
+### Which YOLO layers should I freeze for fine-tuning?
+
+It depends on the dataset size and domain similarity. For small datasets with a domain similar to COCO, freezing the backbone (`freeze=10`) prevents overfitting. For domains very different from COCO, leaving all layers unfrozen (`freeze=None`) allows the backbone to adapt. See [Freezing Layers](#freezing-layers) for detailed recommendations.
+
+### How do I prevent catastrophic forgetting when fine-tuning YOLO on new classes?
+
+Include examples of the original classes in the training data alongside the new classes. If that is not possible, freezing more layers (`freeze=10` or higher) and using a lower learning rate helps preserve the pretrained knowledge. See [Performance degrades on original classes](#performance-degrades-on-original-classes-after-fine-tuning) for more details.

docs/en/guides/heatmaps.md

@@ -216,4 +216,4 @@ cv2.destroyAllWindows()
 
 ### Why should businesses choose Ultralytics YOLO26 for heatmap generation in data analysis?
 
-Ultralytics YOLO26 offers seamless integration of advanced object detection and real-time heatmap generation, making it an ideal choice for businesses looking to visualize data more effectively. The key advantages include intuitive data distribution visualization, efficient pattern detection, and enhanced spatial analysis for better decision-making. Additionally, YOLO26's cutting-edge features such as persistent tracking, customizable colormaps, and support for various export formats make it superior to other tools like [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) and OpenCV for comprehensive data analysis. Learn more about business applications at [Ultralytics Plans](https://www.ultralytics.com/plans).
+Ultralytics YOLO26 offers seamless integration of advanced object detection and real-time heatmap generation, making it an ideal choice for businesses looking to visualize data more effectively. The key advantages include intuitive data distribution visualization, efficient pattern detection, and enhanced spatial analysis for better decision-making. Additionally, YOLO26's cutting-edge features such as persistent tracking, customizable colormaps, and support for various export formats make it superior to other tools like [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) and OpenCV for comprehensive data analysis. Learn more about business applications at [Ultralytics Plans](https://www.ultralytics.com/pricing).

docs/en/guides/hyperparameter-tuning.md

@@ -8,7 +8,7 @@ keywords: Ultralytics YOLO, hyperparameter tuning, machine learning, model optim
 
 ## Introduction
 
-Hyperparameter tuning is not just a one-time setup but an iterative process aimed at optimizing the [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) model's performance metrics, such as accuracy, precision, and recall. In the context of Ultralytics YOLO, these hyperparameters could range from learning rate to architectural details, such as the number of layers or types of activation functions used.
+Hyperparameter tuning is not just a one-time setup but an iterative process aimed at optimizing the [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) model's performance metrics, such as accuracy, precision, and recall. In the context of Ultralytics YOLO, these hyperparameters could range from learning rate to architectural details, such as the number of layers or types of activation functions used. [Ultralytics Platform](https://platform.ultralytics.com) also supports [cloud training](../platform/train/cloud-training.md) with configurable hyperparameters and real-time metrics tracking.
 
 <p align="center">
   <br>
@@ -70,7 +70,7 @@ Use metrics like AP50, F1-score, or custom metrics to evaluate the model's perfo
 
 ### Log Results
 
-It's crucial to log both the performance metrics and the corresponding hyperparameters for future reference. Ultralytics YOLO automatically saves these results in CSV format.
+It's crucial to log both the performance metrics and the corresponding hyperparameters for future reference. Ultralytics YOLO automatically saves these results in NDJSON format.
 
 ### Repeat
 
@@ -90,6 +90,7 @@ The following table lists the default search space parameters for hyperparameter
 | `warmup_momentum` | `float` | `(0.0, 0.95)`  | Initial momentum during warmup phase. Gradually increases to the final momentum value                                      |
 | `box`             | `float` | `(1.0, 20.0)`  | Bounding box loss weight in the total loss function. Balances box regression vs classification                             |
 | `cls`             | `float` | `(0.1, 4.0)`   | Classification loss weight in the total loss function. Higher values emphasize correct class prediction                    |
+| `cls_pw`          | `float` | `(0.0, 1.0)`   | Class weighting power for handling class imbalance. Higher values increase weight on rare classes                          |
 | `dfl`             | `float` | `(0.4, 12.0)`  | DFL (Distribution Focal Loss) weight in the total loss function. Higher values emphasize precise bounding box localization |
 | `hsv_h`           | `float` | `(0.0, 0.1)`   | Random hue augmentation range in HSV color space. Helps model generalize across color variations                           |
 | `hsv_s`           | `float` | `(0.0, 0.9)`   | Random saturation augmentation range in HSV space. Simulates different lighting conditions                                 |
@@ -186,8 +187,8 @@ runs/
     ├── ...
     └── tune/
         ├── best_hyperparameters.yaml
-        ├── best_fitness.png
-        ├── tune_results.csv
+        ├── tune_fitness.png
+        ├── tune_results.ndjson
         ├── tune_scatter_plots.png
         └── weights/
             ├── last.pt
@@ -236,7 +237,7 @@ This YAML file contains the best-performing hyperparameters found during the tun
     copy_paste: 0.0
     ```
 
-#### best_fitness.png
+#### tune_fitness.png
 
 This is a plot displaying fitness (typically a performance metric like AP50) against the number of iterations. It helps you visualize how well the genetic algorithm performed over time.
 
@@ -247,23 +248,59 @@ This is a plot displaying fitness (typically a performance metric like AP50) aga
   <img width="640" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/best-fitness.avif" alt="Hyperparameter Tuning Fitness vs Iteration">
 </p>
 
-#### tune_results.csv
+#### tune_results.ndjson
 
-A CSV file containing detailed results of each iteration during the tuning. Each row in the file represents one iteration, and it includes metrics like fitness score, [precision](https://www.ultralytics.com/glossary/precision), [recall](https://www.ultralytics.com/glossary/recall), as well as the hyperparameters used.
+An NDJSON file containing detailed results of each tuning iteration. Each line is one JSON object with the aggregate fitness, tuned hyperparameters, and per-dataset metrics. Single-dataset and multi-dataset tuning use the same file format.
 
-- **Format**: CSV
+- **Format**: NDJSON
 - **Usage**: Per-iteration results tracking.
 - **Example**:
-    ```csv
-      fitness,lr0,lrf,momentum,weight_decay,warmup_epochs,warmup_momentum,box,cls,dfl,hsv_h,hsv_s,hsv_v,degrees,translate,scale,shear,perspective,flipud,fliplr,mosaic,mixup,copy_paste
-      0.05021,0.01,0.01,0.937,0.0005,3.0,0.8,7.5,0.5,1.5,0.015,0.7,0.4,0.0,0.1,0.5,0.0,0.0,0.0,0.5,1.0,0.0,0.0
-      0.07217,0.01003,0.00967,0.93897,0.00049,2.79757,0.81075,7.5,0.50746,1.44826,0.01503,0.72948,0.40658,0.0,0.0987,0.4922,0.0,0.0,0.0,0.49729,1.0,0.0,0.0
-      0.06584,0.01003,0.00855,0.91009,0.00073,3.42176,0.95,8.64301,0.54594,1.72261,0.01503,0.59179,0.40658,0.0,0.0987,0.46955,0.0,0.0,0.0,0.49729,0.80187,0.0,0.0
-    ```
+
+A pretty-printed example is shown below for readability. In the actual `.ndjson` file, each object is stored on a single line.
+
+```json
+{
+  "iteration": 1,
+  "fitness": 0.23345,
+  "hyperparameters": {
+    "lr0": 0.01,
+    "lrf": 0.01,
+    "momentum": 0.937,
+    "weight_decay": 0.0005
+  },
+  "datasets": {
+    "coco8": {
+      "fitness": 0.28992
+    },
+    "coco8-grayscale": {
+      "fitness": 0.17697
+    }
+  }
+}
+
+{
+  "iteration": 2,
+  "fitness": 0.23661,
+  "hyperparameters": {
+    "lr0": 0.0062,
+    "lrf": 0.01,
+    "momentum": 0.90058,
+    "weight_decay": 0.0
+  },
+  "datasets": {
+    "coco8": {
+      "fitness": 0.29561
+    },
+    "coco8-grayscale": {
+      "fitness": 0.1776
+    }
+  }
+}
+```
 
 #### tune_scatter_plots.png
 
-This file contains scatter plots generated from `tune_results.csv`, helping you visualize relationships between different hyperparameters and performance metrics. Note that hyperparameters initialized to 0 will not be tuned, such as `degrees` and `shear` below.
+This file contains scatter plots generated from `tune_results.ndjson`, helping you visualize relationships between different hyperparameters and performance metrics. Note that hyperparameters initialized to 0 will not be tuned, such as `degrees` and `shear` below.
 
 - **Format**: PNG
 - **Usage**: Exploratory data analysis

docs/en/guides/index.md

@@ -38,6 +38,7 @@ Here's a compilation of in-depth guides to help you master different aspects of
 - [Docker Quickstart](docker-quickstart.md): Complete guide to setting up and using Ultralytics YOLO models with [Docker](https://hub.docker.com/r/ultralytics/ultralytics). Learn how to install Docker, manage GPU support, and run YOLO models in isolated containers for consistent development and deployment.
 - [Edge TPU on Raspberry Pi](coral-edge-tpu-on-raspberry-pi.md): [Google Edge TPU](https://developers.google.com/coral) accelerates YOLO inference on [Raspberry Pi](https://www.raspberrypi.com/).
 - [End-to-End Detection](end2end-detection.md): Understand YOLO26's NMS-free end-to-end detection, export compatibility, output format changes, and how to migrate from older YOLO models.
+- [Fine-Tuning YOLO on Custom Data](finetuning-guide.md): Complete guide to fine-tuning YOLO26 on custom datasets with pretrained weights, covering transfer learning, layer freezing, optimizer selection, two-stage training, and troubleshooting.
 - [Hyperparameter Tuning](hyperparameter-tuning.md): Discover how to optimize your YOLO models by fine-tuning hyperparameters using the Tuner class and genetic evolution algorithms.
 - [Insights on Model Evaluation and Fine-Tuning](model-evaluation-insights.md): Gain insights into the strategies and best practices for evaluating and fine-tuning your computer vision models. Learn about the iterative process of refining models to achieve optimal results.
 - [Isolating Segmentation Objects](isolating-segmentation-objects.md): Step-by-step recipe and explanation on how to extract and/or isolate objects from images using Ultralytics Segmentation.
@@ -45,6 +46,7 @@ Here's a compilation of in-depth guides to help you master different aspects of
 - [Maintaining Your Computer Vision Model](model-monitoring-and-maintenance.md): Understand the key practices for monitoring, maintaining, and documenting computer vision models to guarantee accuracy, spot anomalies, and mitigate data drift.
 - [Model Deployment Options](model-deployment-options.md): Overview of YOLO [model deployment](https://www.ultralytics.com/glossary/model-deployment) formats like ONNX, OpenVINO, and TensorRT, with pros and cons for each to inform your deployment strategy.
 - [Model YAML Configuration Guide](model-yaml-config.md): A comprehensive deep dive into Ultralytics' model architecture definitions. Explore the YAML format, understand the module resolution system, and learn how to integrate custom modules seamlessly.
+- [NVIDIA DALI GPU Preprocessing](nvidia-dali.md): Eliminate CPU preprocessing bottlenecks by running YOLO letterbox resize, padding, and normalization on the GPU using NVIDIA DALI, with Triton Inference Server integration.
 - [NVIDIA DGX Spark](nvidia-dgx-spark.md): Quickstart guide for deploying YOLO models on NVIDIA DGX Spark devices.
 - [NVIDIA Jetson](nvidia-jetson.md): Quickstart guide for deploying YOLO models on NVIDIA Jetson devices.
 - [OpenVINO Latency vs Throughput Modes](optimizing-openvino-latency-vs-throughput-modes.md): Learn latency and throughput optimization techniques for peak YOLO inference performance.

docs/en/guides/modal-quickstart.md

@@ -0,0 +1,197 @@
+---
+comments: true
+description: Learn to set up Modal for running Ultralytics YOLO26 in the cloud. Follow our guide for easy serverless GPU inference and training.
+keywords: Ultralytics, Modal, YOLO26, serverless, cloud computing, GPU, machine learning, inference, training
+---
+
+# Modal Quickstart Guide for Ultralytics
+
+This guide provides a comprehensive introduction to running [Ultralytics YOLO26](../models/yolo26.md) on [Modal](https://modal.com/), covering serverless GPU inference and model training.
+
+## What is Modal?
+
+[Modal](https://modal.com/) is a serverless [cloud computing](https://www.ultralytics.com/glossary/cloud-computing) platform for AI and [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) workloads. It handles provisioning, scaling, and execution automatically — you write Python code locally and Modal runs it in the cloud with GPU access. This makes it ideal for running [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models like YOLO26 without managing infrastructure.
+
+## What You Will Learn
+
+- Setting up Modal and authenticating
+- Running YOLO26 inference on Modal
+- Using GPUs for faster inference
+- Training YOLO26 models on Modal
+
+## Prerequisites
+
+- A Modal account (sign up for free at [modal.com](https://modal.com/))
+- Python 3.9 or later installed on your local machine
+
+## Installation
+
+Install the Modal Python package and authenticate:
+
+```bash
+pip install modal
+```
+
+```bash
+modal token new
+```
+
+!!! tip "Authentication"
+
+    The `modal token new` command will open a browser window to authenticate your Modal account. After authentication, you can run Modal commands from the terminal.
+
+## Running YOLO26 Inference
+
+Create a new Python file called `modal_yolo.py` with the following code:
+
+```python
+"""
+Modal + Ultralytics YOLO26 Quickstart
+Run: modal run modal_yolo.py.
+"""
+
+import modal
+
+app = modal.App("ultralytics-yolo")
+
+image = modal.Image.debian_slim(python_version="3.11").apt_install("libgl1", "libglib2.0-0").pip_install("ultralytics")
+
+
+@app.function(image=image)
+def predict(image_url: str):
+    """Run YOLO26 inference on an image URL."""
+    from ultralytics import YOLO
+
+    model = YOLO("yolo26n.pt")
+    results = model(image_url)
+
+    for r in results:
+        print(f"Detected {len(r.boxes)} objects:")
+        for box in r.boxes:
+            print(f"  - {model.names[int(box.cls)]}: {float(box.conf):.2f}")
+
+
+@app.local_entrypoint()
+def main():
+    """Test inference with sample image."""
+    predict.remote("https://ultralytics.com/images/bus.jpg")
+```
+
+Run the inference:
+
+```bash
+modal run modal_yolo.py
+```
+
+Expected output:
+
+```
+✓ Initialized. View run at https://modal.com/apps/your-username/main/ap-xxxxxxxx
+✓ Created objects.
+├── 🔨 Created mount modal_yolo.py
+└── 🔨 Created function predict.
+Downloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt to 'yolo26n.pt'...
+Downloading https://ultralytics.com/images/bus.jpg to 'bus.jpg'...
+image 1/1 /root/bus.jpg: 640x480 4 persons, 1 bus, 377.8ms
+Speed: 5.8ms preprocess, 377.8ms inference, 0.3ms postprocess per image at shape (1, 3, 640, 480)
+
+Detected 5 objects:
+  - bus: 0.92
+  - person: 0.91
+  - person: 0.91
+  - person: 0.87
+  - person: 0.53
+✓ App completed.
+```
+
+You can monitor your function execution in the Modal dashboard:
+
+<p align="center">
+  <img width="800" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@fda2504f1e5dab2f437097ac7b99a7da984e4243/docs/modal-dashboard-function-calls.avif" alt="Modal Dashboard Function Calls">
+</p>
+
+## Using GPU for Faster Inference
+
+Add a GPU to your function by specifying the `gpu` parameter:
+
+```python
+@app.function(image=image, gpu="T4")  # Options: "T4", "A10G", "A100", "H100"
+def predict_gpu(image_url: str):
+    """Run YOLO26 inference on GPU."""
+    from ultralytics import YOLO
+
+    model = YOLO("yolo26n.pt")
+    results = model(image_url)
+    print(results[0].boxes)
+```
+
+| GPU  | Memory | Best For                        |
+| ---- | ------ | ------------------------------- |
+| T4   | 16 GB  | Inference, small model training |
+| A10G | 24 GB  | Medium training jobs            |
+| A100 | 40 GB  | Large-scale training            |
+| H100 | 80 GB  | Maximum performance             |
+
+## Training YOLO26 on Modal
+
+For training, use a GPU and Modal [Volumes](https://modal.com/docs/guide/volumes) for persistent storage. Create a new Python file called `train_yolo.py`:
+
+```python
+import modal
+
+app = modal.App("ultralytics-training")
+
+volume = modal.Volume.from_name("yolo-training-vol", create_if_missing=True)
+
+image = modal.Image.debian_slim(python_version="3.11").apt_install("libgl1", "libglib2.0-0").pip_install("ultralytics")
+
+
+@app.function(image=image, gpu="T4", timeout=3600, volumes={"/data": volume})
+def train():
+    """Train YOLO26 model on Modal."""
+    from ultralytics import YOLO
+
+    model = YOLO("yolo26n.pt")
+    model.train(data="coco8.yaml", epochs=3, imgsz=640, project="/data/runs")
+
+
+@app.local_entrypoint()
+def main():
+    train.remote()
+```
+
+Run training:
+
+```bash
+modal run train_yolo.py
+```
+
+!!! tip "Volume Persistence"
+
+    Modal Volumes persist data between function runs. Trained weights are saved to `/data/runs/detect/train/weights/`.
+
+Congratulations! You have successfully set up Ultralytics YOLO26 on Modal. For further learning:
+
+- Explore the [Ultralytics YOLO26 documentation](../models/yolo26.md) for advanced features
+- Learn about [training custom models](../modes/train.md) with your own datasets
+- Visit the [Modal documentation](https://modal.com/docs) for advanced platform features
+
+## FAQ
+
+### How do I choose the right GPU for my YOLO26 workload?
+
+For inference, an NVIDIA T4 (16 GB) is typically sufficient and cost-effective. For training or larger models like YOLO26x, consider A10G or A100 GPUs.
+
+### How much does it cost to run YOLO26 on Modal?
+
+Modal uses pay-per-second pricing. Approximate rates: CPU ~$0.05/hr, T4 ~$0.59/hr, A10G ~$1.10/hr, A100 ~$2.10/hr. Check [Modal pricing](https://modal.com/pricing) for current rates.
+
+### Can I use my own custom-trained YOLO model?
+
+Yes! Load custom models from a Modal Volume:
+
+```python
+model = YOLO("/data/my_custom_model.pt")
+```
+
+For more information on training custom models, see the [training guide](../modes/train.md).

docs/en/guides/model-deployment-options.md

@@ -27,7 +27,7 @@ This guide walks you through YOLO26's deployment options and the essential facto
 
 When it's time to deploy your YOLO26 model, selecting a suitable export format is very important. As outlined in the [Ultralytics YOLO26 Modes documentation](../modes/export.md#usage-examples), the `model.export()` function allows you to convert your trained model into a variety of formats tailored to diverse environments and performance requirements.
 
-The ideal format depends on your model's intended operational context, balancing speed, hardware constraints, and ease of integration. In the following section, we'll take a closer look at each export option, understanding when to choose each one.
+The ideal format depends on your model's intended operational context, balancing speed, hardware constraints, and ease of integration. For managed deployment without manual export, [Ultralytics Platform](https://platform.ultralytics.com) provides ready-to-use [inference endpoints](../platform/deploy/endpoints.md) with auto-scaling across 43 global regions. In the following section, we'll take a closer look at each export option, understanding when to choose each one.
 
 ## YOLO26's Deployment Options
 

docs/en/guides/model-evaluation-insights.md

@@ -104,6 +104,7 @@ If you want to get a deeper understanding of your YOLO26 model's performance, yo
         print("Mean results for different metrics:", results.box.mean_results)
         print("Mean precision:", results.box.mp)
         print("Mean recall:", results.box.mr)
+        print("Per-image metrics:", results.box.image_metrics)
         print("Precision:", results.box.p)
         print("Precision curve:", results.box.p_curve)
         print("Precision values:", results.box.prec_values)
@@ -112,7 +113,10 @@ If you want to get a deeper understanding of your YOLO26 model's performance, yo
         print("Recall curve:", results.box.r_curve)
         ```
 
-The results object also includes speed metrics like preprocess time, inference time, loss, and postprocess time. By analyzing these metrics, you can fine-tune and optimize your YOLO26 model for better performance, making it more effective for your specific use case.
+The results object also includes `image_metrics`, a per-image dictionary keyed by image filename with `precision`,
+`recall`, `f1`, `tp`, `fp`, and `fn`, as well as speed metrics like preprocess time, inference time, loss, and
+postprocess time. By analyzing these metrics, you can fine-tune and optimize your YOLO26 model for better performance,
+making it more effective for your specific use case.
 
 ## How Does Fine-Tuning Work?
 

docs/en/guides/nvidia-dali.md

@@ -0,0 +1,570 @@
+---
+comments: true
+description: Learn how to use NVIDIA DALI for GPU-accelerated preprocessing with Ultralytics YOLO models. Eliminate CPU bottlenecks by running letterbox resize, padding, and normalization on the GPU for faster TensorRT and Triton deployments.
+keywords: NVIDIA DALI, GPU preprocessing, Ultralytics, YOLO, YOLO26, TensorRT, Triton Inference Server, letterbox, inference optimization, deep learning, computer vision, deployment, video processing, batch inference, DALI pipeline, CV-CUDA
+---
+
+# GPU-Accelerated Preprocessing with NVIDIA DALI
+
+## Introduction
+
+When deploying [Ultralytics YOLO](../models/index.md) models in production, [preprocessing](https://www.ultralytics.com/glossary/data-preprocessing) often becomes the bottleneck. While [TensorRT](../integrations/tensorrt.md) can run model [inference](../modes/predict.md) in just a few milliseconds, the CPU-based preprocessing (resize, pad, normalize) can take 2-10ms per image, especially at high resolutions. [NVIDIA DALI](https://docs.nvidia.com/deeplearning/dali/user-guide/docs/index.html) (Data Loading Library) solves this by moving the entire preprocessing pipeline to the GPU.
+
+This guide walks you through building DALI pipelines that exactly replicate Ultralytics YOLO preprocessing, integrating them with `model.predict()`, processing video streams, and deploying end-to-end with [Triton Inference Server](triton-inference-server.md).
+
+!!! tip "Who is this guide for?"
+
+    This guide is for engineers deploying YOLO models in production environments where CPU preprocessing is a measured bottleneck — typically [TensorRT](../integrations/tensorrt.md) deployments on NVIDIA GPUs, high-throughput video pipelines, or [Triton Inference Server](triton-inference-server.md) setups. If you're running standard inference with `model.predict()` and don't have a preprocessing bottleneck, the default CPU pipeline works well.
+
+!!! summary "Quick Summary"
+
+    - **Building a DALI pipeline?** Use `fn.resize(mode="not_larger")` + `fn.crop(out_of_bounds_policy="pad")` + `fn.crop_mirror_normalize` to replicate YOLO's letterbox preprocessing on GPU.
+    - **Integrating with Ultralytics?** Pass the DALI output as a `torch.Tensor` to `model.predict()` — Ultralytics skips image preprocessing automatically.
+    - **Deploying with Triton?** Use the DALI backend with a TensorRT ensemble for zero-CPU preprocessing.
+
+## Why Use DALI for YOLO Preprocessing
+
+In a typical YOLO inference pipeline, the preprocessing steps run on the CPU:
+
+1. **Decode** the image (JPEG/PNG)
+2. **Resize** while preserving aspect ratio
+3. **Pad** to the target size (letterbox)
+4. **Normalize** pixel values from `[0, 255]` to `[0, 1]`
+5. **Convert** layout from HWC to CHW
+
+With DALI, all these operations run on the GPU, eliminating the CPU bottleneck. This is especially valuable when:
+
+| Scenario                                                                 | Why DALI Helps                                                                                                          |
+| ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| **Fast GPU inference**                                                   | [TensorRT](../integrations/tensorrt.md) engines with sub-millisecond inference make CPU preprocessing the dominant cost |
+| **High-resolution inputs**                                               | 1080p and 4K video streams require expensive resize operations                                                          |
+| **Large [batch sizes](https://www.ultralytics.com/glossary/batch-size)** | Server-side inference processing many images in parallel                                                                |
+| **Limited CPU cores**                                                    | Edge devices like [NVIDIA Jetson](nvidia-jetson.md), or dense GPU servers with few CPU cores per GPU                    |
+
+## Prerequisites
+
+!!! warning "Linux Only"
+
+    NVIDIA DALI supports **Linux only**. It is not available on Windows or macOS.
+
+Install the required packages:
+
+=== "CUDA 12.x"
+
+    ```bash
+    pip install ultralytics
+    pip install --extra-index-url https://pypi.nvidia.com nvidia-dali-cuda120
+    ```
+
+=== "CUDA 11.x"
+
+    ```bash
+    pip install ultralytics
+    pip install --extra-index-url https://pypi.nvidia.com nvidia-dali-cuda110
+    ```
+
+**Requirements:**
+
+- NVIDIA GPU (compute capability 5.0+ / Maxwell or newer)
+- CUDA 11.0+ or 12.0+
+- Python 3.10-3.14
+- Linux operating system
+
+## Understanding YOLO Preprocessing
+
+Before building a DALI pipeline, it helps to understand exactly what Ultralytics does during preprocessing. The key class is `LetterBox` in [`ultralytics/data/augment.py`](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/augment.py):
+
+```python
+from ultralytics.data.augment import LetterBox
+
+letterbox = LetterBox(
+    new_shape=(640, 640),  # Target size
+    center=True,  # Center the image (pad equally on both sides)
+    stride=32,  # Stride alignment
+    padding_value=114,  # Gray padding (114, 114, 114)
+)
+```
+
+The full preprocessing pipeline in [`ultralytics/engine/predictor.py`](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/predictor.py) performs these steps:
+
+| Step | Operation                  | CPU Function                    | DALI Equivalent                               |
+| ---- | -------------------------- | ------------------------------- | --------------------------------------------- |
+| 1    | Letterbox resize           | `cv2.resize`                    | `fn.resize(mode="not_larger")`                |
+| 2    | Centered padding           | `cv2.copyMakeBorder`            | `fn.crop(out_of_bounds_policy="pad")`         |
+| 3    | BGR → RGB                  | `im[..., ::-1]`                 | `fn.decoders.image(output_type=types.RGB)`    |
+| 4    | HWC → CHW + normalize /255 | `np.transpose` + `tensor / 255` | `fn.crop_mirror_normalize(std=[255,255,255])` |
+
+The letterbox operation preserves the aspect ratio by:
+
+1. Computing scale: `r = min(target_h / h, target_w / w)`
+2. Resizing to `(round(w * r), round(h * r))`
+3. Padding the remaining space with gray (`114`) to reach the target size
+4. Centering the image so padding is distributed equally on both sides
+
+## DALI Pipeline for YOLO
+
+Use the centered pipeline below as the default reference. It matches Ultralytics `LetterBox(center=True)` behavior, which is what standard YOLO inference uses.
+
+### Centered Pipeline (Recommended, matches Ultralytics LetterBox)
+
+This version exactly replicates the default Ultralytics preprocessing with centered padding, matching `LetterBox(center=True)`:
+
+!!! example "DALI pipeline with centered padding (recommended)"
+
+    ```python
+    import nvidia.dali as dali
+    import nvidia.dali.fn as fn
+    import nvidia.dali.types as types
+
+
+    @dali.pipeline_def(batch_size=8, num_threads=4, device_id=0)
+    def yolo_dali_pipeline_centered(image_dir, target_size=640):
+        """DALI pipeline replicating YOLO preprocessing with centered padding.
+
+        Matches Ultralytics LetterBox(center=True) behavior exactly.
+        """
+        # Read and decode images on GPU
+        jpegs, _ = fn.readers.file(file_root=image_dir, random_shuffle=False, name="Reader")
+        images = fn.decoders.image(jpegs, device="mixed", output_type=types.RGB)
+
+        # Aspect-ratio-preserving resize
+        resized = fn.resize(
+            images,
+            resize_x=target_size,
+            resize_y=target_size,
+            mode="not_larger",
+            interp_type=types.INTERP_LINEAR,
+            antialias=False,  # Match cv2.INTER_LINEAR (no antialiasing)
+        )
+
+        # Centered padding using fn.crop with out_of_bounds_policy
+        # When crop size > image size, fn.crop centers the image and pads symmetrically
+        padded = fn.crop(
+            resized,
+            crop=(target_size, target_size),
+            out_of_bounds_policy="pad",
+            fill_values=114,  # YOLO padding value
+        )
+
+        # Normalize and convert layout
+        output = fn.crop_mirror_normalize(
+            padded,
+            dtype=types.FLOAT,
+            output_layout="CHW",
+            mean=[0.0, 0.0, 0.0],
+            std=[255.0, 255.0, 255.0],
+        )
+        return output
+    ```
+
+!!! note "When is `fn.pad` enough?"
+
+    If you do not need exact `LetterBox(center=True)` parity, you can simplify the padding step by using `fn.pad(...)` instead of `fn.crop(..., out_of_bounds_policy="pad")`. That variant pads only the **right and bottom** edges, which can be acceptable for custom deployment pipelines, but it will not match Ultralytics' default centered letterbox behavior exactly.
+
+!!! tip "Why `fn.crop` for centered padding?"
+
+    DALI's `fn.pad` operator only adds padding to the **right and bottom** edges. To get centered padding (matching Ultralytics `LetterBox(center=True)`), use `fn.crop` with `out_of_bounds_policy="pad"`. With the default `crop_pos_x=0.5` and `crop_pos_y=0.5`, the image is automatically centered with symmetric padding.
+
+!!! warning "Antialias Mismatch"
+
+    DALI's `fn.resize` enables antialiasing by default (`antialias=True`), while OpenCV's `cv2.resize` with `INTER_LINEAR` does **not** apply antialiasing. Always set `antialias=False` in DALI to match the CPU pipeline. Omitting this causes subtle numerical differences that can affect [model accuracy](https://www.ultralytics.com/glossary/accuracy).
+
+### Running the Pipeline
+
+!!! example "Build and run a DALI pipeline"
+
+    ```python
+    # Build and run the pipeline
+    pipe = yolo_dali_pipeline_centered(image_dir="/path/to/images", target_size=640)
+    pipe.build()
+
+    # Get a batch of preprocessed images
+    (output,) = pipe.run()
+
+    # Convert to numpy or PyTorch tensors
+    batch_np = output.as_cpu().as_array()  # Shape: (batch_size, 3, 640, 640)
+    print(f"Output shape: {batch_np.shape}, dtype: {batch_np.dtype}")
+    print(f"Value range: [{batch_np.min():.4f}, {batch_np.max():.4f}]")
+    ```
+
+## Using DALI with Ultralytics Predict
+
+You can pass a preprocessed [PyTorch](https://www.ultralytics.com/glossary/pytorch) tensor directly to `model.predict()`. When a `torch.Tensor` is passed, Ultralytics **skips image preprocessing** (letterbox, BGR→RGB, HWC→CHW, and /255 normalization) and only performs device transfer and dtype casting before sending it to the model.
+
+Since Ultralytics doesn't have access to the original image dimensions in this case, detection box coordinates are returned in the 640×640 letterboxed space. To map them back to original image coordinates, use [`scale_boxes`](../reference/utils/ops.md) which handles the exact rounding logic used by `LetterBox`:
+
+```python
+from ultralytics.utils.ops import scale_boxes
+
+# boxes: tensor of shape (N, 4) in xyxy format, in 640x640 letterboxed coords
+# Scale boxes from letterboxed (640, 640) back to original (orig_h, orig_w)
+boxes = scale_boxes((640, 640), boxes, (orig_h, orig_w))
+```
+
+This applies to all external preprocessing paths — direct tensor input, video streams, and Triton deployment.
+
+!!! example "DALI + Ultralytics predict"
+
+    ```python
+    from nvidia.dali.plugin.pytorch import DALIGenericIterator
+
+    from ultralytics import YOLO
+
+    # Load model
+    model = YOLO("yolo26n.pt")
+
+    # Create DALI iterator
+    pipe = yolo_dali_pipeline_centered(image_dir="/path/to/images", target_size=640)
+    pipe.build()
+    dali_iter = DALIGenericIterator(pipe, ["images"], reader_name="Reader")
+
+    # Run inference with DALI-preprocessed tensors
+    for batch in dali_iter:
+        images = batch[0]["images"]  # Already on GPU, shape (B, 3, 640, 640)
+        results = model.predict(images, verbose=False)
+        for result in results:
+            print(f"Detected {len(result.boxes)} objects")
+    ```
+
+!!! tip "Zero Preprocessing Overhead"
+
+    When you pass a `torch.Tensor` to `model.predict()`, the image preprocessing step takes ~0.004ms (essentially zero) compared to ~1-10ms with CPU preprocessing. The tensor must be in BCHW format, float32 (or float16), and normalized to `[0, 1]`. Ultralytics will still handle device transfer and dtype casting automatically.
+
+## DALI with Video Streams
+
+For real-time video processing, use `fn.external_source` to feed frames from any source — [OpenCV](https://www.ultralytics.com/glossary/opencv), GStreamer, or custom capture libraries:
+
+!!! example "DALI pipeline for video stream preprocessing"
+
+    === "Pipeline Definition"
+
+        ```python
+        import nvidia.dali as dali
+        import nvidia.dali.fn as fn
+        import nvidia.dali.types as types
+
+
+        @dali.pipeline_def(batch_size=1, num_threads=4, device_id=0)
+        def yolo_video_pipeline(target_size=640):
+            """DALI pipeline for processing video frames from external source."""
+            # External source for feeding frames from OpenCV, GStreamer, etc.
+            frames = fn.external_source(device="cpu", name="input")
+            frames = fn.reshape(frames, layout="HWC")
+
+            # Move to GPU and preprocess
+            frames_gpu = frames.gpu()
+            resized = fn.resize(
+                frames_gpu,
+                resize_x=target_size,
+                resize_y=target_size,
+                mode="not_larger",
+                interp_type=types.INTERP_LINEAR,
+                antialias=False,
+            )
+            padded = fn.crop(
+                resized,
+                crop=(target_size, target_size),
+                out_of_bounds_policy="pad",
+                fill_values=114,
+            )
+            output = fn.crop_mirror_normalize(
+                padded,
+                dtype=types.FLOAT,
+                output_layout="CHW",
+                mean=[0.0, 0.0, 0.0],
+                std=[255.0, 255.0, 255.0],
+            )
+            return output
+        ```
+
+    === "Inference Loop (Simple OpenCV fallback)"
+
+        ```python
+        import cv2
+        import numpy as np
+        import torch
+
+        from ultralytics import YOLO
+
+        model = YOLO("yolo26n.engine")  # TensorRT model
+
+        pipe = yolo_video_pipeline(target_size=640)
+        pipe.build()
+
+        cap = cv2.VideoCapture("video.mp4")
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            # Feed BGR frame (convert to RGB for DALI)
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            pipe.feed_input("input", [np.array(frame_rgb)])
+            (output,) = pipe.run()
+
+            # Convert DALI output to torch tensor for inference.
+            # This is a simple fallback path: using feed_input() with pipe.run() keeps a GPU->CPU->GPU copy.
+            # For high-throughput deployments, prefer a reader-based pipeline plus DALIGenericIterator to keep data on GPU.
+            tensor = torch.tensor(output.as_cpu().as_array()).to("cuda")
+            results = model.predict(tensor, verbose=False)
+        ```
+
+## Triton Inference Server with DALI
+
+For production deployment, combine DALI preprocessing with [TensorRT](../integrations/tensorrt.md) inference in [Triton Inference Server](triton-inference-server.md) using an ensemble model. This eliminates CPU preprocessing entirely — raw JPEG bytes go in, detections come out, with everything processed on the GPU.
+
+### Model Repository Structure
+
+```
+model_repository/
+├── dali_preprocessing/
+│   ├── 1/
+│   │   └── model.dali
+│   └── config.pbtxt
+├── yolo_trt/
+│   ├── 1/
+│   │   └── model.plan
+│   └── config.pbtxt
+└── ensemble_dali_yolo/
+    ├── 1/                  # Empty directory (required by Triton)
+    └── config.pbtxt
+```
+
+### Step 1: Create the DALI Pipeline
+
+Serialize the DALI pipeline for the Triton DALI backend:
+
+!!! example "Serialize DALI pipeline for Triton"
+
+    ```python
+    import nvidia.dali as dali
+    import nvidia.dali.fn as fn
+    import nvidia.dali.types as types
+
+
+    @dali.pipeline_def(batch_size=8, num_threads=4, device_id=0)
+    def triton_dali_pipeline():
+        """DALI preprocessing pipeline for Triton deployment."""
+        # Input: raw encoded image bytes from Triton
+        images = fn.external_source(device="cpu", name="DALI_INPUT_0")
+        images = fn.decoders.image(images, device="mixed", output_type=types.RGB)
+
+        resized = fn.resize(
+            images,
+            resize_x=640,
+            resize_y=640,
+            mode="not_larger",
+            interp_type=types.INTERP_LINEAR,
+            antialias=False,
+        )
+        padded = fn.crop(
+            resized,
+            crop=(640, 640),
+            out_of_bounds_policy="pad",
+            fill_values=114,
+        )
+        output = fn.crop_mirror_normalize(
+            padded,
+            dtype=types.FLOAT,
+            output_layout="CHW",
+            mean=[0.0, 0.0, 0.0],
+            std=[255.0, 255.0, 255.0],
+        )
+        return output
+
+
+    # Serialize pipeline to model repository
+    pipe = triton_dali_pipeline()
+    pipe.serialize(filename="model_repository/dali_preprocessing/1/model.dali")
+    ```
+
+### Step 2: Export YOLO to TensorRT
+
+!!! example "Export YOLO model to TensorRT engine"
+
+    ```python
+    from ultralytics import YOLO
+
+    model = YOLO("yolo26n.pt")
+    model.export(format="engine", imgsz=640, half=True, batch=8)
+    # Copy the .engine file to model_repository/yolo_trt/1/model.plan
+    ```
+
+### Step 3: Configure Triton
+
+**dali_preprocessing/config.pbtxt:**
+
+```protobuf
+name: "dali_preprocessing"
+backend: "dali"
+max_batch_size: 8
+input [
+  {
+    name: "DALI_INPUT_0"
+    data_type: TYPE_UINT8
+    dims: [ -1 ]
+  }
+]
+output [
+  {
+    name: "DALI_OUTPUT_0"
+    data_type: TYPE_FP32
+    dims: [ 3, 640, 640 ]
+  }
+]
+```
+
+**yolo_trt/config.pbtxt:**
+
+```protobuf
+name: "yolo_trt"
+platform: "tensorrt_plan"
+max_batch_size: 8
+input [
+  {
+    name: "images"
+    data_type: TYPE_FP32
+    dims: [ 3, 640, 640 ]
+  }
+]
+output [
+  {
+    name: "output0"
+    data_type: TYPE_FP32
+    dims: [ 300, 6 ]
+  }
+]
+```
+
+**ensemble_dali_yolo/config.pbtxt:**
+
+```protobuf
+name: "ensemble_dali_yolo"
+platform: "ensemble"
+max_batch_size: 8
+input [
+  {
+    name: "INPUT"
+    data_type: TYPE_UINT8
+    dims: [ -1 ]
+  }
+]
+output [
+  {
+    name: "OUTPUT"
+    data_type: TYPE_FP32
+    dims: [ 300, 6 ]
+  }
+]
+ensemble_scheduling {
+  step [
+    {
+      model_name: "dali_preprocessing"
+      model_version: -1
+      input_map {
+        key: "DALI_INPUT_0"
+        value: "INPUT"
+      }
+      output_map {
+        key: "DALI_OUTPUT_0"
+        value: "preprocessed_image"
+      }
+    },
+    {
+      model_name: "yolo_trt"
+      model_version: -1
+      input_map {
+        key: "images"
+        value: "preprocessed_image"
+      }
+      output_map {
+        key: "output0"
+        value: "OUTPUT"
+      }
+    }
+  ]
+}
+```
+
+!!! info "How Ensemble Mapping Works"
+
+    The ensemble connects models through **virtual tensor names**. The `output_map` value `"preprocessed_image"` in the DALI step matches the `input_map` value `"preprocessed_image"` in the TensorRT step. These are arbitrary names that link one step's output to the next step's input — they don't need to match any model's internal tensor names.
+
+### Step 4: Send Inference Requests
+
+!!! info "Why `tritonclient` instead of `YOLO(\"http://...\")`?"
+
+    Ultralytics has [built-in Triton support](triton-inference-server.md#running-inference) that handles pre/postprocessing automatically. However, it won't work with the DALI ensemble because `YOLO()` sends a preprocessed float32 tensor while the ensemble expects raw JPEG bytes. Use `tritonclient` directly for DALI ensembles, and the [built-in integration](triton-inference-server.md) for standard deployments without DALI.
+
+!!! example "Send images to Triton ensemble"
+
+    ```python
+    import numpy as np
+    import tritonclient.http as httpclient
+
+    client = httpclient.InferenceServerClient(url="localhost:8000")
+
+    # Load image as raw bytes (JPEG/PNG encoded)
+    image_data = np.fromfile("image.jpg", dtype="uint8")
+    image_data = np.expand_dims(image_data, axis=0)  # Add batch dimension
+
+    # Create input
+    input_tensor = httpclient.InferInput("INPUT", image_data.shape, "UINT8")
+    input_tensor.set_data_from_numpy(image_data)
+
+    # Run inference through the ensemble
+    result = client.infer(model_name="ensemble_dali_yolo", inputs=[input_tensor])
+    detections = result.as_numpy("OUTPUT")  # Shape: (1, 300, 6) -> [x1, y1, x2, y2, conf, class_id]
+
+    # Filter by confidence (no NMS needed — YOLO26 is end-to-end)
+    detections = detections[0]  # First image
+    detections = detections[detections[:, 4] > 0.25]  # Confidence threshold
+    print(f"Detected {len(detections)} objects")
+    ```
+
+!!! tip "Batching JPEG Images"
+
+    When sending a batch of JPEG images to Triton, pad all encoded byte arrays to the same length (the maximum byte count in the batch). Triton requires homogeneous batch shapes for the input tensor.
+
+## Supported Tasks
+
+DALI preprocessing works with all YOLO tasks that use the standard `LetterBox` pipeline:
+
+| Task                                        | Supported | Notes                                                    |
+| ------------------------------------------- | --------- | -------------------------------------------------------- |
+| [Detection](../tasks/detect.md)             | ✅        | Standard letterbox preprocessing                         |
+| [Segmentation](../tasks/segment.md)         | ✅        | Same preprocessing as detection                          |
+| [Pose Estimation](../tasks/pose.md)         | ✅        | Same preprocessing as detection                          |
+| [Oriented Detection (OBB)](../tasks/obb.md) | ✅        | Same preprocessing as detection                          |
+| [Classification](../tasks/classify.md)      | ❌        | Uses torchvision transforms (center crop), not letterbox |
+
+## Limitations
+
+- **Linux only**: DALI does not support Windows or macOS
+- **NVIDIA GPU required**: No CPU-only fallback
+- **Static pipeline**: Pipeline structure is defined at build time and cannot change dynamically
+- **`fn.pad` is right/bottom only**: Use `fn.crop` with `out_of_bounds_policy="pad"` for centered padding
+- **No rect mode**: DALI pipelines produce fixed-size outputs (e.g., 640×640). The `auto=True` rect mode that produces variable-size outputs (e.g., 384×640) is not supported. Note that while [TensorRT](../integrations/tensorrt.md) does support dynamic input shapes, a fixed-size DALI pipeline pairs naturally with a fixed-size engine for maximum throughput
+- **Memory with multiple instances**: Using `instance_group` with `count` > 1 in Triton can cause high memory usage. Use the default instance group for the DALI model
+
+## FAQ
+
+### How does DALI preprocessing compare to CPU preprocessing speed?
+
+The benefit depends on your pipeline. When GPU inference is already fast with [TensorRT](../integrations/tensorrt.md), CPU preprocessing at 2-10ms can become the dominant cost. DALI eliminates this bottleneck by running preprocessing on the GPU. The biggest gains are seen with high-resolution inputs (1080p, 4K), large [batch sizes](https://www.ultralytics.com/glossary/batch-size), and systems with limited CPU cores per GPU.
+
+### Can I use DALI with PyTorch models (not just TensorRT)?
+
+Yes. Use `DALIGenericIterator` to get preprocessed `torch.Tensor` outputs, then pass them to `model.predict()`. However, the performance benefit is greatest with [TensorRT](../integrations/tensorrt.md) models where inference is already very fast and CPU preprocessing becomes the bottleneck.
+
+### What is the difference between `fn.pad` and `fn.crop` for padding?
+
+`fn.pad` adds padding only to the **right and bottom** edges. `fn.crop` with `out_of_bounds_policy="pad"` centers the image and adds padding symmetrically on all sides, matching Ultralytics `LetterBox(center=True)` behavior.
+
+### Does DALI produce pixel-identical results to CPU preprocessing?
+
+Nearly identical. Set `antialias=False` in `fn.resize` to match OpenCV's `cv2.INTER_LINEAR`. Minor floating-point differences (< 0.001) may occur due to GPU vs CPU arithmetic, but these have no measurable impact on detection [accuracy](https://www.ultralytics.com/glossary/accuracy).
+
+### What about CV-CUDA as an alternative to DALI?
+
+[CV-CUDA](https://github.com/CVCUDA/CV-CUDA) is another NVIDIA library for GPU-accelerated vision processing. It provides per-operator control (like [OpenCV](https://www.ultralytics.com/glossary/opencv) but on GPU) rather than DALI's pipeline approach. CV-CUDA's `cvcuda.copymakeborder()` supports explicit per-side padding, making centered letterbox straightforward. Choose DALI for pipeline-based workflows (especially with [Triton](triton-inference-server.md)), and CV-CUDA for fine-grained operator-level control in custom inference code.

docs/en/guides/nvidia-dgx-spark.md

@@ -143,7 +143,7 @@ pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130
 
     When running PyTorch 2.9.1 on NVIDIA DGX Spark, you may encounter the following `UserWarning` when initializing CUDA (e.g. running `yolo checks`, `yolo predict`, etc.):
 
-    ```text
+    ```
     UserWarning: Found GPU0 NVIDIA GB10 which is of cuda capability 12.1.
     Minimum and Maximum cuda capability supported by this version of PyTorch is (8.0) - (12.0)
     ```

docs/en/guides/nvidia-jetson.md

@@ -206,6 +206,16 @@ pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch
 
     Visit the [PyTorch for Jetson page](https://forums.developer.nvidia.com/t/pytorch-for-jetson/72048) to access all different versions of PyTorch for different JetPack versions. For a more detailed list on the PyTorch, Torchvision compatibility, visit the [PyTorch and Torchvision compatibility page](https://github.com/pytorch/vision).
 
+Install [`cuDSS`](https://developer.nvidia.com/cudss-downloads?target_os=Linux&target_arch=aarch64-jetson&Compilation=Native&Distribution=Ubuntu&target_version=22.04&target_type=deb_local) to fix a dependency issue with `torch 2.10.0`
+
+```bash
+wget https://developer.download.nvidia.com/compute/cudss/0.7.1/local_installers/cudss-local-tegra-repo-ubuntu2204-0.7.1_0.7.1-1_arm64.deb
+sudo dpkg -i cudss-local-tegra-repo-ubuntu2204-0.7.1_0.7.1-1_arm64.deb
+sudo cp /var/cudss-local-tegra-repo-ubuntu2204-0.7.1/cudss-*-keyring.gpg /usr/share/keyrings/
+sudo apt-get update
+sudo apt-get -y install cudss
+```
+
 #### Install `onnxruntime-gpu`
 
 The [onnxruntime-gpu](https://pypi.org/project/onnxruntime-gpu/) package hosted in PyPI does not have `aarch64` binaries for the Jetson. So we need to manually install this package. This package is needed for some of the exports.
@@ -260,11 +270,11 @@ The above ultralytics installation will install Torch and Torchvision. However,
     pip uninstall torch torchvision
     ```
 
-2. Install `torch 2.2.0` and `torchvision 0.17.2` according to JP5.1.2
+2. Install `torch 2.1.0` and `torchvision 0.16.2` according to JP5.1.2
 
     ```bash
-    pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.2.0-cp38-cp38-linux_aarch64.whl
-    pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.17.2+c1d70fe-cp38-cp38-linux_aarch64.whl
+    pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl
+    pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.16.2+c6f3977-cp38-cp38-linux_aarch64.whl
     ```
 
 !!! note
@@ -398,21 +408,21 @@ Even though all model exports work on NVIDIA Jetson, we have only included **PyT
 
 <figure style="text-align: center;">
     <img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/jetson-agx-orin-benchmarks-coco128.avif" alt="Jetson AGX Orin Benchmarks">
-    <figcaption style="font-style: italic; color: gray;">Benchmarked with Ultralytics 8.3.157</figcaption>
+    <figcaption style="font-style: italic; color: gray;">Benchmarked with Ultralytics 8.4.32</figcaption>
 </figure>
 
 #### NVIDIA Jetson Orin Nano Super Developer Kit
 
 <figure style="text-align: center;">
     <img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/jetson-orin-nano-super-benchmarks-coco128.avif" alt="Jetson Orin Nano Super Benchmarks">
-    <figcaption style="font-style: italic; color: gray;">Benchmarked with Ultralytics 8.3.157</figcaption>
+    <figcaption style="font-style: italic; color: gray;">Benchmarked with Ultralytics 8.4.33</figcaption>
 </figure>
 
 #### NVIDIA Jetson Orin NX 16GB
 
 <figure style="text-align: center;">
     <img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/jetson-orin-nx-16-benchmarks-coco128.avif" alt="Jetson Orin NX 16GB Benchmarks">
-    <figcaption style="font-style: italic; color: gray;">Benchmarked with Ultralytics 8.3.157</figcaption>
+    <figcaption style="font-style: italic; color: gray;">Benchmarked with Ultralytics 8.4.33</figcaption>
 </figure>
 
 ### Detailed Comparison Tables
@@ -513,92 +523,93 @@ The below table represents the benchmark results for five different models (YOLO
 
 !!! tip "Performance"
 
-    === "YOLO11n"
+    === "YOLO26n"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 5.4               | 0.5101      | 9.40                   |
-        | TorchScript     | ✅      | 10.5              | 0.5083      | 11.00                  |
-        | ONNX            | ✅      | 10.2              | 0.5077      | 48.32                  |
-        | OpenVINO        | ✅      | 10.4              | 0.5058      | 27.24                  |
-        | TensorRT (FP32) | ✅      | 12.1              | 0.5085      | 3.93                   |
-        | TensorRT (FP16) | ✅      | 8.3               | 0.5063      | 2.55                   |
-        | TensorRT (INT8) | ✅      | 5.4               | 0.4719      | 2.18                   |
-        | TF SavedModel   | ✅      | 25.9              | 0.5077      | 66.87                  |
-        | TF GraphDef     | ✅      | 10.3              | 0.5077      | 65.68                  |
-        | TF Lite         | ✅      | 10.3              | 0.5077      | 272.92                 |
-        | MNN             | ✅      | 10.1              | 0.5059      | 36.33                  |
-        | NCNN            | ✅      | 10.2              | 0.5031      | 28.51                  |
+        | PyTorch         | ✅      | 5.3               | 0.4790      | 11.58                  |
+        | TorchScript     | ✅      | 9.8               | 0.4770      | 4.60                   |
+        | ONNX            | ✅      | 9.5               | 0.4770      | 9.87                   |
+        | OpenVINO        | ✅      | 9.6               | 0.4820      | 28.80                  |
+        | TensorRT (FP32) | ✅      | 11.5              | 0.0450      | 4.18                   |
+        | TensorRT (FP16) | ✅      | 7.9               | 0.0450      | 2.62                   |
+        | TensorRT (INT8) | ✅      | 5.4               | 0.4640      | 2.30                   |
+        | TF SavedModel   | ✅      | 24.6              | 0.4760      | 71.10                  |
+        | TF GraphDef     | ✅      | 9.5               | 0.4760      | 70.02                  |
+        | TF Lite         | ✅      | 9.9               | 0.4760      | 227.94                 |
+        | MNN             | ✅      | 9.4               | 0.4760      | 32.46                  |
+        | NCNN            | ✅      | 9.3               | 0.4810      | 29.93                  |
 
-    === "YOLO11s"
+
+    === "YOLO26s"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 18.4              | 0.5783      | 12.10                  |
-        | TorchScript     | ✅      | 36.5              | 0.5782      | 11.01                  |
-        | ONNX            | ✅      | 36.3              | 0.5782      | 107.54                 |
-        | OpenVINO        | ✅      | 36.4              | 0.5810      | 55.03                  |
-        | TensorRT (FP32) | ✅      | 38.1              | 0.5781      | 6.52                   |
-        | TensorRT (FP16) | ✅      | 21.4              | 0.5803      | 3.65                   |
-        | TensorRT (INT8) | ✅      | 12.1              | 0.5735      | 2.81                   |
-        | TF SavedModel   | ✅      | 91.0              | 0.5782      | 132.73                 |
-        | TF GraphDef     | ✅      | 36.4              | 0.5782      | 134.96                 |
-        | TF Lite         | ✅      | 36.3              | 0.5782      | 798.21                 |
-        | MNN             | ✅      | 36.2              | 0.5777      | 82.35                  |
-        | NCNN            | ✅      | 36.2              | 0.5784      | 56.07                  |
+        | PyTorch         | ✅      | 20.0              | 0.5730      | 13.18                  |
+        | TorchScript     | ✅      | 36.8              | 0.5670      | 11.48                  |
+        | ONNX            | ✅      | 36.5              | 0.5660      | 13.47                  |
+        | OpenVINO        | ✅      | 36.7              | 0.5650      | 58.30                  |
+        | TensorRT (FP32) | ✅      | 38.5              | 0.5660      | 6.82                   |
+        | TensorRT (FP16) | ✅      | 21.9              | 0.5660      | 3.76                   |
+        | TensorRT (INT8) | ✅      | 12.5              | 0.5480      | 2.98                   |
+        | TF SavedModel   | ✅      | 92.2              | 0.5660      | 145.62                 |
+        | TF GraphDef     | ✅      | 36.5              | 0.5660      | 146.26                 |
+        | TF Lite         | ✅      | 36.9              | 0.5660      | 753.52                 |
+        | MNN             | ✅      | 36.4              | 0.5650      | 79.50                  |
+        | NCNN            | ✅      | 36.4              | 0.5700      | 58.73                  |
 
-    === "YOLO11m"
+    === "YOLO26m"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 38.8              | 0.6265      | 22.20                  |
-        | TorchScript     | ✅      | 77.3              | 0.6307      | 21.47                  |
-        | ONNX            | ✅      | 76.9              | 0.6307      | 270.89                 |
-        | OpenVINO        | ✅      | 77.1              | 0.6284      | 129.10                 |
-        | TensorRT (FP32) | ✅      | 78.8              | 0.6306      | 12.53                  |
-        | TensorRT (FP16) | ✅      | 41.9              | 0.6305      | 6.25                   |
-        | TensorRT (INT8) | ✅      | 23.2              | 0.6291      | 4.69                   |
-        | TF SavedModel   | ✅      | 192.7             | 0.6307      | 299.95                 |
-        | TF GraphDef     | ✅      | 77.1              | 0.6307      | 310.58                 |
-        | TF Lite         | ✅      | 77.0              | 0.6307      | 2400.54                |
-        | MNN             | ✅      | 76.8              | 0.6308      | 213.56                 |
-        | NCNN            | ✅      | 76.8              | 0.6284      | 141.18                 |
+        | PyTorch         | ✅      | 43.0              | 0.6220      | 19.36                  |
+        | TorchScript     | ✅      | 78.5              | 0.6230      | 20.02                  |
+        | ONNX            | ✅      | 78.2              | 0.6230      | 25.40                  |
+        | OpenVINO        | ✅      | 78.3              | 0.6190      | 130.76                 |
+        | TensorRT (FP32) | ✅      | 80.2              | 0.6220      | 12.60                  |
+        | TensorRT (FP16) | ✅      | 42.5              | 0.6220      | 6.24                   |
+        | TensorRT (INT8) | ✅      | 23.4              | 0.5820      | 4.72                   |
+        | TF SavedModel   | ✅      | 196.3             | 0.6230      | 306.76                 |
+        | TF GraphDef     | ✅      | 78.2              | 0.6230      | 314.23                 |
+        | TF Lite         | ✅      | 78.5              | 0.6230      | 2331.63                |
+        | MNN             | ✅      | 78.0              | 0.6220      | 206.93                 |
+        | NCNN            | ✅      | 78.0              | 0.6220      | 143.03                 |
 
-    === "YOLO11l"
+    === "YOLO26l"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 49.0              | 0.6364      | 27.70                   |
-        | TorchScript     | ✅      | 97.6              | 0.6399      | 27.94                  |
-        | ONNX            | ✅      | 97.0              | 0.6409      | 345.47                 |
-        | OpenVINO        | ✅      | 97.3              | 0.6378      | 161.93                 |
-        | TensorRT (FP32) | ✅      | 99.1              | 0.6406      | 16.11                  |
-        | TensorRT (FP16) | ✅      | 52.6              | 0.6376      | 8.08                   |
-        | TensorRT (INT8) | ✅      | 30.8              | 0.6208      | 6.12                   |
-        | TF SavedModel   | ✅      | 243.1             | 0.6409      | 390.78                 |
-        | TF GraphDef     | ✅      | 97.2              | 0.6409      | 398.76                 |
-        | TF Lite         | ✅      | 97.1              | 0.6409      | 3037.05                |
-        | MNN             | ✅      | 96.9              | 0.6372      | 265.46                 |
-        | NCNN            | ✅      | 96.9              | 0.6364      | 179.68                 |
+        | PyTorch         | ✅      | 51.0              | 0.6230      | 23.53                   |
+        | TorchScript     | ✅      | 95.5              | 0.6250      | 24.23                  |
+        | ONNX            | ✅      | 95.0              | 0.6250      | 31.73                  |
+        | OpenVINO        | ✅      | 95.3              | 0.6240      | 162.80                 |
+        | TensorRT (FP32) | ✅      | 97.3              | 0.6250      | 15.90                  |
+        | TensorRT (FP16) | ✅      | 51.4              | 0.6240      | 7.93                   |
+        | TensorRT (INT8) | ✅      | 29.9              | 0.5920      | 5.97                   |
+        | TF SavedModel   | ✅      | 238.4             | 0.6250      | 394.30                 |
+        | TF GraphDef     | ✅      | 95.0              | 0.6250      | 398.63                 |
+        | TF Lite         | ✅      | 95.4              | 0.6250      | 2925.27                |
+        | MNN             | ✅      | 94.8              | 0.6250      | 255.87                 |
+        | NCNN            | ✅      | 94.8              | 0.6320      | 177.70                 |
 
-    === "YOLO11x"
+    === "YOLO26x"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 109.3             | 0.7005      | 44.40                  |
-        | TorchScript     | ✅      | 218.1             | 0.6898      | 47.49                  |
-        | ONNX            | ✅      | 217.5             | 0.6900      | 682.98                 |
-        | OpenVINO        | ✅      | 217.8             | 0.6876      | 298.15                 |
-        | TensorRT (FP32) | ✅      | 219.6             | 0.6904      | 28.50                  |
-        | TensorRT (FP16) | ✅      | 112.2             | 0.6887      | 13.55                  |
-        | TensorRT (INT8) | ✅      | 60.0              | 0.6574      | 9.40                   |
-        | TF SavedModel   | ✅      | 544.3             | 0.6900      | 749.85                 |
-        | TF GraphDef     | ✅      | 217.7             | 0.6900      | 753.86                 |
-        | TF Lite         | ✅      | 217.6             | 0.6900      | 6603.27                |
-        | MNN             | ✅      | 217.3             | 0.6868      | 519.77                 |
-        | NCNN            | ✅      | 217.3             | 0.6849      | 298.58                 |
+        | PyTorch         | ✅      | 114               | 0.6610      | 38.37                  |
+        | TorchScript     | ✅      | 213.5             | 0.6590      | 41.23                  |
+        | ONNX            | ✅      | 212.9             | 0.6590      | 52.03                  |
+        | OpenVINO        | ✅      | 213.2             | 0.6590      | 300.40                 |
+        | TensorRT (FP32) | ✅      | 215.2             | 0.6590      | 28.43                  |
+        | TensorRT (FP16) | ✅      | 110.3             | 0.6570      | 13.50                  |
+        | TensorRT (INT8) | ✅      | 59.9              | 0.6080      | 9.33                   |
+        | TF SavedModel   | ✅      | 533.3             | 0.6590      | 738.60                 |
+        | TF GraphDef     | ✅      | 212.9             | 0.6590      | 785.70                 |
+        | TF Lite         | ✅      | 217.6             | 0.6900      | 6476.80                |
+        | MNN             | ✅      | 213.3             | 0.6590      | 519.77                 |
+        | NCNN            | ✅      | 212.8             | 0.6670      | 300.00                 |
 
-    Benchmarked with Ultralytics 8.3.157
+    Benchmarked with Ultralytics 8.4.32
 
     !!! note
 
@@ -608,92 +619,92 @@ The below table represents the benchmark results for five different models (YOLO
 
 !!! tip "Performance"
 
-    === "YOLO11n"
+    === "YOLO26n"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 5.4               | 0.5101      | 13.70                  |
-        | TorchScript     | ✅      | 10.5              | 0.5082      | 13.69                  |
-        | ONNX            | ✅      | 10.2              | 0.5081      | 14.47                  |
-        | OpenVINO        | ✅      | 10.4              | 0.5058      | 56.66                  |
-        | TensorRT (FP32) | ✅      | 12.0              | 0.5081      | 7.44                   |
-        | TensorRT (FP16) | ✅      | 8.2               | 0.5061      | 4.53                   |
-        | TensorRT (INT8) | ✅      | 5.4               | 0.4825      | 3.70                   |
-        | TF SavedModel   | ✅      | 25.9              | 0.5077      | 116.23                 |
-        | TF GraphDef     | ✅      | 10.3              | 0.5077      | 114.92                 |
-        | TF Lite         | ✅      | 10.3              | 0.5077      | 340.75                 |
-        | MNN             | ✅      | 10.1              | 0.5059      | 76.26                  |
-        | NCNN            | ✅      | 10.2              | 0.5031      | 45.03                  |
+        | PyTorch         | ✅      | 5.3               | 0.4790      | 15.60                  |
+        | TorchScript     | ✅      | 9.8               | 0.4770      | 12.60                  |
+        | ONNX            | ✅      | 9.5               | 0.4760      | 15.76                  |
+        | OpenVINO        | ✅      | 9.6               | 0.4820      | 56.23                  |
+        | TensorRT (FP32) | ✅      | 11.3              | 0.4770      | 7.53                   |
+        | TensorRT (FP16) | ✅      | 8.1               | 0.4800      | 4.57                   |
+        | TensorRT (INT8) | ✅      | 5.3               | 0.4490      | 3.80                   |
+        | TF SavedModel   | ✅      | 24.6              | 0.4760      | 118.33                 |
+        | TF GraphDef     | ✅      | 9.5               | 0.4760      | 116.30                 |
+        | TF Lite         | ✅      | 9.9               | 0.4760      | 286.00                 |
+        | MNN             | ✅      | 9.4               | 0.4760      | 68.77                  |
+        | NCNN            | ✅      | 9.3               | 0.4810      | 47.50                  |
 
-    === "YOLO11s"
+    === "YOLO26s"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 18.4              | 0.5790      | 20.90                  |
-        | TorchScript     | ✅      | 36.5              | 0.5781      | 21.22                  |
-        | ONNX            | ✅      | 36.3              | 0.5781      | 25.07                  |
-        | OpenVINO        | ✅      | 36.4              | 0.5810      | 122.98                 |
-        | TensorRT (FP32) | ✅      | 37.9              | 0.5783      | 13.02                  |
-        | TensorRT (FP16) | ✅      | 21.8              | 0.5779      | 6.93                   |
-        | TensorRT (INT8) | ✅      | 12.2              | 0.5735      | 5.08                   |
-        | TF SavedModel   | ✅      | 91.0              | 0.5782      | 250.65                 |
-        | TF GraphDef     | ✅      | 36.4              | 0.5782      | 252.69                 |
-        | TF Lite         | ✅      | 36.3              | 0.5782      | 998.68                 |
-        | MNN             | ✅      | 36.2              | 0.5781      | 188.01                 |
-        | NCNN            | ✅      | 36.2              | 0.5784      | 101.37                 |
+        | PyTorch         | ✅      | 20.0              | 0.5730      | 22.83                  |
+        | TorchScript     | ✅      | 36.8              | 0.5670      | 21.83                  |
+        | ONNX            | ✅      | 36.5              | 0.5664      | 26.29                  |
+        | OpenVINO        | ✅      | 36.7              | 0.5653      | 127.09                 |
+        | TensorRT (FP32) | ✅      | 38.2              | 0.5664      | 13.60                  |
+        | TensorRT (FP16) | ✅      | 21.3              | 0.5649      | 7.17                   |
+        | TensorRT (INT8) | ✅      | 12.7              | 0.5468      | 5.25                   |
+        | TF SavedModel   | ✅      | 92.2              | 0.5665      | 263.69                 |
+        | TF GraphDef     | ✅      | 36.5              | 0.5665      | 268.21                 |
+        | TF Lite         | ✅      | 36.9              | 0.5665      | 949.63                 |
+        | MNN             | ✅      | 36.4              | 0.5644      | 184.68                 |
+        | NCNN            | ✅      | 36.4              | 0.5697      | 107.48                 |
 
-    === "YOLO11m"
+    === "YOLO26m"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 38.8              | 0.6266      | 46.50                  |
-        | TorchScript     | ✅      | 77.3              | 0.6307      | 47.95                  |
-        | ONNX            | ✅      | 76.9              | 0.6307      | 53.06                  |
-        | OpenVINO        | ✅      | 77.1              | 0.6284      | 301.63                 |
-        | TensorRT (FP32) | ✅      | 78.8              | 0.6305      | 27.86                  |
-        | TensorRT (FP16) | ✅      | 41.7              | 0.6309      | 13.50                  |
-        | TensorRT (INT8) | ✅      | 23.2              | 0.6291      | 9.12                   |
-        | TF SavedModel   | ✅      | 192.7             | 0.6307      | 622.24                 |
-        | TF GraphDef     | ✅      | 77.1              | 0.6307      | 628.74                 |
-        | TF Lite         | ✅      | 77.0              | 0.6307      | 2997.93                |
-        | MNN             | ✅      | 76.8              | 0.6299      | 509.96                 |
-        | NCNN            | ✅      | 76.8              | 0.6284      | 292.99                 |
+        | PyTorch         | ✅      | 43.0              | 0.6220      | 44.43                  |
+        | TorchScript     | ✅      | 78.5              | 0.6230      | 44.00                  |
+        | ONNX            | ✅      | 78.2              | 0.6225      | 53.44                  |
+        | OpenVINO        | ✅      | 78.3              | 0.6186      | 303.26                 |
+        | TensorRT (FP32) | ✅      | 80.0              | 0.6217      | 28.19                  |
+        | TensorRT (FP16) | ✅      | 42.6              | 0.6225      | 13.59                  |
+        | TensorRT (INT8) | ✅      | 23.4              | 0.5817      | 9.30                   |
+        | TF SavedModel   | ✅      | 196.3             | 0.6229      | 636.03                 |
+        | TF GraphDef     | ✅      | 78.2              | 0.6229      | 659.57                 |
+        | TF Lite         | ✅      | 78.5              | 0.6229      | 2905.17                |
+        | MNN             | ✅      | 78.0              | 0.6168      | 500.09                 |
+        | NCNN            | ✅      | 78.0              | 0.6224      | 332.39                 |
 
-    === "YOLO11l"
+    === "YOLO26l"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 49.0              | 0.6364      | 56.50                  |
-        | TorchScript     | ✅      | 97.6              | 0.6409      | 62.51                  |
-        | ONNX            | ✅      | 97.0              | 0.6399      | 68.35                  |
-        | OpenVINO        | ✅      | 97.3              | 0.6378      | 376.03                 |
-        | TensorRT (FP32) | ✅      | 99.2              | 0.6396      | 35.59                  |
-        | TensorRT (FP16) | ✅      | 52.1              | 0.6361      | 17.48                  |
-        | TensorRT (INT8) | ✅      | 30.9              | 0.6207      | 11.87                  |
-        | TF SavedModel   | ✅      | 243.1             | 0.6409      | 807.47                 |
-        | TF GraphDef     | ✅      | 97.2              | 0.6409      | 822.88                 |
-        | TF Lite         | ✅      | 97.1              | 0.6409      | 3792.23                |
-        | MNN             | ✅      | 96.9              | 0.6372      | 631.16                 |
-        | NCNN            | ✅      | 96.9              | 0.6364      | 350.46                 |
+        | PyTorch         | ✅      | 51.0              | 0.6230      | 60.97                  |
+        | TorchScript     | ✅      | 95.5              | 0.6250      | 56.20                  |
+        | ONNX            | ✅      | 95.0              | 0.6247      | 68.12                  |
+        | OpenVINO        | ✅      | 95.3              | 0.6238      | 397.84                 |
+        | TensorRT (FP32) | ✅      | 97.1              | 0.6250      | 35.88                  |
+        | TensorRT (FP16) | ✅      | 51.4              | 0.6225      | 17.42                  |
+        | TensorRT (INT8) | ✅      | 30.0              | 0.5923      | 11.83                  |
+        | TF SavedModel   | ✅      | 238.4             | 0.6245      | 835.83                 |
+        | TF GraphDef     | ✅      | 95.0              | 0.6245      | 852.16                 |
+        | TF Lite         | ✅      | 95.4              | 0.6245      | 3650.85                |
+        | MNN             | ✅      | 94.8              | 0.6257      | 612.37                 |
+        | NCNN            | ✅      | 94.8              | 0.6323      | 405.45                 |
 
-    === "YOLO11x"
+    === "YOLO26x"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 109.3             | 0.7005      | 90.00                  |
-        | TorchScript     | ✅      | 218.1             | 0.6901      | 113.40                 |
-        | ONNX            | ✅      | 217.5             | 0.6901      | 122.94                 |
-        | OpenVINO        | ✅      | 217.8             | 0.6876      | 713.1                  |
-        | TensorRT (FP32) | ✅      | 219.5             | 0.6904      | 66.93                  |
-        | TensorRT (FP16) | ✅      | 112.2             | 0.6892      | 32.58                  |
-        | TensorRT (INT8) | ✅      | 61.5              | 0.6612      | 19.90                  |
-        | TF SavedModel   | ✅      | 544.3             | 0.6900      | 1605.4                 |
-        | TF GraphDef     | ✅      | 217.8             | 0.6900      | 2961.8                 |
-        | TF Lite         | ✅      | 217.6             | 0.6900      | 8234.86                |
-        | MNN             | ✅      | 217.3             | 0.6893      | 1254.18                |
-        | NCNN            | ✅      | 217.3             | 0.6849      | 725.50                 |
+        | PyTorch         | ✅      | 113.2             | 0.6561      | 98.44                  |
+        | TorchScript     | ✅      | 214.0             | 0.6593      | 98.0                   |
+        | ONNX            | ✅      | 212.9             | 0.6595      | 122.43                 |
+        | OpenVINO        | ✅      | 213.2             | 0.6592      | 760.72                 |
+        | TensorRT (FP32) | ✅      | 215.1             | 0.6593      | 67.17                  |
+        | TensorRT (FP16) | ✅      | 110.2             | 0.6637      | 32.60                  |
+        | TensorRT (INT8) | ✅      | 59.9              | 0.6170      | 19.99                  |
+        | TF SavedModel   | ✅      | 533.3             | 0.6593      | 1647.06                |
+        | TF GraphDef     | ✅      | 212.9             | 0.6593      | 1670.30                |
+        | TF Lite         | ✅      | 213.3             | 0.6590      | 8066.30                |
+        | MNN             | ✅      | 212.8             | 0.6600      | 1227.90                |
+        | NCNN            | ✅      | 212.8             | 0.6666      | 782.24                 |
 
-    Benchmarked with Ultralytics 8.3.157
+    Benchmarked with Ultralytics 8.4.33
 
     !!! note
 
@@ -703,92 +714,92 @@ The below table represents the benchmark results for five different models (YOLO
 
 !!! tip "Performance"
 
-    === "YOLO11n"
+    === "YOLO26n"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 5.4               | 0.5101      | 12.90                  |
-        | TorchScript     | ✅      | 10.5              | 0.5082      | 13.17                  |
-        | ONNX            | ✅      | 10.2              | 0.5081      | 15.43                  |
-        | OpenVINO        | ✅      | 10.4              | 0.5058      | 39.80                  |
-        | TensorRT (FP32) | ✅      | 11.8              | 0.5081      | 7.94                   |
-        | TensorRT (FP16) | ✅      | 8.1               | 0.5085      | 4.73                   |
-        | TensorRT (INT8) | ✅      | 5.4               | 0.4786      | 3.90                   |
-        | TF SavedModel   | ✅      | 25.9              | 0.5077      | 88.48                  |
-        | TF GraphDef     | ✅      | 10.3              | 0.5077      | 86.67                  |
-        | TF Lite         | ✅      | 10.3              | 0.5077      | 302.55                 |
-        | MNN             | ✅      | 10.1              | 0.5059      | 52.73                  |
-        | NCNN            | ✅      | 10.2              | 0.5031      | 32.04                  |
+        | PyTorch         | ✅      | 5.3               | 0.4799      | 13.90                  |
+        | TorchScript     | ✅      | 9.8               | 0.4787      | 11.60                  |
+        | ONNX            | ✅      | 9.5               | 0.4763      | 14.18                  |
+        | OpenVINO        | ✅      | 9.6               | 0.4819      | 40.19                  |
+        | TensorRT (FP32) | ✅      | 11.4              | 0.4770      | 7.01                   |
+        | TensorRT (FP16) | ✅      | 8.0               | 0.4789      | 4.13                   |
+        | TensorRT (INT8) | ✅      | 5.5               | 0.4489      | 3.49                   |
+        | TF SavedModel   | ✅      | 24.6              | 0.4764      | 92.34                  |
+        | TF GraphDef     | ✅      | 9.5               | 0.4764      | 92.06                  |
+        | TF Lite         | ✅      | 9.9               | 0.4764      | 254.43                 |
+        | MNN             | ✅      | 9.4               | 0.4760      | 48.55                  |
+        | NCNN            | ✅      | 9.3               | 0.4805      | 34.31                  |
 
-    === "YOLO11s"
+    === "YOLO26s"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 18.4              | 0.5790      | 21.70                  |
-        | TorchScript     | ✅      | 36.5              | 0.5781      | 22.71                  |
-        | ONNX            | ✅      | 36.3              | 0.5781      | 26.49                  |
-        | OpenVINO        | ✅      | 36.4              | 0.5810      | 84.73                  |
-        | TensorRT (FP32) | ✅      | 37.8              | 0.5783      | 13.77                  |
-        | TensorRT (FP16) | ✅      | 21.2              | 0.5796      | 7.31                   |
-        | TensorRT (INT8) | ✅      | 12.0              | 0.5735      | 5.33                   |
-        | TF SavedModel   | ✅      | 91.0              | 0.5782      | 185.06                 |
-        | TF GraphDef     | ✅      | 36.4              | 0.5782      | 186.45                 |
-        | TF Lite         | ✅      | 36.3              | 0.5782      | 882.58                 |
-        | MNN             | ✅      | 36.2              | 0.5775      | 126.36                 |
-        | NCNN            | ✅      | 36.2              | 0.5784      | 66.73                  |
+        | PyTorch         | ✅      | 19.5              | 0.5738      | 20.40                  |
+        | TorchScript     | ✅      | 36.8              | 0.5664      | 19.20                  |
+        | ONNX            | ✅      | 36.5              | 0.5664      | 24.35                  |
+        | OpenVINO        | ✅      | 36.7              | 0.5653      | 88.18                  |
+        | TensorRT (FP32) | ✅      | 38.5              | 0.5664      | 12.62                  |
+        | TensorRT (FP16) | ✅      | 21.5              | 0.5652      | 6.41                   |
+        | TensorRT (INT8) | ✅      | 12.6              | 0.5468      | 4.78                   |
+        | TF SavedModel   | ✅      | 92.2              | 0.5665      | 195.16                 |
+        | TF GraphDef     | ✅      | 36.5              | 0.5665      | 197.57                 |
+        | TF Lite         | ✅      | 36.9              | 0.5665      | 827.48                 |
+        | MNN             | ✅      | 36.4              | 0.5649      | 123.47                 |
+        | NCNN            | ✅      | 36.4              | 0.5697      | 74.04                  |
 
-    === "YOLO11m"
+    === "YOLO26m"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 38.8              | 0.6266      | 45.00                  |
-        | TorchScript     | ✅      | 77.3              | 0.6307      | 51.87                  |
-        | ONNX            | ✅      | 76.9              | 0.6307      | 56.00                  |
-        | OpenVINO        | ✅      | 77.1              | 0.6284      | 202.69                 |
-        | TensorRT (FP32) | ✅      | 78.7              | 0.6305      | 30.38                  |
-        | TensorRT (FP16) | ✅      | 41.8              | 0.6302      | 14.48                  |
-        | TensorRT (INT8) | ✅      | 23.2              | 0.6291      | 9.74                   |
-        | TF SavedModel   | ✅      | 192.7             | 0.6307      | 445.58                 |
-        | TF GraphDef     | ✅      | 77.1              | 0.6307      | 460.94                 |
-        | TF Lite         | ✅      | 77.0              | 0.6307      | 2653.65                |
-        | MNN             | ✅      | 76.8              | 0.6308      | 339.38                 |
-        | NCNN            | ✅      | 76.8              | 0.6284      | 187.64                 |
+        | PyTorch         | ✅      | 42.2              | 0.6237      | 38.60                  |
+        | TorchScript     | ✅      | 78.5              | 0.6227      | 40.50                  |
+        | ONNX            | ✅      | 78.2              | 0.6225      | 48.87                  |
+        | OpenVINO        | ✅      | 78.3              | 0.6186      | 205.69                 |
+        | TensorRT (FP32) | ✅      | 80.1              | 0.6217      | 24.69                  |
+        | TensorRT (FP16) | ✅      | 42.6              | 0.6225      | 11.66                  |
+        | TensorRT (INT8) | ✅      | 23.4              | 0.5817      | 8.22                   |
+        | TF SavedModel   | ✅      | 196.3             | 0.6229      | 451.48                 |
+        | TF GraphDef     | ✅      | 78.2              | 0.6229      | 460.94                 |
+        | TF Lite         | ✅      | 78.5              | 0.6229      | 2555.53                |
+        | MNN             | ✅      | 78.0              | 0.6217      | 333.33                 |
+        | NCNN            | ✅      | 78.0              | 0.6224      | 214.60                 |
 
-    === "YOLO11l"
+    === "YOLO26l"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 49.0              | 0.6364      | 56.60                  |
-        | TorchScript     | ✅      | 97.6              | 0.6409      | 66.72                  |
-        | ONNX            | ✅      | 97.0              | 0.6399      | 71.92                  |
-        | OpenVINO        | ✅      | 97.3              | 0.6378      | 254.17                 |
-        | TensorRT (FP32) | ✅      | 99.2              | 0.6406      | 38.89                  |
-        | TensorRT (FP16) | ✅      | 51.9              | 0.6363      | 18.59                  |
-        | TensorRT (INT8) | ✅      | 30.9              | 0.6207      | 12.60                  |
-        | TF SavedModel   | ✅      | 243.1             | 0.6409      | 575.98                 |
-        | TF GraphDef     | ✅      | 97.2              | 0.6409      | 583.79                 |
-        | TF Lite         | ✅      | 97.1              | 0.6409      | 3353.41                |
-        | MNN             | ✅      | 96.9              | 0.6367      | 421.33                 |
-        | NCNN            | ✅      | 96.9              | 0.6364      | 228.26                 |
+        | PyTorch         | ✅      | 50.7              | 0.6258      | 48.60                  |
+        | TorchScript     | ✅      | 95.5              | 0.6249      | 51.60                  |
+        | ONNX            | ✅      | 95.0              | 0.6247      | 61.95                  |
+        | OpenVINO        | ✅      | 95.3              | 0.6238      | 272.47                 |
+        | TensorRT (FP32) | ✅      | 97.1              | 0.6250      | 31.64                  |
+        | TensorRT (FP16) | ✅      | 51.4              | 0.6225      | 14.77                  |
+        | TensorRT (INT8) | ✅      | 30.0              | 0.5923      | 10.49                  |
+        | TF SavedModel   | ✅      | 238.4             | 0.6245      | 596.46                 |
+        | TF GraphDef     | ✅      | 95.0              | 0.6245      | 606.10                 |
+        | TF Lite         | ✅      | 95.4              | 0.6245      | 3275.55                |
+        | MNN             | ✅      | 94.8              | 0.6247      | 408.15                 |
+        | NCNN            | ✅      | 94.8              | 0.6323      | 262.99                 |
 
-    === "YOLO11x"
+    === "YOLO26x"
 
         | Format          | Status | Size on disk (MB) | mAP50-95(B) | Inference time (ms/im) |
         |-----------------|--------|-------------------|-------------|------------------------|
-        | PyTorch         | ✅      | 109.3             | 0.7005      | 98.50                  |
-        | TorchScript     | ✅      | 218.1             | 0.6901      | 123.03                 |
-        | ONNX            | ✅      | 217.5             | 0.6901      | 129.55                 |
-        | OpenVINO        | ✅      | 217.8             | 0.6876      | 483.44                 |
-        | TensorRT (FP32) | ✅      | 219.6             | 0.6904      | 75.92                  |
-        | TensorRT (FP16) | ✅      | 112.1             | 0.6885      | 35.78                  |
-        | TensorRT (INT8) | ✅      | 61.6              | 0.6592      | 21.60                  |
-        | TF SavedModel   | ✅      | 544.3             | 0.6900      | 1120.43                |
-        | TF GraphDef     | ✅      | 217.7             | 0.6900      | 1172.35                |
-        | TF Lite         | ✅      | 217.6             | 0.6900      | 7283.63                |
-        | MNN             | ✅      | 217.3             | 0.6877      | 840.16                 |
-        | NCNN            | ✅      | 217.3             | 0.6849      | 474.41                 |
+        | PyTorch         | ✅      | 113.2             | 0.6561      | 84.40                  |
+        | TorchScript     | ✅      | 213.5             | 0.6594      | 91.20                  |
+        | ONNX            | ✅      | 212.9             | 0.6595      | 109.34                 |
+        | OpenVINO        | ✅      | 213.2             | 0.6592      | 520.88                 |
+        | TensorRT (FP32) | ✅      | 215.1             | 0.6593      | 57.18                  |
+        | TensorRT (FP16) | ✅      | 109.7             | 0.6632      | 26.76                  |
+        | TensorRT (INT8) | ✅      | 60.0              | 0.6170      | 17.32                  |
+        | TF SavedModel   | ✅      | 533.3             | 0.6593      | 1170.50                |
+        | TF GraphDef     | ✅      | 212.9             | 0.6593      | 1217.87                |
+        | TF Lite         | ✅      | 213.3             | 0.6593      | 7247.11                |
+        | MNN             | ✅      | 212.8             | 0.6591      | 820.90                 |
+        | NCNN            | ✅      | 212.8             | 0.6666      | 534.30                 |
 
-    Benchmarked with Ultralytics 8.3.157
+    Benchmarked with Ultralytics 8.4.33
 
     !!! note
 

docs/en/guides/parking-management.md

@@ -109,6 +109,15 @@ Parking management with [Ultralytics YOLO26](https://github.com/ultralytics/ultr
         cv2.destroyAllWindows()  # destroy all opened windows
         ```
 
+    === "CLI"
+
+        ```bash
+        yolo solutions parking source="path/to/video.mp4" json_file="bounding_boxes.json" show=True
+        ```
+
+        !!! note
+            Create parking zone annotations first using `ParkingPtsSelection()` in Python (Step 2 above), then pass the JSON file to the CLI command.
+
 ### `ParkingManagement` Arguments
 
 Here's a table with the `ParkingManagement` arguments:

docs/en/guides/preprocessing_annotated_data.md

@@ -130,17 +130,9 @@ Common tools for visualizations include:
 - **Scatter Plots**: Helpful for exploring relationships between image features or annotations.
 - **Heatmaps**: Effective for visualizing the distribution of pixel intensities or the spatial distribution of annotated features within images.
 
-### Using Ultralytics Explorer for EDA
+### Using Ultralytics Platform for EDA
 
-!!! warning "Community Note"
-
-    As of **`ultralytics>=8.3.10`**, Ultralytics Explorer support is deprecated. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
-
-For a more advanced approach to EDA, you can use the Ultralytics Explorer tool. It offers robust capabilities for exploring computer vision datasets. By supporting semantic search, SQL queries, and vector similarity search, the tool makes it easy to analyze and understand your data. With Ultralytics Explorer, you can create [embeddings](https://www.ultralytics.com/glossary/embeddings) for your dataset to find similar images, run SQL queries for detailed analysis, and perform semantic searches, all through a user-friendly graphical interface.
-
-<p align="center">
-  <img width="100%" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/ultralytics-explorer-openai-integration.avif" alt="Overview of Ultralytics Explorer">
-</p>
+For a no-code approach to EDA, upload your dataset to [Ultralytics Platform](https://platform.ultralytics.com/). The dataset's `Charts` tab automatically generates the visualizations described above: split distribution, top class counts, image width/height histograms, and 2D heatmaps of annotation positions and image dimensions. The `Images` tab lets you browse your data in grid, compact, or table views with annotation overlays, making it easy to spot mislabeled examples or unbalanced classes without writing a single line of code.
 
 ## Reach Out and Connect
 

docs/en/guides/region-counting.md

@@ -87,6 +87,12 @@ keywords: object counting, regions, YOLO26, computer vision, Ultralytics, effici
          cv2.destroyAllWindows()  # destroy all opened windows
          ```
 
+    === "CLI"
+
+         ```bash
+         yolo solutions region source="path/to/video.mp4" show=True region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]"
+         ```
+
 !!! tip "Ultralytics Example Code"
 
       The Ultralytics region counting module is available in our [examples section](https://github.com/ultralytics/ultralytics/blob/main/examples/YOLOv8-Region-Counter/yolov8_region_counter.py). You can explore this example for code customization and modify it to suit your specific use case.

docs/en/guides/ros-quickstart.md

@@ -243,7 +243,7 @@ Using YOLO, it is possible to extract and combine information from both RGB and
 
 !!! warning "RGB-D Cameras"
 
-    When working with depth images, it is essential to ensure that the RGB and depth images are correctly aligned. RGB-D cameras, such as the [Intel RealSense](https://realsenseai.com/) series, provide synchronized RGB and depth images, making it easier to combine information from both sources. If using separate RGB and depth cameras, it is crucial to calibrate them to ensure accurate alignment.
+    When working with depth images, it is essential to ensure that the RGB and depth images are correctly aligned. RGB-D cameras, such as the [Intel RealSense](https://www.realsenseai.com/) series, provide synchronized RGB and depth images, making it easier to combine information from both sources. If using separate RGB and depth cameras, it is crucial to calibrate them to ensure accurate alignment.
 
 #### Depth Step-by-Step Usage
 

docs/en/guides/sahi-tiled-inference.md

@@ -70,15 +70,10 @@ pip install -U ultralytics sahi
 
 ### Import Modules and Download Resources
 
-Here's how to import the necessary modules and download a YOLO26 model and some test images:
+Here's how to download some test images:
 
 ```python
 from sahi.utils.file import download_from_url
-from sahi.utils.ultralytics import download_yolo26n_model
-
-# Download YOLO26 model
-model_path = "models/yolo26n.pt"
-download_yolo26n_model(model_path)
 
 # Download test images
 download_from_url(
@@ -102,7 +97,7 @@ from sahi import AutoDetectionModel
 
 detection_model = AutoDetectionModel.from_pretrained(
     model_type="ultralytics",
-    model_path=model_path,
+    model_path="yolo26n.pt",
     confidence_threshold=0.3,
     device="cpu",  # or 'cuda:0'
 )
@@ -110,17 +105,14 @@ detection_model = AutoDetectionModel.from_pretrained(
 
 ### Perform Standard Prediction
 
-Perform standard inference using an image path or a numpy image.
+Perform standard inference using an image path.
 
 ```python
 from sahi.predict import get_prediction
-from sahi.utils.cv import read_image
 
-# With an image path
 result = get_prediction("demo_data/small-vehicles1.jpeg", detection_model)
 
-# With a numpy image
-result_with_np_image = get_prediction(read_image("demo_data/small-vehicles1.jpeg"), detection_model)
+result.export_visuals(export_dir="demo_data/", hide_conf=True)
 ```
 
 ### Visualize Results
@@ -128,10 +120,13 @@ result_with_np_image = get_prediction(read_image("demo_data/small-vehicles1.jpeg
 Export and visualize the predicted bounding boxes and masks:
 
 ```python
-from IPython.display import Image
+from PIL import Image
 
-result.export_visuals(export_dir="demo_data/")
-Image("demo_data/prediction_visual.png")
+# Open the predicted image
+processed_image = Image.open("demo_data/prediction_visual.png")
+
+# Display the predicted image
+processed_image.show()
 ```
 
 ## Sliced Inference with YOLO26
@@ -139,6 +134,7 @@ Image("demo_data/prediction_visual.png")
 Perform sliced inference by specifying the slice dimensions and overlap ratios:
 
 ```python
+from PIL import Image
 from sahi.predict import get_sliced_prediction
 
 result = get_sliced_prediction(
@@ -149,6 +145,15 @@ result = get_sliced_prediction(
     overlap_height_ratio=0.2,
     overlap_width_ratio=0.2,
 )
+
+# Export results
+result.export_visuals(export_dir="demo_data/", hide_conf=True)
+
+# Open the predicted image
+processed_image = Image.open("demo_data/prediction_visual.png")
+
+# Display the predicted image
+processed_image.show()
 ```
 
 ## Handling Prediction Results
@@ -175,7 +180,7 @@ from sahi.predict import predict
 
 predict(
     model_type="ultralytics",
-    model_path="path/to/yolo26n.pt",
+    model_path="yolo26n.pt",
     model_device="cpu",  # or 'cuda:0'
     model_confidence_threshold=0.4,
     source="path/to/dir",
@@ -219,21 +224,20 @@ Integrating Ultralytics YOLO26 with SAHI (Slicing Aided Hyper Inference) for sli
 pip install -U ultralytics sahi
 ```
 
-Then, download a YOLO26 model and test images:
+Then, download test images:
 
 ```python
 from sahi.utils.file import download_from_url
-from sahi.utils.ultralytics import download_yolo26n_model
-
-# Download YOLO26 model
-model_path = "models/yolo26n.pt"
-download_yolo26n_model(model_path)
 
 # Download test images
 download_from_url(
     "https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/small-vehicles1.jpeg",
     "demo_data/small-vehicles1.jpeg",
 )
+download_from_url(
+    "https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/terrain2.png",
+    "demo_data/terrain2.png",
+)
 ```
 
 For more detailed instructions, refer to our [Sliced Inference guide](#sliced-inference-with-yolo26).
@@ -253,10 +257,13 @@ Learn more about the [benefits of sliced inference](#benefits-of-sliced-inferenc
 Yes, you can visualize prediction results when using YOLO26 with SAHI. Here's how you can export and visualize the results:
 
 ```python
-from IPython.display import Image
+from PIL import Image
 
-result.export_visuals(export_dir="demo_data/")
-Image("demo_data/prediction_visual.png")
+result.export_visuals(export_dir="demo_data/", hide_conf=True)
+
+processed_image = Image.open("demo_data/prediction_visual.png")
+
+processed_image.show()
 ```
 
 This command will save the visualized predictions to the specified directory, and you can then load the image to view it in your notebook or application. For a detailed guide, check out the [Standard Inference section](#visualize-results).

docs/en/guides/security-alarm-system.md

@@ -79,6 +79,15 @@ The Security Alarm System Project utilizing Ultralytics YOLO26 integrates advanc
         cv2.destroyAllWindows()  # destroy all opened windows
         ```
 
+    === "CLI"
+
+        ```bash
+        yolo solutions security source="path/to/video.mp4" show=True
+        ```
+
+        !!! note
+            Email alerts require the Python API to call `.authenticate()`. The CLI provides detection and visualization only.
+
 When you run the code, you will receive a single email notification if any object is detected. The notification is sent immediately, not repeatedly. You can customize the code to suit your project requirements.
 
 #### Email Received Sample

docs/en/guides/steps-of-a-cv-project.md

@@ -114,11 +114,7 @@ After splitting your data, you can perform data augmentation by applying transfo
 
 Libraries like [OpenCV](https://www.ultralytics.com/glossary/opencv), [Albumentations](../integrations/albumentations.md), and [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) offer flexible augmentation functions that you can use. Additionally, some libraries, such as Ultralytics, have [built-in augmentation settings](../modes/train.md) directly within its model training function, simplifying the process.
 
-To understand your data better, you can use tools like [Matplotlib](https://matplotlib.org/) or [Seaborn](https://seaborn.pydata.org/) to visualize the images and analyze their distribution and characteristics. Visualizing your data helps identify patterns, anomalies, and the effectiveness of your augmentation techniques. You can also use [Ultralytics Explorer](../datasets/explorer/index.md), a tool for exploring computer vision datasets with semantic search, SQL queries, and vector similarity search.
-
-<p align="center">
-  <img width="100%" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/explorer-dashboard-screenshot-1.avif" alt="The Ultralytics Explorer Tool">
-</p>
+To understand your data better, you can use tools like [Matplotlib](https://matplotlib.org/) or [Seaborn](https://seaborn.pydata.org/) to visualize the images and analyze their distribution and characteristics. Visualizing your data helps identify patterns, anomalies, and the effectiveness of your augmentation techniques. The [Ultralytics Platform](https://platform.ultralytics.com/) `Charts` tab can surface many of these insights without any code by automatically generating split distribution, class counts, image-dimension histograms, and annotation-position heatmaps for every uploaded dataset.
 
 By properly [understanding, splitting, and augmenting your data](./preprocessing_annotated_data.md), you can develop a well-trained, validated, and tested model that performs well in real-world applications.
 
@@ -164,7 +160,7 @@ Once your model has been thoroughly tested, it's time to deploy it. [Model deplo
 - **Deploying the Model:** Deploy the model by setting up APIs or endpoints and integrating it with your application.
 - **Ensuring Scalability:** Implement load balancers, auto-scaling groups, and monitoring tools to manage resources and handle increasing data and user requests.
 
-For more detailed guidance on deployment strategies and best practices, check out our [model deployment practices guide](./model-deployment-practices.md).
+For more detailed guidance on deployment strategies and best practices, check out our [model deployment practices guide](./model-deployment-practices.md). [Ultralytics Platform](https://platform.ultralytics.com) also provides managed [deployment endpoints](../platform/deploy/endpoints.md) with auto-scaling across 43 global regions, handling infrastructure setup automatically.
 
 ## Step 8: Monitoring, Maintenance, and Documentation
 

docs/en/guides/vertex-ai-deployment-with-docker.md

@@ -27,7 +27,7 @@ Before we start, you will need to create a Google Cloud Platform (GCP) project.
 ## Prerequisites
 
 1. Install [Docker](https://docs.docker.com/engine/install/) on your machine.
-2. Install the [Google Cloud SDK](https://cloud.google.com/sdk/docs/install) and [authenticate for using the gcloud CLI](https://cloud.google.com/docs/authentication/gcloud).
+2. Install the [Google Cloud SDK](https://docs.cloud.google.com/sdk/docs/install-sdk) and [authenticate for using the gcloud CLI](https://docs.cloud.google.com/docs/authentication/gcloud).
 3. It is highly recommended that you go through the [Docker Quickstart Guide for Ultralytics](https://docs.ultralytics.com/guides/docker-quickstart/), because you will need to extend one of the official Ultralytics Docker images while following this guide.
 
 ## 1. Create an inference backend with FastAPI
@@ -507,7 +507,7 @@ docker push YOUR_REGION-docker.pkg.dev/YOUR_PROJECT_ID/YOUR_REPOSITORY_NAME/IMAG
 
 Wait for the process to complete. You should now see the image in your Artifact Registry repository.
 
-For more specific instructions on how to work with images in Artifact Registry, see the Artifact Registry documentation: [Push and pull images](https://cloud.google.com/artifact-registry/docs/docker/pushing-and-pulling).
+For more specific instructions on how to work with images in Artifact Registry, see the Artifact Registry documentation: [Push and pull images](https://docs.cloud.google.com/artifact-registry/docs/docker/pushing-and-pulling).
 
 ## 4. Import your model in Vertex AI
 

docs/en/help/contributing.md

@@ -42,7 +42,7 @@ Before we can merge your pull request, you must sign our [Contributor License Ag
 
 After submitting your pull request, the CLA bot will guide you through the signing process. To sign the CLA, simply add a comment in your PR stating:
 
-```text
+```
 I have read the CLA Document and I sign the CLA
 ```
 
@@ -207,11 +207,11 @@ We highly value bug reports as they help us improve the quality and reliability
 
 Ultralytics uses the [GNU Affero General Public License v3.0 (AGPL-3.0)](https://www.ultralytics.com/legal/agpl-3-0-software-license) for its repositories. This license promotes [openness](https://en.wikipedia.org/wiki/Openness), [transparency](https://www.ultralytics.com/glossary/transparency-in-ai), and [collaborative improvement](https://en.wikipedia.org/wiki/Collaborative_software) in software development. It ensures that all users have the freedom to use, modify, and share the software, fostering a strong community of collaboration and innovation.
 
-We encourage all contributors to familiarize themselves with the terms of the [AGPL-3.0 license](https://opensource.org/license/agpl-v3) to contribute effectively and ethically to the Ultralytics open-source community.
+We encourage all contributors to familiarize themselves with the terms of the [AGPL-3.0 license](https://opensource.org/license/agpl-3.0) to contribute effectively and ethically to the Ultralytics open-source community.
 
 ## 🌍 Open-Sourcing Your YOLO Project Under AGPL-3.0
 
-Using Ultralytics YOLO models or code in your project? The [AGPL-3.0 license](https://opensource.org/license/agpl-v3) requires that your entire derivative work also be open-sourced under AGPL-3.0. This ensures modifications and larger projects built upon open-source foundations remain open.
+Using Ultralytics YOLO models or code in your project? The [AGPL-3.0 license](https://opensource.org/license/agpl-3.0) requires that your entire derivative work also be open-sourced under AGPL-3.0. This ensures modifications and larger projects built upon open-source foundations remain open.
 
 ### Why AGPL-3.0 Compliance Matters
 
@@ -230,7 +230,7 @@ Complying means making the **complete corresponding source code** of your projec
     - **Use Ultralytics Template:** Start with the [Ultralytics template repository](https://github.com/ultralytics/template) for a clean, modular setup integrating YOLO.
 
 2. **License Your Project:**
-    - Add a `LICENSE` file containing the full text of the [AGPL-3.0 license](https://opensource.org/license/agpl-v3).
+    - Add a `LICENSE` file containing the full text of the [AGPL-3.0 license](https://opensource.org/license/agpl-3.0).
     - Add a notice at the top of each source file indicating the license.
 
 3. **Publish Your Source Code:**
@@ -295,7 +295,7 @@ Contributing to Ultralytics YOLO open-source repositories improves the software,
 
 To sign the Contributor License Agreement (CLA), follow the instructions provided by the CLA bot after submitting your pull request. This process ensures that your contributions are properly licensed under the AGPL-3.0 license, maintaining the legal integrity of the open-source project. Add a comment in your pull request stating:
 
-```text
+```
 I have read the CLA Document and I sign the CLA
 ```
 

docs/en/help/security.md

@@ -9,9 +9,9 @@ At [Ultralytics](https://www.ultralytics.com/), the security of our users' data
 
 ## Snyk Scanning
 
-We utilize [Snyk](https://snyk.io/advisor/python/ultralytics) to conduct comprehensive security scans on Ultralytics repositories. Snyk's robust scanning capabilities extend beyond dependency checks; it also examines our code and Dockerfiles for various vulnerabilities. By identifying and addressing these issues proactively, we ensure a higher level of security and reliability for our users.
+We utilize [Snyk](https://security.snyk.io/package/pip/ultralytics) to conduct comprehensive security scans on Ultralytics repositories. Snyk's robust scanning capabilities extend beyond dependency checks; it also examines our code and Dockerfiles for various vulnerabilities. By identifying and addressing these issues proactively, we ensure a higher level of security and reliability for our users.
 
-[![ultralytics](https://snyk.io/advisor/python/ultralytics/badge.svg)](https://snyk.io/advisor/python/ultralytics)
+[![ultralytics](https://img.shields.io/badge/Snyk_security-monitored-8A2BE2)](https://security.snyk.io/package/pip/ultralytics)
 
 ## GitHub CodeQL Scanning
 
@@ -51,7 +51,7 @@ These tools ensure proactive identification and resolution of security issues, e
 
 ### How does Ultralytics use Snyk for security scanning?
 
-Ultralytics utilizes [Snyk](https://snyk.io/advisor/python/ultralytics) to conduct thorough security scans on its repositories. Snyk extends beyond basic dependency checks, examining the code and Dockerfiles for various vulnerabilities. By proactively identifying and resolving potential security issues, Snyk helps ensure that Ultralytics' open-source projects remain secure and reliable.
+Ultralytics utilizes [Snyk](https://security.snyk.io/package/pip/ultralytics) to conduct thorough security scans on its repositories. Snyk extends beyond basic dependency checks, examining the code and Dockerfiles for various vulnerabilities. By proactively identifying and resolving potential security issues, Snyk helps ensure that Ultralytics' open-source projects remain secure and reliable.
 
 To see the Snyk badge and learn more about its deployment, check the [Snyk Scanning section](#snyk-scanning).
 

docs/en/index.md

@@ -164,7 +164,7 @@ Explore the Ultralytics Docs, a comprehensive resource designed to help you unde
 
 Ultralytics offers two licensing options to accommodate diverse use cases:
 
-- **AGPL-3.0 License**: This [OSI-approved](https://opensource.org/license/agpl-v3) open-source license is ideal for students and enthusiasts, promoting open collaboration and knowledge sharing. See the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file for more details.
+- **AGPL-3.0 License**: This [OSI-approved](https://opensource.org/license/agpl-3.0) open-source license is ideal for students and enthusiasts, promoting open collaboration and knowledge sharing. See the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file for more details.
 - **Enterprise License**: Designed for commercial use, this license permits seamless integration of Ultralytics software and AI models into commercial goods and services, bypassing the open-source requirements of AGPL-3.0. If your scenario involves embedding our solutions into a commercial offering, reach out through [Ultralytics Licensing](https://www.ultralytics.com/license).
 
 Our licensing strategy is designed to ensure that any improvements to our open-source projects are returned to the community. We believe in open source, and our mission is to ensure that our contributions can be used and expanded in ways that benefit everyone.

docs/en/integrations/axelera.md

@@ -6,7 +6,7 @@ keywords: Axelera AI, Metis AIPU, Voyager SDK, Edge AI, YOLOv8, YOLO11, YOLO26,
 
 # Axelera AI Export and Deployment
 
-Ultralytics partners with [Axelera AI](https://www.axelera.ai/) to enable high-performance, energy-efficient inference on [Edge AI](https://www.ultralytics.com/glossary/edge-ai) devices. Export and deploy **Ultralytics YOLO models** directly to the **Metis® AIPU** using the **Voyager SDK**.
+Ultralytics partners with [Axelera AI](https://axelera.ai/) to enable high-performance, energy-efficient inference on [Edge AI](https://www.ultralytics.com/glossary/edge-ai) devices. Export and deploy **Ultralytics YOLO models** directly to the **Metis® AIPU** using the **Voyager SDK**.
 
 ![Axelera AI edge deployment ecosystem for YOLO](https://github.com/user-attachments/assets/c97a0297-390d-47df-bb13-ff1aa499f34a)
 
@@ -148,20 +148,21 @@ Export your trained YOLO models using the standard Ultralytics export command.
 
 ### Export Arguments
 
-| Argument   | Type             | Default          | Description                                                                                  |
-| :--------- | :--------------- | :--------------- | :------------------------------------------------------------------------------------------- |
-| `format`   | `str`            | `'axelera'`      | Target format for Axelera Metis AIPU hardware                                                |
-| `imgsz`    | `int` or `tuple` | `640`            | Image size for model input                                                                   |
-| `int8`     | `bool`           | `True`           | Enable [INT8 quantization](https://www.ultralytics.com/glossary/model-quantization) for AIPU |
-| `data`     | `str`            | `'coco128.yaml'` | [Dataset](https://docs.ultralytics.com/datasets/) config for quantization calibration        |
-| `fraction` | `float`          | `1.0`            | Fraction of dataset for calibration (100-400 images recommended)                             |
-| `device`   | `str`            | `None`           | Export device: GPU (`device=0`) or CPU (`device=cpu`)                                        |
+| Argument   | Type             | Default          | Description                                                                                                                             |
+| :--------- | :--------------- | :--------------- | :-------------------------------------------------------------------------------------------------------------------------------------- |
+| `format`   | `str`            | `'axelera'`      | Target format for Axelera Metis AIPU hardware.                                                                                          |
+| `imgsz`    | `int` or `tuple` | `640`            | Image size for model input.                                                                                                             |
+| `batch`    | `int`            | `1`              | Specifies export model batch inference size or the max number of images the exported model will process concurrently in `predict` mode. |
+| `int8`     | `bool`           | `True`           | Enable [INT8 quantization](https://www.ultralytics.com/glossary/model-quantization) for AIPU.                                           |
+| `data`     | `str`            | `'coco128.yaml'` | [Dataset](https://docs.ultralytics.com/datasets/) config for quantization calibration.                                                  |
+| `fraction` | `float`          | `1.0`            | Fraction of dataset for calibration (100-400 images recommended).                                                                       |
+| `device`   | `str`            | `None`           | Export device: GPU (`device=0`) or CPU (`device=cpu`).                                                                                  |
 
 For all export options, see the [Export Mode documentation](https://docs.ultralytics.com/modes/export/).
 
 ### Output Structure
 
-```text
+```
 yolo26n_axelera_model/
 ├── yolo26n.axm              # Axelera model file
 └── metadata.yaml            # Model metadata (classes, image size, etc.)

docs/en/integrations/coreml.md

@@ -117,15 +117,16 @@ Before diving into the usage instructions, be sure to check out the range of [YO
 
 ### Export Arguments
 
-| Argument | Type             | Default    | Description                                                                                                                                                                                   |
-| -------- | ---------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `format` | `str`            | `'coreml'` | Target format for the exported model, defining compatibility with various deployment environments.                                                                                            |
-| `imgsz`  | `int` or `tuple` | `640`      | Desired image size for the model input. Can be an integer for square images or a tuple `(height, width)` for specific dimensions.                                                             |
-| `half`   | `bool`           | `False`    | Enables FP16 (half-precision) quantization, reducing model size and potentially speeding up inference on supported hardware.                                                                  |
-| `int8`   | `bool`           | `False`    | Activates INT8 quantization, further compressing the model and speeding up inference with minimal [accuracy](https://www.ultralytics.com/glossary/accuracy) loss, primarily for edge devices. |
-| `nms`    | `bool`           | `False`    | Adds Non-Maximum Suppression (NMS), essential for accurate and efficient detection post-processing.                                                                                           |
-| `batch`  | `int`            | `1`        | Specifies export model batch inference size or the max number of images the exported model will process concurrently in `predict` mode.                                                       |
-| `device` | `str`            | `None`     | Specifies the device for exporting: GPU (`device=0`), CPU (`device=cpu`), MPS for Apple silicon (`device=mps`).                                                                               |
+| Argument  | Type             | Default    | Description                                                                                                                                                                                   |
+| --------- | ---------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `format`  | `str`            | `'coreml'` | Target format for the exported model, defining compatibility with various deployment environments.                                                                                            |
+| `imgsz`   | `int` or `tuple` | `640`      | Desired image size for the model input. Can be an integer for square images or a tuple `(height, width)` for specific dimensions.                                                             |
+| `dynamic` | `bool`           | `False`    | Allows dynamic input sizes, enhancing flexibility in handling varying image dimensions.                                                                                                       |
+| `half`    | `bool`           | `False`    | Enables FP16 (half-precision) quantization, reducing model size and potentially speeding up inference on supported hardware.                                                                  |
+| `int8`    | `bool`           | `False`    | Activates INT8 quantization, further compressing the model and speeding up inference with minimal [accuracy](https://www.ultralytics.com/glossary/accuracy) loss, primarily for edge devices. |
+| `nms`     | `bool`           | `False`    | Adds Non-Maximum Suppression (NMS), essential for accurate and efficient detection post-processing.                                                                                           |
+| `batch`   | `int`            | `1`        | Specifies export model batch inference size or the max number of images the exported model will process concurrently in `predict` mode.                                                       |
+| `device`  | `str`            | `None`     | Specifies the device for exporting: GPU (`device=0`), CPU (`device=cpu`), MPS for Apple silicon (`device=mps`).                                                                               |
 
 !!! tip
 

docs/en/integrations/executorch.md

@@ -80,8 +80,10 @@ Exporting YOLO26 models to ExecuTorch is straightforward:
         # Export the model to ExecuTorch format
         model.export(format="executorch")  # creates 'yolo26n_executorch_model' directory
 
+        # Load the exported ExecuTorch model
         executorch_model = YOLO("yolo26n_executorch_model")
 
+        # Run inference on a single image
         results = executorch_model.predict("https://ultralytics.com/images/bus.jpg")
         ```
 
@@ -101,16 +103,18 @@ Exporting YOLO26 models to ExecuTorch is straightforward:
 
 When exporting to ExecuTorch format, you can specify the following arguments:
 
-| Argument | Type            | Default | Description                                |
-| -------- | --------------- | ------- | ------------------------------------------ |
-| `imgsz`  | `int` or `list` | `640`   | Image size for model input (height, width) |
-| `device` | `str`           | `'cpu'` | Device to use for export (`'cpu'`)         |
+| Argument | Type             | Default        | Description                                                                                                                             |
+| -------- | ---------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `format` | `str`            | `'executorch'` | Target format for the exported model, defining compatibility with various deployment environments.                                      |
+| `imgsz`  | `int` or `tuple` | `640`          | Desired image size for the model input. Can be an integer for square images or a tuple `(height, width)` for specific dimensions.       |
+| `batch`  | `int`            | `1`            | Specifies export model batch inference size or the max number of images the exported model will process concurrently in `predict` mode. |
+| `device` | `str`            | `None`         | Specifies the device for exporting: GPU (`device=0`), CPU (`device=cpu`), MPS for Apple silicon (`device=mps`).                         |
 
 ### Output Structure
 
 The ExecuTorch export creates a directory containing the model and metadata:
 
-```text
+```
 yolo26n_executorch_model/
 ├── yolo26n.pte              # ExecuTorch model file
 └── metadata.yaml            # Model metadata (classes, image size, etc.)

docs/en/integrations/google-colab.md

@@ -103,7 +103,7 @@ If you'd like to dive deeper into Google Colab, here are a few resources to guid
 
 - **[Image Segmentation with Ultralytics YOLO26 on Google Colab](https://www.ultralytics.com/blog/image-segmentation-with-ultralytics-yolo11-on-google-colab)**: Explore how to perform image segmentation tasks using YOLO26 in the Google Colab environment, with practical examples using datasets like the Roboflow Carparts Segmentation Dataset.
 
-- **[Curated Notebooks](https://colab.google/notebooks/)**: Here you can explore a series of organized and educational notebooks, each grouped by specific topic areas.
+- **[Curated Notebooks](https://developers.google.com/colab)**: Here you can explore a series of organized and educational notebooks, each grouped by specific topic areas.
 
 - **[Google Colab's Medium Page](https://medium.com/google-colab)**: You can find tutorials, updates, and community contributions here that can help you better understand and utilize this tool.
 
@@ -130,7 +130,7 @@ Google Colab offers several advantages for training YOLO26 models:
 - **Integration with Google Drive:** Easily store and access datasets and models.
 - **Collaboration:** Share notebooks with others and collaborate in real-time.
 
-For more information on why you should use Google Colab, explore the [training guide](../modes/train.md) and visit the [Google Colab page](https://colab.google/notebooks/).
+For more information on why you should use Google Colab, explore the [training guide](../modes/train.md) and visit the [Google Colab page](https://developers.google.com/colab).
 
 ### How can I handle Google Colab session timeouts during YOLO26 training?
 

docs/en/integrations/ibm-watsonx.md

@@ -87,7 +87,7 @@ Then, you can import the needed packages.
 
 For this tutorial, we will use a [marine litter dataset](https://www.kaggle.com/datasets/atiqishrak/trash-dataset-icra19) available on Kaggle. With this dataset, we will custom-train a YOLO26 model to detect and classify litter and biological objects in underwater images.
 
-We can load the dataset directly into the notebook using the Kaggle API. First, create a free Kaggle account. Once you have created an account, you'll need to generate an API key. Directions for generating your key can be found in the [Kaggle API documentation](https://github.com/Kaggle/kaggle-api/blob/main/docs/README.md) under the section "API credentials".
+We can load the dataset directly into the notebook using the Kaggle API. First, create a free Kaggle account. Once you have created an account, you'll need to generate an API key. Directions for generating your key can be found in the [Kaggle API documentation](https://github.com/Kaggle/kaggle-cli/blob/main/docs/README.md) under the section "API credentials".
 
 Copy and paste your Kaggle username and API key into the following code. Then run the code to install the API and load the dataset into Watsonx.
 

docs/en/integrations/index.md

@@ -41,6 +41,8 @@ Welcome to the Ultralytics Integrations page! This page provides an overview of
 
 - [Kaggle](kaggle.md): Explore how you can use Kaggle to train and evaluate Ultralytics models in a cloud-based environment with pre-installed libraries, GPU support, and a vibrant community for collaboration and sharing.
 
+- [Modal](../guides/modal-quickstart.md): Run Ultralytics models on Modal's serverless cloud platform with automatic GPU provisioning, pay-per-second pricing, and seamless scaling for inference and training workloads.
+
 - [MLFlow](mlflow.md): Streamline the entire ML lifecycle of Ultralytics models, from experimentation and reproducibility to deployment.
 
 - [Neptune](neptune.md): Maintain a comprehensive log of your ML experiments with Ultralytics in this metadata store designed for MLOps.

docs/en/integrations/mlflow.md

@@ -86,7 +86,11 @@ Make sure that MLflow logging is enabled in Ultralytics settings. Usually, this
     mlflow server --backend-store-uri runs/mlflow
     ```
 
-    This will start a local server at `http://127.0.0.1:5000` by default and save all mlflow logs to the 'runs/mlflow' directory. To specify a different URI, set the `MLFLOW_TRACKING_URI` environment variable.
+    This will start a local server at `http://127.0.0.1:5000` by default and save all mlflow logs to the 'runs/mlflow' directory. To point your training runs at a different tracking server, export `MLFLOW_TRACKING_URI` before training:
+
+    ```bash
+    export MLFLOW_TRACKING_URI=http://127.0.0.1:5000
+    ```
 
 4. **Kill MLflow Server Instances**: To stop all running MLflow instances, run:
 

docs/en/integrations/neptune.md

@@ -74,7 +74,6 @@ The securest way to handle credentials is via environment variables. Note that t
     import os
 
     os.environ["NEPTUNE_API_TOKEN"] = "your_long_api_token_here"
-    os.environ["NEPTUNE_PROJECT"] = "your_workspace/your_project"
     ```
 
 ## Usage

docs/en/integrations/openvino.md

@@ -99,7 +99,7 @@ For more details about the export process, visit the [Ultralytics documentation
 1. **Performance**: OpenVINO delivers high-performance inference by utilizing the power of Intel CPUs, integrated and discrete GPUs, and FPGAs.
 2. **Support for Heterogeneous Execution**: OpenVINO provides an API to write once and deploy on any supported Intel hardware (CPU, GPU, FPGA, VPU, etc.).
 3. **Model Optimizer**: OpenVINO provides a Model Optimizer that imports, converts, and optimizes models from popular [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) frameworks such as PyTorch, [TensorFlow](https://www.ultralytics.com/glossary/tensorflow), TensorFlow Lite, Keras, ONNX, PaddlePaddle, and Caffe.
-4. **Ease of Use**: The toolkit comes with more than [80 tutorial notebooks](https://github.com/openvinotoolkit/openvino_notebooks) (including [YOLOv8 optimization](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/yolov8-optimization)) teaching different aspects of the toolkit.
+4. **Ease of Use**: The toolkit comes with more than [80 tutorial notebooks](https://github.com/openvinotoolkit/openvino_notebooks) (including [YOLO26 optimization](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/yolov26-optimization)) teaching different aspects of the toolkit.
 
 ## OpenVINO Export Structure
 
@@ -136,7 +136,7 @@ This approach is ideal for fast prototyping or deployment when you don't need fu
 
 ### Inference with OpenVINO Runtime
 
-The OpenVINO Runtime provides a unified API for inference across all supported Intel hardware. It also provides advanced capabilities like load balancing across Intel hardware and asynchronous execution. For more information on running inference, refer to the [YOLO26 notebooks](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/yolov11-optimization).
+The OpenVINO Runtime provides a unified API for inference across all supported Intel hardware. It also provides advanced capabilities like load balancing across Intel hardware and asynchronous execution. For more information on running inference, refer to the [YOLO26 notebooks](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/yolov26-optimization).
 
 Remember, you'll need the XML and BIN files as well as any application-specific settings like input size, scale factor for normalization, etc., to correctly set up and use the model with the Runtime.
 

docs/en/integrations/sony-imx500.md

@@ -44,6 +44,10 @@ Currently, you can only export models that include the following tasks to IMX500
 - [Classification](https://docs.ultralytics.com/tasks/classify/)
 - [Instance segmentation](https://docs.ultralytics.com/tasks/segment/)
 
+!!! note "Supported model variants"
+
+    IMX export is designed and benchmarked for **YOLOv8n** and **YOLO11n** (nano). Other architectures and model scales are not supported.
+
 ## Usage Examples
 
 Export an Ultralytics YOLO11 model to IMX500 format and run inference with the exported model.
@@ -185,6 +189,7 @@ Export an Ultralytics YOLO11 model to IMX500 format and run inference with the e
 | `int8`     | `bool`           | `True`         | Activates INT8 quantization, further compressing the model and speeding up inference with minimal [accuracy](https://www.ultralytics.com/glossary/accuracy) loss, primarily for edge devices.                                                                    |
 | `data`     | `str`            | `'coco8.yaml'` | Path to the [dataset](https://docs.ultralytics.com/datasets/) configuration file (default: `coco8.yaml`), essential for quantization.                                                                                                                            |
 | `fraction` | `float`          | `1.0`          | Specifies the fraction of the dataset to use for INT8 quantization calibration. Allows for calibrating on a subset of the full dataset, useful for experiments or when resources are limited. If not specified with INT8 enabled, the full dataset will be used. |
+| `nms`      | `bool`           | `False`        | Adds Non-Maximum Suppression (NMS) to the exported model. When `True`, `conf`, `iou`, and `agnostic_nms` are also accepted.                                                                                                                                      |
 | `device`   | `str`            | `None`         | Specifies the device for exporting: GPU (`device=0`), CPU (`device=cpu`).                                                                                                                                                                                        |
 
 !!! tip
@@ -204,9 +209,9 @@ The export process will create an ONNX model for quantization validation, along
         ├── dnnParams.xml
         ├── labels.txt
         ├── packerOut.zip
-        ├── yolo11n_imx.onnx
-        ├── yolo11n_imx_MemoryReport.json
-        └── yolo11n_imx.pbtxt
+        ├── model_imx.onnx
+        ├── model_imx_MemoryReport.json
+        └── model_imx.pbtxt
         ```
 
     === "Pose Estimation"
@@ -216,9 +221,9 @@ The export process will create an ONNX model for quantization validation, along
         ├── dnnParams.xml
         ├── labels.txt
         ├── packerOut.zip
-        ├── yolo11n-pose_imx.onnx
-        ├── yolo11n-pose_imx_MemoryReport.json
-        └── yolo11n-pose_imx.pbtxt
+        ├── model_imx.onnx
+        ├── model_imx_MemoryReport.json
+        └── model_imx.pbtxt
         ```
 
     === "Classification"
@@ -228,9 +233,9 @@ The export process will create an ONNX model for quantization validation, along
         ├── dnnParams.xml
         ├── labels.txt
         ├── packerOut.zip
-        ├── yolo11n-cls_imx.onnx
-        ├── yolo11n-cls_imx_MemoryReport.json
-        └── yolo11n-cls_imx.pbtxt
+        ├── model_imx.onnx
+        ├── model_imx_MemoryReport.json
+        └── model_imx.pbtxt
         ```
 
     === "Instance Segmentation"
@@ -240,9 +245,9 @@ The export process will create an ONNX model for quantization validation, along
         ├── dnnParams.xml
         ├── labels.txt
         ├── packerOut.zip
-        ├── yolo11n-seg_imx.onnx
-        ├── yolo11n-seg_imx_MemoryReport.json
-        └── yolo11n-seg_imx.pbtxt
+        ├── model_imx.onnx
+        ├── model_imx_MemoryReport.json
+        └── model_imx.pbtxt
         ```
 
 ## Using IMX500 Export in Deployment

docs/en/integrations/torchscript.md

@@ -112,6 +112,7 @@ All [Ultralytics YOLO26 models](../models/index.md) are designed to support expo
 | `format`   | `str`            | `'torchscript'` | Target format for the exported model, defining compatibility with various deployment environments.                                      |
 | `imgsz`    | `int` or `tuple` | `640`           | Desired image size for the model input. Can be an integer for square images or a tuple `(height, width)` for specific dimensions.       |
 | `dynamic`  | `bool`           | `False`         | Allows dynamic input sizes, enhancing flexibility in handling varying image dimensions.                                                 |
+| `half`     | `bool`           | `False`         | Enables FP16 (half-precision) quantization, reducing model size and potentially speeding up inference on supported hardware.            |
 | `optimize` | `bool`           | `False`         | Applies optimization for mobile devices, potentially reducing model size and improving performance.                                     |
 | `nms`      | `bool`           | `False`         | Adds Non-Maximum Suppression (NMS), essential for accurate and efficient detection post-processing.                                     |
 | `batch`    | `int`            | `1`             | Specifies export model batch inference size or the max number of images the exported model will process concurrently in `predict` mode. |

docs/en/integrations/weights-biases.md

@@ -214,7 +214,7 @@ These features help in tracking experiments, optimizing models, and collaboratin
 After running your training script with W&B integration:
 
 1. A link to your W&B dashboard will be provided in the console output.
-2. Click on the link or go to [wandb.ai](https://wandb.ai/) and log in to your account.
+2. Click on the link or go to [wandb.ai](https://wandb.ai/site) and log in to your account.
 3. Navigate to your project to view detailed metrics, visualizations, and model performance data.
 
 The dashboard offers insights into your model's training process, allowing you to analyze and improve your YOLO26 models effectively.

docs/en/models/fast-sam.md

@@ -1,7 +1,7 @@
 ---
 comments: true
 description: Discover FastSAM, a real-time CNN-based solution for segmenting any object in an image. Efficient, competitive, and ideal for various vision tasks.
-keywords: FastSAM, Fast Segment Anything Model, Ultralytics, real-time segmentation, CNN, YOLOv8-seg, object segmentation, image processing, computer vision
+keywords: FastSAM, Fast Segment Anything Model, Ultralytics, real-time segmentation, instance segmentation, FastSAM vs YOLO, FastSAM vs SAM, YOLOv8-seg, YOLO26-seg, zero-shot segmentation, object segmentation, Meta
 ---
 
 # Fast Segment Anything Model (FastSAM)
@@ -54,21 +54,22 @@ This table presents the available models with their specific pretrained weights,
 
 ## FastSAM Comparison vs YOLO
 
-Here we compare Meta's SAM 2 models, including the smallest SAM2-t variant, with Ultralytics smallest segmentation model, [YOLO11n-seg](../tasks/segment.md):
+Here we compare Meta's SAM 2 models, including the smallest SAM2-t variant, with Ultralytics segmentation models including [YOLO26n-seg](yolo26.md):
 
 | Model                                                                                          | Size<br><sup>(MB)</sup> | Parameters<br><sup>(M)</sup> | Speed (CPU)<br><sup>(ms/im)</sup> |
 | ---------------------------------------------------------------------------------------------- | ----------------------- | ---------------------------- | --------------------------------- |
-| [Meta SAM-b](sam.md)                                                                           | 375                     | 93.7                         | 49401                             |
-| [Meta SAM2-b](sam-2.md)                                                                        | 162                     | 80.8                         | 31901                             |
-| [Meta SAM2-t](sam-2.md)                                                                        | 78.1                    | 38.9                         | 25997                             |
-| [MobileSAM](mobile-sam.md)                                                                     | 40.7                    | 10.1                         | 25381                             |
-| [FastSAM-s](fast-sam.md) with YOLOv8 [backbone](https://www.ultralytics.com/glossary/backbone) | 23.7                    | 11.8                         | 55.9                              |
-| Ultralytics [YOLOv8n-seg](yolov8.md)                                                           | **6.7** (11.7x smaller) | **3.4** (11.4x less)         | **24.5** (1061x faster)           |
-| Ultralytics [YOLO11n-seg](yolo11.md)                                                           | **5.9** (13.2x smaller) | **2.9** (13.4x less)         | **30.1** (864x faster)            |
+| [Meta SAM-b](sam.md)                                                                           | 375                     | 93.7                         | 41703                             |
+| [Meta SAM2-b](sam-2.md)                                                                        | 162                     | 80.8                         | 28867                             |
+| [Meta SAM2-t](sam-2.md)                                                                        | 78.1                    | 38.9                         | 23430                             |
+| [MobileSAM](mobile-sam.md)                                                                     | 40.7                    | 10.1                         | 23802                             |
+| [FastSAM-s](fast-sam.md) with YOLOv8 [backbone](https://www.ultralytics.com/glossary/backbone) | 23.9                    | 11.8                         | 58.0                              |
+| Ultralytics [YOLOv8n-seg](yolov8.md)                                                           | **7.1** (11.0x smaller) | **3.4** (11.4x less)         | **24.8** (945x faster)            |
+| Ultralytics [YOLO11n-seg](yolo11.md)                                                           | **6.2** (12.6x smaller) | **2.9** (13.4x less)         | **24.3** (964x faster)            |
+| Ultralytics [YOLO26n-seg](yolo26.md)                                                           | **6.7** (11.7x smaller) | **2.7** (14.4x less)         | **25.2** (930x faster)            |
 
-This comparison demonstrates the substantial differences in model sizes and speeds between SAM variants and YOLO segmentation models. While SAM provides unique automatic segmentation capabilities, YOLO models, particularly YOLOv8n-seg and YOLO11n-seg, are significantly smaller, faster, and more computationally efficient.
+This comparison demonstrates the substantial differences in model sizes and speeds between SAM variants and YOLO segmentation models. While SAM provides unique automatic segmentation capabilities, YOLO models, particularly YOLOv8n-seg, YOLO11n-seg and YOLO26n-seg, are significantly smaller, faster, and more computationally efficient.
 
-Tests run on a 2025 Apple M4 Pro with 24GB of RAM using `torch==2.6.0` and `ultralytics==8.3.90`. To reproduce this test:
+SAM speeds measured with PyTorch, YOLO speeds measured with ONNX Runtime. Tests run on a 2025 Apple M4 Air with 16GB of RAM using `torch==2.10.0`, `ultralytics==8.4.31`, and `onnxruntime==1.24.4`. To reproduce this test:
 
 !!! example
 
@@ -88,10 +89,12 @@ Tests run on a 2025 Apple M4 Pro with 24GB of RAM using `torch==2.6.0` and `ultr
         model.info()
         model(ASSETS)
 
-        # Profile YOLO models
-        for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt"]:
+        # Profile YOLO models (ONNX)
+        for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt", "yolo26n-seg.pt"]:
             model = YOLO(file_name)
             model.info()
+            onnx_path = model.export(format="onnx", dynamic=True)
+            model = YOLO(onnx_path)
             model(ASSETS)
         ```
 

docs/en/models/mobile-sam.md

@@ -1,7 +1,7 @@
 ---
 comments: true
 description: Discover MobileSAM, a lightweight and fast image segmentation model for mobile and edge applications. Compare its performance with SAM and YOLO models.
-keywords: MobileSAM, image segmentation, lightweight model, fast segmentation, mobile applications, SAM, Tiny-ViT, YOLO, Ultralytics
+keywords: MobileSAM, image segmentation, lightweight segmentation, mobile segmentation, MobileSAM vs SAM, MobileSAM vs YOLO, Tiny-ViT, YOLO26-seg, edge AI segmentation, Ultralytics, Meta
 ---
 
 ![MobileSAM lightweight image segmentation model logo](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/logo2.png)
@@ -35,21 +35,22 @@ The table below outlines the available MobileSAM model, its pretrained weights,
 
 ## MobileSAM Comparison vs YOLO
 
-The following comparison highlights the differences between Meta's SAM variants, MobileSAM, and Ultralytics' smallest segmentation models, including [YOLO11n-seg](../models/yolo11.md):
+The following comparison highlights the differences between Meta's SAM variants, MobileSAM, and Ultralytics segmentation models including [YOLO26n-seg](yolo26.md):
 
 | Model                                                                           | Size<br><sup>(MB)</sup> | Parameters<br><sup>(M)</sup> | Speed (CPU)<br><sup>(ms/im)</sup> |
 | ------------------------------------------------------------------------------- | ----------------------- | ---------------------------- | --------------------------------- |
-| Meta SAM-b                                                                      | 375                     | 93.7                         | 49401                             |
-| Meta SAM2-b                                                                     | 162                     | 80.8                         | 31901                             |
-| Meta SAM2-t                                                                     | 78.1                    | 38.9                         | 25997                             |
-| MobileSAM                                                                       | 40.7                    | 10.1                         | 25381                             |
-| FastSAM-s with YOLOv8 [backbone](https://www.ultralytics.com/glossary/backbone) | 23.7                    | 11.8                         | 55.9                              |
-| Ultralytics YOLOv8n-seg                                                         | **6.7** (11.7x smaller) | **3.4** (11.4x less)         | **24.5** (1061x faster)           |
-| Ultralytics YOLO11n-seg                                                         | **5.9** (13.2x smaller) | **2.9** (13.4x less)         | **30.1** (864x faster)            |
+| Meta SAM-b                                                                      | 375                     | 93.7                         | 41703                             |
+| Meta SAM2-b                                                                     | 162                     | 80.8                         | 28867                             |
+| Meta SAM2-t                                                                     | 78.1                    | 38.9                         | 23430                             |
+| MobileSAM                                                                       | 40.7                    | 10.1                         | 23802                             |
+| FastSAM-s with YOLOv8 [backbone](https://www.ultralytics.com/glossary/backbone) | 23.9                    | 11.8                         | 58.0                              |
+| Ultralytics YOLOv8n-seg                                                         | **7.1** (11.0x smaller) | **3.4** (11.4x less)         | **24.8** (945x faster)            |
+| Ultralytics YOLO11n-seg                                                         | **6.2** (12.6x smaller) | **2.9** (13.4x less)         | **24.3** (964x faster)            |
+| Ultralytics YOLO26n-seg                                                         | **6.7** (11.7x smaller) | **2.7** (14.4x less)         | **25.2** (930x faster)            |
 
-This comparison demonstrates the substantial differences in model size and speed between SAM variants and YOLO segmentation models. While SAM models offer unique automatic segmentation capabilities, YOLO models—especially YOLOv8n-seg and YOLO11n-seg—are significantly smaller, faster, and more computationally efficient.
+This comparison demonstrates the substantial differences in model size and speed between SAM variants and YOLO segmentation models. While SAM models offer unique automatic segmentation capabilities, YOLO models—especially YOLOv8n-seg, YOLO11n-seg and YOLO26n-seg—are significantly smaller, faster, and more computationally efficient.
 
-Tests were conducted on a 2025 Apple M4 Pro with 24GB RAM using `torch==2.6.0` and `ultralytics==8.3.90`. To reproduce these results:
+SAM speeds measured with PyTorch, YOLO speeds measured with ONNX Runtime. Tests run on a 2025 Apple M4 Air with 16GB of RAM using `torch==2.10.0`, `ultralytics==8.4.31`, and `onnxruntime==1.24.4`. To reproduce these results:
 
 !!! example
 
@@ -69,10 +70,12 @@ Tests were conducted on a 2025 Apple M4 Pro with 24GB RAM using `torch==2.6.0` a
         model.info()
         model(ASSETS)
 
-        # Profile YOLO models
-        for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt"]:
+        # Profile YOLO models (ONNX)
+        for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt", "yolo26n-seg.pt"]:
             model = YOLO(file_name)
             model.info()
+            onnx_path = model.export(format="onnx", dynamic=True)
+            model = YOLO(onnx_path)
             model(ASSETS)
         ```
 
@@ -182,7 +185,7 @@ To automatically annotate your dataset with the Ultralytics framework, use the `
         ```python
         from ultralytics.data.annotator import auto_annotate
 
-        auto_annotate(data="path/to/images", det_model="yolo11x.pt", sam_model="mobile_sam.pt")
+        auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="mobile_sam.pt")
         ```
 
 {% include "macros/sam-auto-annotate.md" %}

docs/en/models/rtdetr.md

@@ -47,7 +47,7 @@ Additionally, Baidu has released RTDETRv2 in July 2024, which further improves u
 
 ## Usage Examples
 
-This example provides simple RT-DETR training and inference examples. For full documentation on these and other [modes](../modes/index.md) see the [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) and [Export](../modes/export.md) docs pages.
+This example provides simple RT-DETR training and inference examples. For full documentation on these and other [modes](../modes/index.md) see the [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) and [Export](../modes/export.md) docs pages. Models can also be trained on cloud GPUs through [Ultralytics Platform](https://platform.ultralytics.com).
 
 !!! example
 
@@ -88,6 +88,10 @@ This table presents the model types, the specific pretrained weights, the tasks
 | RT-DETR Large       | [rtdetr-l.pt](https://github.com/ultralytics/assets/releases/download/v8.4.0/rtdetr-l.pt) | [Object Detection](../tasks/detect.md) | ✅        | ✅         | ✅       | ✅     |
 | RT-DETR Extra-Large | [rtdetr-x.pt](https://github.com/ultralytics/assets/releases/download/v8.4.0/rtdetr-x.pt) | [Object Detection](../tasks/detect.md) | ✅        | ✅         | ✅       | ✅     |
 
+!!! note "Architecture-only variants"
+
+    [`rtdetr-resnet50.yaml`](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/rt-detr/rtdetr-resnet50.yaml) and [`rtdetr-resnet101.yaml`](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/rt-detr/rtdetr-resnet101.yaml) are shipped as YAML architectures only. Ultralytics releases pretrained weights only for `rtdetr-l` and `rtdetr-x`. Instantiate the ResNet variants from YAML (for example, `RTDETR("rtdetr-resnet50.yaml")`) and train or fine-tune them as needed.
+
 ## Ideal Use Cases
 
 RT-DETR is particularly well-suited for applications requiring both high accuracy and real-time performance:

docs/en/models/sam-2.md

@@ -1,7 +1,7 @@
 ---
 comments: true
 description: Discover SAM 2, the next generation of Meta's Segment Anything Model, supporting real-time promptable segmentation in both images and videos with state-of-the-art performance. Learn about its key features, datasets, and how to use it.
-keywords: SAM 2, SAM 2.1, Segment Anything, video segmentation, image segmentation, promptable segmentation, zero-shot performance, SA-V dataset, Ultralytics, real-time segmentation, AI, machine learning
+keywords: SAM 2, SAM 2.1, SAM-2, Segment Anything, video segmentation, image segmentation, promptable segmentation, zero-shot segmentation, instance segmentation, interactive segmentation, real-time segmentation, SAM 2 vs YOLO, SAM 2 vs SAM 3, SA-V dataset, Meta, Ultralytics
 ---
 
 # SAM 2: Segment Anything Model 2
@@ -14,6 +14,10 @@ keywords: SAM 2, SAM 2.1, Segment Anything, video segmentation, image segmentati
 
 SAM 2, the successor to Meta's [Segment Anything Model (SAM)](sam.md), is a cutting-edge tool designed for comprehensive object segmentation in both images and videos. It excels in handling complex visual data through a unified, promptable model architecture that supports real-time processing and zero-shot generalization.
 
+!!! tip "SAM 2 on Ultralytics Platform"
+
+    SAM 2.1 models power the smart annotation feature on [Ultralytics Platform](https://platform.ultralytics.com), enabling click-based segmentation for fast dataset labeling. See the [annotation guide](../platform/data/annotation.md) for details.
+
 ![SAM 2 Example Results](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/sa-v-dataset.avif)
 
 ## Key Features
@@ -314,23 +318,24 @@ It offers three significant enhancements:
 - **Cross-domain segmentation** leveraging memory from diverse image contexts
 - **Semi-automatic annotation** for efficient dataset creation with minimal manual intervention
 
-## SAM 2 Comparison vs YOLO
+## SAM Comparison vs YOLO
 
-Here we compare Meta's SAM 2 models, including the smallest SAM2-t variant, with Ultralytics smallest segmentation model, [YOLO11n-seg](../tasks/segment.md):
+Here we compare Meta's SAM 2 models, including the smallest SAM2-t variant, with Ultralytics segmentation models including [YOLO26n-seg](yolo26.md):
 
 | Model                                                                                          | Size<br><sup>(MB)</sup> | Parameters<br><sup>(M)</sup> | Speed (CPU)<br><sup>(ms/im)</sup> |
 | ---------------------------------------------------------------------------------------------- | ----------------------- | ---------------------------- | --------------------------------- |
-| [Meta SAM-b](sam.md)                                                                           | 375                     | 93.7                         | 49401                             |
-| Meta SAM2-b                                                                                    | 162                     | 80.8                         | 31901                             |
-| Meta SAM2-t                                                                                    | 78.1                    | 38.9                         | 25997                             |
-| [MobileSAM](mobile-sam.md)                                                                     | 40.7                    | 10.1                         | 25381                             |
-| [FastSAM-s](fast-sam.md) with YOLOv8 [backbone](https://www.ultralytics.com/glossary/backbone) | 23.7                    | 11.8                         | 55.9                              |
-| Ultralytics [YOLOv8n-seg](yolov8.md)                                                           | **6.7** (11.7x smaller) | **3.4** (11.4x less)         | **24.5** (1061x faster)           |
-| Ultralytics [YOLO11n-seg](yolo11.md)                                                           | **5.9** (13.2x smaller) | **2.9** (13.4x less)         | **30.1** (864x faster)            |
+| [Meta SAM-b](sam.md)                                                                           | 375                     | 93.7                         | 41703                             |
+| Meta SAM2-b                                                                                    | 162                     | 80.8                         | 28867                             |
+| Meta SAM2-t                                                                                    | 78.1                    | 38.9                         | 23430                             |
+| [MobileSAM](mobile-sam.md)                                                                     | 40.7                    | 10.1                         | 23802                             |
+| [FastSAM-s](fast-sam.md) with YOLOv8 [backbone](https://www.ultralytics.com/glossary/backbone) | 23.9                    | 11.8                         | 58.0                              |
+| Ultralytics [YOLOv8n-seg](yolov8.md)                                                           | **7.1** (11.0x smaller) | **3.4** (11.4x less)         | **24.8** (945x faster)            |
+| Ultralytics [YOLO11n-seg](yolo11.md)                                                           | **6.2** (12.6x smaller) | **2.9** (13.4x less)         | **24.3** (964x faster)            |
+| Ultralytics [YOLO26n-seg](yolo26.md)                                                           | **6.7** (11.7x smaller) | **2.7** (14.4x less)         | **25.2** (930x faster)            |
 
-This comparison demonstrates the substantial differences in model sizes and speeds between SAM variants and YOLO segmentation models. While SAM provides unique automatic segmentation capabilities, YOLO models, particularly YOLOv8n-seg and YOLO11n-seg, are significantly smaller, faster, and more computationally efficient.
+This comparison demonstrates the substantial differences in model sizes and speeds between SAM variants and YOLO segmentation models. While SAM provides unique automatic segmentation capabilities, YOLO models, particularly YOLOv8n-seg, YOLO11n-seg and YOLO26n-seg, are significantly smaller, faster, and more computationally efficient.
 
-Tests run on a 2025 Apple M4 Pro with 24GB of RAM using `torch==2.6.0` and `ultralytics==8.3.90`. To reproduce this test:
+SAM speeds measured with PyTorch, YOLO speeds measured with ONNX Runtime. Tests run on a 2025 Apple M4 Air with 16GB of RAM using `torch==2.10.0`, `ultralytics==8.4.31`, and `onnxruntime==1.24.4`. To reproduce this test:
 
 !!! example
 
@@ -350,10 +355,12 @@ Tests run on a 2025 Apple M4 Pro with 24GB of RAM using `torch==2.6.0` and `ultr
         model.info()
         model(ASSETS)
 
-        # Profile YOLO models
-        for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt"]:
+        # Profile YOLO models (ONNX)
+        for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt", "yolo26n-seg.pt"]:
             model = YOLO(file_name)
             model.info()
+            onnx_path = model.export(format="onnx", dynamic=True)
+            model = YOLO(onnx_path)
             model(ASSETS)
         ```
 
@@ -381,7 +388,7 @@ To auto-annotate your dataset using SAM 2, follow this example:
     ```python
     from ultralytics.data.annotator import auto_annotate
 
-    auto_annotate(data="path/to/images", det_model="yolo11x.pt", sam_model="sam2_b.pt")
+    auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam2_b.pt")
     ```
 
 {% include "macros/sam-auto-annotate.md" %}
@@ -478,6 +485,6 @@ SAM 2 includes a sophisticated memory mechanism to manage temporal dependencies
 
 This mechanism ensures continuity even when objects are temporarily obscured or exit and re-enter the scene. For more details, refer to the [Memory Mechanism and Occlusion Handling](#memory-mechanism-and-occlusion-handling) section.
 
-### How does SAM 2 compare to other segmentation models like YOLO11?
+### How does SAM 2 compare to other segmentation models like YOLO26?
 
-SAM 2 models, such as Meta's SAM2-t and SAM2-b, offer powerful zero-shot segmentation capabilities but are significantly larger and slower compared to YOLO11 models. For instance, YOLO11n-seg is approximately **13 times smaller** and over **860 times faster** than SAM2-b. While SAM 2 excels in versatile, prompt-based, and zero-shot segmentation scenarios, YOLO11 is optimized for speed, efficiency, and real-time applications, making it better suited for deployment in resource-constrained environments.
+SAM 2 models, such as Meta's SAM2-t and SAM2-b, offer powerful zero-shot segmentation capabilities but are significantly larger and slower compared to YOLO models. For instance, [YOLO26n-seg](yolo26.md) is approximately **24 times smaller** and over **1145 times faster** than SAM2-b on CPU. While SAM 2 excels in versatile, prompt-based, and zero-shot segmentation scenarios, YOLO26 is optimized for speed, efficiency, and real-time applications with NMS-free end-to-end inference, making it better suited for deployment in resource-constrained environments.

docs/en/models/sam-3.md

@@ -1,7 +1,7 @@
 ---
 comments: true
 description: Discover SAM 3, Meta's next evolution of the Segment Anything Model, introducing Promptable Concept Segmentation with text and image exemplar prompts for detecting all instances of visual concepts across images and videos.
-keywords: SAM 3, Segment Anything 3, SAM3, SAM-3, video segmentation, image segmentation, concept segmentation, promptable AI, SA-Co dataset, Meta, Ultralytics, computer vision, AI, machine learning, open vocabulary
+keywords: SAM 3, Segment Anything 3, SAM3, SAM-3, concept segmentation, text prompt segmentation, open-vocabulary segmentation, zero-shot segmentation, instance segmentation, real-time segmentation, video segmentation, image segmentation, SAM 3 vs YOLO, SAM 3 vs SAM 2, SA-Co dataset, Meta, Ultralytics
 ---
 
 # SAM 3: Segment Anything with Concepts
@@ -403,41 +403,43 @@ SAM 3 provides accurate counting by segmenting all instances, a common requireme
 
 ## SAM 3 vs SAM 2 vs YOLO Comparison
 
-Here we compare SAM 3's capabilities with SAM 2 and [YOLO11](../models/yolo11.md) models:
+Here we compare SAM 3's capabilities with [SAM 2](./sam-2.md) and [YOLO26](./yolo26.md) models:
 
-| Capability                   | SAM 3                                 | SAM 2                | YOLO11n-seg        |
-| ---------------------------- | ------------------------------------- | -------------------- | ------------------ |
-| **Concept Segmentation**     | ✅ All instances from text/exemplars  | ❌ Not supported     | ❌ Not supported   |
-| **Visual Segmentation**      | ✅ Single instance (SAM 2 compatible) | ✅ Single instance   | ✅ All instances   |
-| **Zero-shot Capability**     | ✅ Open vocabulary                    | ✅ Geometric prompts | ❌ Closed set      |
-| **Interactive Refinement**   | ✅ Exemplars + clicks                 | ✅ Clicks only       | ❌ Not supported   |
-| **Video Tracking**           | ✅ Multi-object with identities       | ✅ Multi-object      | ✅ Multi-object    |
-| **LVIS Mask AP (zero-shot)** | **47.0**                              | N/A                  | N/A                |
-| **MOSEv2 J&F**               | **60.1**                              | 47.9                 | N/A                |
-| **Inference Speed (H200)**   | **30 ms** (100+ objects)              | ~23 ms (per object)  | **2-3 ms** (image) |
-| **Model Size**               | 3.4GB                                 | 162 MB (base)        | **5.9 MB**         |
+| Capability                   | SAM 3                                 | SAM 2                | YOLO26n-seg      |
+| ---------------------------- | ------------------------------------- | -------------------- | ---------------- |
+| **Concept Segmentation**     | ✅ All instances from text/exemplars  | ❌ Not supported     | ❌ Not supported |
+| **Visual Segmentation**      | ✅ Single instance (SAM 2 compatible) | ✅ Single instance   | ✅ All instances |
+| **Zero-shot Capability**     | ✅ Open vocabulary                    | ✅ Geometric prompts | ❌ Closed set    |
+| **Interactive Refinement**   | ✅ Exemplars + clicks                 | ✅ Clicks only       | ❌ Not supported |
+| **Video Tracking**           | ✅ Multi-object with identities       | ✅ Multi-object      | ✅ Multi-object  |
+| **LVIS Mask AP (zero-shot)** | **47.0**                              | N/A                  | N/A              |
+| **MOSEv2 J&F**               | **60.1**                              | 47.9                 | N/A              |
+| **Speed (GPU, ms/im)**       | 2921                                  | 857                  | **8.4**          |
+| **Model Size**               | 3.45 GB                               | 162 MB (base)        | **6.4 MB**       |
+
+Speed benchmarked on NVIDIA RTX PRO 6000 with `torch==2.9.1` and `ultralytics==8.4.19`.
 
 **Key Takeaways**:
 
 - **SAM 3**: Best for open-vocabulary concept segmentation, finding all instances of a concept with text or exemplar prompts
 - **SAM 2**: Best for interactive single-object segmentation in images and videos with geometric prompts
-- **YOLO11**: Best for real-time, high-speed segmentation in resource-constrained deployments using efficient [export pipelines](../modes/export.md) like [ONNX](../integrations/onnx.md) and [TensorRT](../integrations/tensorrt.md)
+- **YOLO26**: Best for real-time, high-speed segmentation with NMS-free end-to-end inference, [exportable to many formats](../modes/export.md#export-formats) for deployment on GPUs, CPUs, and edge devices
 
-## SAM 3 Comparison vs YOLO
+## SAM Comparison vs YOLO
 
-Here we compare Meta's SAM 2 models, including the smallest SAM2-t variant, with Ultralytics smallest segmentation model, [YOLO11n-seg](../tasks/segment.md):
+Comparing SAM 3, SAM 2, SAM, MobileSAM, and FastSAM against Ultralytics YOLO segmentation models (YOLOv8, YOLO11, YOLO26) in size, parameters, and GPU inference speed:
 
 | Model                                                                                          | Size<br><sup>(MB)</sup> | Parameters<br><sup>(M)</sup> | Speed (GPU)<br><sup>(ms/im)</sup> |
 | ---------------------------------------------------------------------------------------------- | ----------------------- | ---------------------------- | --------------------------------- |
 | [Meta SAM-b](sam.md)                                                                           | 375                     | 93.7                         | 1306                              |
 | [Meta SAM2-b](sam-2.md)                                                                        | 162                     | 80.8                         | 857                               |
 | [Meta SAM2-t](sam-2.md)                                                                        | 78.1                    | 38.9                         | 668                               |
-| Meta SAM3                                                                                      | 3200                    | 473.6                        | 2921                              |
+| Meta SAM3                                                                                      | 3450                    | 473.6                        | 2921                              |
 | [MobileSAM](mobile-sam.md)                                                                     | 40.7                    | 10.1                         | 605                               |
 | [FastSAM-s](fast-sam.md) with YOLOv8 [backbone](https://www.ultralytics.com/glossary/backbone) | 23.7                    | 11.8                         | 55.9                              |
-| Ultralytics [YOLOv8n-seg](yolov8.md)                                                           | **6.7** (477x smaller)  | **3.4** (139.1x less)        | **17.4** (167x faster)            |
-| Ultralytics [YOLO11n-seg](yolo11.md)                                                           | **5.9** (542x smaller)  | **2.9** (163.1x less)        | **12.6** (231x faster)            |
-| Ultralytics [YOLO26n-seg](yolo26.md)                                                           | **6.4** (500x smaller)  | **2.7** (175.2x less)        | **8.4** (347x faster)             |
+| Ultralytics [YOLOv8n-seg](yolov8.md)                                                           | **6.7** (515x smaller)  | **3.4** (139.1x less)        | **17.4** (167x faster)            |
+| Ultralytics [YOLO11n-seg](yolo11.md)                                                           | **5.9** (585x smaller)  | **2.9** (163.1x less)        | **12.6** (231x faster)            |
+| Ultralytics [YOLO26n-seg](yolo26.md)                                                           | **6.4** (539x smaller)  | **2.7** (175.2x less)        | **8.4** (347x faster)             |
 
 This comparison demonstrates the substantial differences in model sizes and speeds between SAM variants and YOLO segmentation models. While SAM provides unique automatic segmentation capabilities, YOLO models, particularly YOLOv8n-seg, YOLO11n-seg and YOLO26n-seg, are significantly smaller, faster, and more computationally efficient.
 
@@ -593,7 +595,7 @@ SAM 3 was released by Meta on **November 20th, 2025** and is fully integrated in
 
 ### Is SAM 3 Integrated Into Ultralytics?
 
-Yes! SAM 3 is fully integrated into the Ultralytics Python package, including concept segmentation, SAM 2–style visual prompts, and multi-object video tracking.
+Yes! SAM 3 is fully integrated into the Ultralytics Python package, including concept segmentation, SAM 2–style visual prompts, and multi-object video tracking. SAM 3 also powers the [smart annotation](../platform/data/annotation.md) feature on [Ultralytics Platform](https://platform.ultralytics.com), where you can annotate images with just a few clicks.
 
 ### What Is Promptable Concept Segmentation (PCS)?
 
@@ -638,9 +640,9 @@ SAM 3 is trained on the **Segment Anything with Concepts (SA-Co)** dataset:
 
 This massive scale and diversity enables SAM 3's superior zero-shot generalization across open-vocabulary concepts.
 
-### How does SAM 3 compare to YOLO11 for segmentation?
+### How does SAM 3 compare to YOLO26 for segmentation?
 
-SAM 3 and YOLO11 serve different use cases:
+SAM 3 and YOLO26 serve different use cases:
 
 **SAM 3 Advantages**:
 
@@ -650,17 +652,17 @@ SAM 3 and YOLO11 serve different use cases:
 - **Concept-based**: Automatically finds all instances of a category
 - **Accuracy**: 47.0 AP on LVIS zero-shot instance segmentation
 
-**YOLO11 Advantages**:
+**YOLO26 Advantages**:
 
-- **Speed**: 10-15× faster inference (2-3ms vs 30ms per image)
-- **Efficiency**: 576× smaller models (5.9MB vs 3.4GB)
+- **Speed**: Orders of magnitude faster inference with NMS-free end-to-end design
+- **Efficiency**: 539× smaller models (6.4MB vs 3.45GB)
 - **Resource-friendly**: Runs on edge devices and mobile
 - **Real-time**: Optimized for production deployments
 
 **Recommendation**:
 
 - Use **SAM 3** for flexible, open-vocabulary segmentation where you need to find all instances of concepts described by text or examples
-- Use **YOLO11** for high-speed, production deployments where categories are known in advance
+- Use **YOLO26** for high-speed, production deployments where categories are known in advance
 - Use **SAM 2** for interactive single-object segmentation with geometric prompts
 
 ### Can SAM 3 handle complex language queries?

docs/en/models/sam.md

@@ -1,7 +1,7 @@
 ---
 comments: true
 description: Explore the revolutionary Segment Anything Model (SAM) for promptable image segmentation with zero-shot performance. Discover key features, datasets, and usage tips.
-keywords: Segment Anything, SAM, image segmentation, promptable segmentation, zero-shot performance, SA-1B dataset, advanced architecture, auto-annotation, Ultralytics, pretrained models, instance segmentation, computer vision, AI, machine learning
+keywords: Segment Anything, SAM, SAM-1, image segmentation, promptable segmentation, zero-shot segmentation, instance segmentation, auto-annotation, SAM vs YOLO, SAM vs SAM 2, SA-1B dataset, Meta, Ultralytics
 ---
 
 # Segment Anything Model (SAM)
@@ -31,6 +31,10 @@ SAM's advanced design allows it to adapt to new image distributions and tasks wi
 
 For an in-depth look at the Segment Anything Model and the SA-1B dataset, please visit the [Segment Anything GitHub](https://github.com/facebookresearch/segment-anything) and check out the research paper [Segment Anything](https://arxiv.org/abs/2304.02643).
 
+!!! tip "SAM on Ultralytics Platform"
+
+    SAM powers the smart annotation feature on [Ultralytics Platform](https://platform.ultralytics.com), enabling click-based intelligent masking for fast dataset labeling. See the [annotation guide](../platform/data/annotation.md) for details.
+
 ## Available Models, Supported Tasks, and Operating Modes
 
 This table presents the available models with their specific pretrained weights, the tasks they support, and their compatibility with different operating modes like [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md), indicated by ✅ emojis for supported modes and ❌ emojis for unsupported modes.
@@ -159,19 +163,20 @@ The Segment Anything Model can be employed for a multitude of downstream tasks t
 
 ## SAM Comparison vs YOLO
 
-Here we compare Meta's SAM-b model with Ultralytics smallest segmentation model, [YOLO11n-seg](../tasks/segment.md):
+Here we compare Meta's SAM-b model with Ultralytics segmentation models including [YOLO26n-seg](yolo26.md):
 
 | Model                                                                                          | Size<br><sup>(MB)</sup> | Parameters<br><sup>(M)</sup> | Speed (CPU)<br><sup>(ms/im)</sup> |
 | ---------------------------------------------------------------------------------------------- | ----------------------- | ---------------------------- | --------------------------------- |
-| [Meta SAM-b](sam.md)                                                                           | 375                     | 93.7                         | 49401                             |
-| [MobileSAM](mobile-sam.md)                                                                     | 40.7                    | 10.1                         | 25381                             |
-| [FastSAM-s](fast-sam.md) with YOLOv8 [backbone](https://www.ultralytics.com/glossary/backbone) | 23.7                    | 11.8                         | 55.9                              |
-| Ultralytics [YOLOv8n-seg](yolov8.md)                                                           | **6.7** (11.7x smaller) | **3.4** (11.4x less)         | **24.5** (1061x faster)           |
-| Ultralytics [YOLO11n-seg](yolo11.md)                                                           | **5.9** (13.2x smaller) | **2.9** (13.4x less)         | **30.1** (864x faster)            |
+| [Meta SAM-b](sam.md)                                                                           | 375                     | 93.7                         | 41703                             |
+| [MobileSAM](mobile-sam.md)                                                                     | 40.7                    | 10.1                         | 23802                             |
+| [FastSAM-s](fast-sam.md) with YOLOv8 [backbone](https://www.ultralytics.com/glossary/backbone) | 23.9                    | 11.8                         | 58.0                              |
+| Ultralytics [YOLOv8n-seg](yolov8.md)                                                           | **7.1** (52.8x smaller) | **3.4** (27.6x less)         | **24.8** (1682x faster)           |
+| Ultralytics [YOLO11n-seg](yolo11.md)                                                           | **6.2** (60.5x smaller) | **2.9** (32.3x less)         | **24.3** (1716x faster)           |
+| Ultralytics [YOLO26n-seg](yolo26.md)                                                           | **6.7** (56.0x smaller) | **2.7** (34.7x less)         | **25.2** (1655x faster)           |
 
-This comparison demonstrates the substantial differences in model sizes and speeds between SAM variants and YOLO segmentation models. While SAM provides unique automatic segmentation capabilities, YOLO models, particularly YOLOv8n-seg and YOLO11n-seg, are significantly smaller, faster, and more computationally efficient.
+This comparison demonstrates the substantial differences in model sizes and speeds between SAM variants and YOLO segmentation models. While SAM provides unique automatic segmentation capabilities, YOLO models, particularly YOLOv8n-seg, YOLO11n-seg and YOLO26n-seg, are significantly smaller, faster, and more computationally efficient.
 
-Tests run on a 2025 Apple M4 Pro with 24GB of RAM using `torch==2.6.0` and `ultralytics==8.3.90`. To reproduce this test:
+SAM speeds measured with PyTorch, YOLO speeds measured with ONNX Runtime. Tests run on a 2025 Apple M4 Air with 16GB of RAM using `torch==2.10.0`, `ultralytics==8.4.31`, and `onnxruntime==1.24.4`. To reproduce this test:
 
 !!! example
 
@@ -180,8 +185,8 @@ Tests run on a 2025 Apple M4 Pro with 24GB of RAM using `torch==2.6.0` and `ultr
         ```python
         from ultralytics import ASSETS, SAM, YOLO, FastSAM
 
-        # Profile SAM2-t, SAM2-b, SAM-b, MobileSAM
-        for file in ["sam_b.pt", "sam2_b.pt", "sam2_t.pt", "mobile_sam.pt"]:
+        # Profile SAM-b, MobileSAM
+        for file in ["sam_b.pt", "mobile_sam.pt"]:
             model = SAM(file)
             model.info()
             model(ASSETS)
@@ -191,10 +196,12 @@ Tests run on a 2025 Apple M4 Pro with 24GB of RAM using `torch==2.6.0` and `ultr
         model.info()
         model(ASSETS)
 
-        # Profile YOLO models
-        for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt"]:
+        # Profile YOLO models (ONNX)
+        for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt", "yolo26n-seg.pt"]:
             model = YOLO(file_name)
             model.info()
+            onnx_path = model.export(format="onnx", dynamic=True)
+            model = YOLO(onnx_path)
             model(ASSETS)
         ```
 
@@ -285,7 +292,7 @@ For more detailed usage instructions, visit the [Segmentation section](#sam-pred
 
 ### How do SAM and YOLO models compare in terms of performance?
 
-Compared to YOLO models, SAM variants like SAM-b, SAM2-t, MobileSAM, and FastSAM-s are typically larger and slower but offer unique zero-shot segmentation capabilities. For example, Ultralytics [YOLOv8n-seg](../tasks/segment.md) is **11.7x smaller** and **1069x faster** than Meta's original SAM-b model, highlighting YOLO's significant advantage in speed and efficiency. Similarly, the newer [YOLO11n-seg](../tasks/segment.md) provides even smaller size and maintains impressive inference speed. This makes YOLO models ideal for applications requiring rapid, lightweight, and computationally efficient segmentation, while SAM models excel in flexible, promptable, and zero-shot segmentation tasks.
+Compared to YOLO models, SAM variants like SAM-b, MobileSAM, and FastSAM-s are typically larger and slower but offer unique zero-shot segmentation capabilities. For example, [YOLO26n-seg](yolo26.md) is **56x smaller** and over **1650x faster** than Meta's original SAM-b model on CPU. This makes YOLO models ideal for applications requiring rapid, lightweight, and computationally efficient segmentation, while SAM models excel in flexible, promptable, and zero-shot segmentation tasks.
 
 ### How can I auto-annotate my dataset using SAM?
 
@@ -294,7 +301,7 @@ Ultralytics' SAM offers an auto-annotation feature that allows generating segmen
 ```python
 from ultralytics.data.annotator import auto_annotate
 
-auto_annotate(data="path/to/images", det_model="yolov8x.pt", sam_model="sam_b.pt")
+auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")
 ```
 
 This function takes the path to your images and optional arguments for pretrained detection and SAM segmentation models, along with device and output directory specifications. For a complete guide, see [Auto-Annotation](#auto-annotation-a-quick-path-to-segmentation-datasets).

docs/en/models/yolo12.md

@@ -48,13 +48,19 @@ YOLO12, released in early 2025, introduces an attention-centric architecture tha
 
 YOLO12 supports a variety of computer vision tasks. The table below shows task support and the operational modes (Inference, Validation, Training, and Export) enabled for each:
 
-| Model Type                                                                                                     | Task                                   | Inference | Validation | Training | Export |
-| -------------------------------------------------------------------------------------------------------------- | -------------------------------------- | --------- | ---------- | -------- | ------ |
-| [YOLO12](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12.yaml)           | [Detection](../tasks/detect.md)        | ✅        | ✅         | ✅       | ✅     |
-| [YOLO12-seg](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12-seg.yaml)   | [Segmentation](../tasks/segment.md)    | ✅        | ✅         | ✅       | ✅     |
-| [YOLO12-pose](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12-pose.yaml) | [Pose](../tasks/pose.md)               | ✅        | ✅         | ✅       | ✅     |
-| [YOLO12-cls](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12-cls.yaml)   | [Classification](../tasks/classify.md) | ✅        | ✅         | ✅       | ✅     |
-| [YOLO12-obb](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12-obb.yaml)   | [OBB](../tasks/obb.md)                 | ✅        | ✅         | ✅       | ✅     |
+!!! warning "Pretrained weights availability"
+
+    Only detection weights (`yolo12n.pt`, `yolo12s.pt`, `yolo12m.pt`, `yolo12l.pt`, `yolo12x.pt`) are released on [ultralytics/assets](https://github.com/ultralytics/assets/releases). Segmentation, classification, pose, and OBB architectures are defined in [ultralytics/cfg/models/12/](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/12), so those variants support training from scratch from the `.yaml` config, but no pretrained `.pt` files are currently available for them. For pretrained segmentation, pose, classification, or OBB checkpoints, Ultralytics recommends [YOLO11](yolo11.md) or [YOLO26](yolo26.md).
+
+| Model Type                                                                                                     | Task                                   | Pretrained Weights | Inference | Validation | Training | Export |
+| -------------------------------------------------------------------------------------------------------------- | -------------------------------------- | ------------------ | --------- | ---------- | -------- | ------ |
+| [YOLO12](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12.yaml)           | [Detection](../tasks/detect.md)        | ✅                 | ✅        | ✅         | ✅       | ✅     |
+| [YOLO12-seg](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12-seg.yaml)   | [Segmentation](../tasks/segment.md)    | ❌                 | ✅        | ✅         | ✅       | ✅     |
+| [YOLO12-pose](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12-pose.yaml) | [Pose](../tasks/pose.md)               | ❌                 | ✅        | ✅         | ✅       | ✅     |
+| [YOLO12-cls](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12-cls.yaml)   | [Classification](../tasks/classify.md) | ❌                 | ✅        | ✅         | ✅       | ✅     |
+| [YOLO12-obb](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/12/yolo12-obb.yaml)   | [OBB](../tasks/obb.md)                 | ❌                 | ✅        | ✅         | ✅       | ✅     |
+
+All YOLO12 architectures support every mode once a trained checkpoint is available. The `Pretrained Weights` column indicates only whether Ultralytics publishes an official pretrained `.pt` on [ultralytics/assets](https://github.com/ultralytics/assets/releases): for segmentation, pose, classification, and OBB, you must train your own checkpoint from the corresponding `.yaml` before running inference, validation, or export.
 
 ## Performance Metrics
 
@@ -173,7 +179,7 @@ YOLO12 incorporates several key innovations to balance speed and accuracy. The A
 
 ### What [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) tasks does YOLO12 support?
 
-YOLO12 is a versatile model that supports a wide range of core computer vision tasks. It excels in object [detection](../tasks/detect.md), instance [segmentation](../tasks/segment.md), image [classification](../tasks/classify.md), [pose estimation](../tasks/pose.md), and oriented object detection (OBB) ([see details](../tasks/obb.md)). This comprehensive task support makes YOLO12 a powerful tool for diverse applications, from [robotics](https://www.ultralytics.com/glossary/robotics) and autonomous driving to medical imaging and industrial inspection. Each of these tasks can be performed in Inference, Validation, Training, and Export modes.
+YOLO12 is a versatile model that supports a wide range of core computer vision tasks. It excels in object [detection](../tasks/detect.md), instance [segmentation](../tasks/segment.md), image [classification](../tasks/classify.md), [pose estimation](../tasks/pose.md), and oriented object detection (OBB) ([see details](../tasks/obb.md)). This comprehensive task support makes YOLO12 a powerful tool for diverse applications, from [robotics](https://www.ultralytics.com/glossary/robotics) and autonomous driving to medical imaging and industrial inspection. Note that pretrained `.pt` weights are currently published for detection only; the segmentation, pose, classification, and OBB architectures are provided as `.yaml` configs for training from scratch.
 
 ### How does YOLO12 compare to other YOLO models and competitors like RT-DETR?
 

docs/en/models/yolo26.md

@@ -69,6 +69,10 @@ YOLO26 builds upon the versatile model range established by earlier Ultralytics
 
 This unified framework ensures YOLO26 is applicable across real-time detection, segmentation, classification, pose estimation, and oriented object detection — all with training, validation, inference, and export support.
 
+!!! note "Architecture-only variants"
+
+    [`yolo26-p2.yaml`](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/26/yolo26-p2.yaml) and [`yolo26-p6.yaml`](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/26/yolo26-p6.yaml) add a P2 (small-object) or P6 (large-input) detection head and are shipped as YAML architectures only. No scale-specific `yolo26*-p2.pt` or `yolo26*-p6.pt` weights are released. Instantiate a scaled config from YAML (for example, `YOLO("yolo26n-p6.yaml")`) and train or fine-tune it as needed.
+
 ---
 
 ## Performance Metrics

docs/en/models/yolov10.md

@@ -153,7 +153,7 @@ _Params and FLOPs values are for the fused model after `model.fuse()`, which mer
 
 ## Usage Examples
 
-For predicting new images with YOLOv10:
+For predicting new images with YOLOv10. Models can also be trained on cloud GPUs through [Ultralytics Platform](https://platform.ultralytics.com):
 
 !!! example
 

docs/en/models/yolov4.md

@@ -32,7 +32,7 @@ When compared to other models in the YOLO family, such as [YOLOv5](https://docs.
 
 ## Usage Examples
 
-As of the time of writing, Ultralytics does not currently support YOLOv4 models. Therefore, any users interested in using YOLOv4 will need to refer directly to the YOLOv4 GitHub repository for installation and usage instructions.
+YOLOv4 is a Darknet-based model and is **not natively supported** by the Ultralytics Python package: there are no `yolov4.pt` pretrained weights published on [ultralytics/assets](https://github.com/ultralytics/assets/releases) and no `ultralytics/cfg/models/v4/` YAMLs. This page is kept as an architectural reference. Users interested in running YOLOv4 should refer directly to the YOLOv4 GitHub repository for installation and usage instructions.
 
 Here is a brief overview of the typical steps you might take to use YOLOv4:
 
@@ -44,13 +44,13 @@ Here is a brief overview of the typical steps you might take to use YOLOv4:
 
 Please note that the specific steps may vary depending on your specific use case and the current state of the YOLOv4 repository. Therefore, it is strongly recommended to refer directly to the instructions provided in the YOLOv4 GitHub repository.
 
-We regret any inconvenience this may cause and will strive to update this document with usage examples for Ultralytics once support for YOLOv4 is implemented.
+For training and inference within the Ultralytics framework, see [YOLO11](yolo11.md) or [YOLO26](yolo26.md).
 
 ## Conclusion
 
 YOLOv4 is a powerful and efficient object detection model that strikes a balance between speed and accuracy. Its use of unique features and bag of freebies techniques during training allows it to perform excellently in real-time object detection tasks. YOLOv4 can be trained and used by anyone with a conventional GPU, making it accessible and practical for a wide range of applications including [surveillance systems](https://www.ultralytics.com/blog/shattering-the-surveillance-status-quo-with-vision-ai), [autonomous vehicles](https://www.ultralytics.com/solutions/ai-in-automotive), and [industrial automation](https://www.ultralytics.com/blog/improving-manufacturing-with-computer-vision).
 
-For those looking to implement object detection in their projects, YOLOv4 remains a strong contender, especially when real-time performance is a priority. While Ultralytics currently focuses on supporting newer YOLO versions like [YOLOv8](https://docs.ultralytics.com/models/yolov8/) and [YOLO11](https://docs.ultralytics.com/models/yolo11/), the architectural innovations introduced in YOLOv4 have influenced the development of these later models.
+For those looking to implement object detection in their projects, YOLOv4 remains a strong contender, especially when real-time performance is a priority. While Ultralytics currently focuses on supporting newer YOLO versions like [YOLO11](yolo11.md) and [YOLO26](yolo26.md), the architectural innovations introduced in YOLOv4 have influenced the development of these later models.
 
 ## Citations and Acknowledgments
 

docs/en/models/yolov7.md

@@ -91,7 +91,7 @@ YOLOv7 introduces several key features:
 
 ## Usage Examples
 
-As of the time of writing, Ultralytics only supports ONNX and TensorRT inference for YOLOv7.
+Ultralytics does not publish `yolov7.pt` pretrained weights or `ultralytics/cfg/models/v7/` YAMLs, and native PyTorch training and inference for YOLOv7 are **not supported** by the Ultralytics Python package. However, you can bring a YOLOv7 checkpoint trained in the [upstream YOLOv7 repository](https://github.com/WongKinYiu/yolov7) into Ultralytics by exporting it to ONNX or TensorRT, as shown below.
 
 ### ONNX Export
 

docs/en/modes/export.md

@@ -80,7 +80,7 @@ Adjusting these parameters allows for customization of the export process to fit
 
 ## Export Formats
 
-Available YOLO26 export formats are in the table below. You can export to any format using the `format` argument, i.e., `format='onnx'` or `format='engine'`. You can predict or validate directly on exported models, i.e., `yolo predict model=yolo26n.onnx`. Usage examples are shown for your model after export completes.
+Available YOLO26 export formats are in the table below. You can export to any format using the `format` argument, i.e., `format='onnx'` or `format='engine'`. You can predict or validate directly on exported models, i.e., `yolo predict model=yolo26n.onnx`. Usage examples are shown for your model after export completes. Models can also be exported directly from the browser on [Ultralytics Platform](https://platform.ultralytics.com) without any local setup.
 
 {% include "macros/export-table.md" %}
 

docs/en/modes/predict.md

@@ -38,6 +38,7 @@ Here's why you should consider YOLO26's predict mode for your various inference
 - **Performance:** Engineered for real-time, high-speed processing without sacrificing [accuracy](https://www.ultralytics.com/glossary/accuracy).
 - **Ease of Use:** Intuitive Python and CLI interfaces for rapid deployment and testing.
 - **Highly Customizable:** Various settings and parameters to tune the model's inference behavior according to your specific requirements.
+- **Production Ready:** Deploy models as API endpoints on [Ultralytics Platform](https://platform.ultralytics.com) with auto-scaling and monitoring, or run inference locally.
 
 ### Key Features of Predict Mode
 
@@ -367,7 +368,7 @@ Below are code examples for using each source type:
 
         Example `.streams` text file:
 
-        ```text
+        ```
         rtsp://example.com/media1.mp4
         rtsp://example.com/media2.mp4
         rtmp://example2.com/live

docs/en/modes/track.md

@@ -56,7 +56,7 @@ The default tracker is BoT-SORT.
 
 ## Tracking
 
-To run the tracker on video streams, use a trained Detect, Segment, or Pose model such as YOLO26n, YOLO26n-seg, or YOLO26n-pose.
+To run the tracker on video streams, use a trained Detect, Segment, or Pose model such as YOLO26n, YOLO26n-seg, or YOLO26n-pose. You can train custom models locally or on cloud GPUs through [Ultralytics Platform](https://platform.ultralytics.com).
 
 !!! example
 

docs/en/modes/train.md

@@ -31,6 +31,7 @@ Here are some compelling reasons to opt for YOLO26's Train mode:
 - **Versatility:** Train on custom datasets in addition to readily available ones like COCO, VOC, and ImageNet.
 - **User-Friendly:** Simple yet powerful CLI and Python interfaces for a straightforward training experience.
 - **Hyperparameter Flexibility:** A broad range of customizable hyperparameters to fine-tune model performance. For deeper control, you can [customize the trainer](../guides/custom-trainer.md) itself.
+- **Cloud Training:** Train on cloud GPUs through [Ultralytics Platform](https://platform.ultralytics.com) with real-time metrics and automatic checkpointing.
 
 ### Key Features of Train Mode
 
@@ -352,6 +353,10 @@ After setting up your logger, you can then proceed with your model training. All
 
 ## FAQ
 
+### Can I train without a local GPU?
+
+Yes. [Ultralytics Platform](https://platform.ultralytics.com) supports cloud training with free credits to get started. Upload your dataset, select a model and GPU, and train directly from the browser. See the [cloud training guide](../platform/train/cloud-training.md) for details.
+
 ### How do I train an [object detection](https://www.ultralytics.com/glossary/object-detection) model using Ultralytics YOLO26?
 
 To train an object detection model using Ultralytics YOLO26, you can either use the Python API or the CLI. Below is an example for both:
@@ -415,6 +420,49 @@ To resume training from an interrupted session, set the `resume` argument to `Tr
 
 Check the section on [Resuming Interrupted Trainings](#resuming-interrupted-trainings) for more information.
 
+### How do I train a model on an imbalanced dataset?
+
+Class imbalance occurs when some classes have significantly fewer examples than others in your training data. This can cause the model to perform poorly on rare classes. Ultralytics YOLO supports class weighting through the `cls_pw` argument to address this issue.
+
+The `cls_pw` argument controls class weighting power based on inverse class frequency:
+
+- `cls_pw=0.0` (default): Disables class weighting
+- `cls_pw=1.0`: Applies full inverse frequency weighting
+- Values between `0.0` and `1.0`: Provide partial weighting for moderate imbalance
+
+The class weights are computed as `(1.0 / class_counts) ^ cls_pw` and normalized so their mean equals 1.0.
+
+!!! example "Training on Imbalanced Dataset"
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a pretrained model
+        model = YOLO("yolo26n.pt")
+
+        # Train with full class weighting for severely imbalanced data
+        results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=1.0)
+
+        # Or use partial weighting (0.25) for moderate imbalance
+        results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=0.25)
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Train with full inverse frequency weighting
+        yolo detect train data=custom.yaml model=yolo26n.pt epochs=100 imgsz=640 cls_pw=1.0
+
+        # Train with partial weighting for moderate imbalance
+        yolo detect train data=custom.yaml model=yolo26n.pt epochs=100 imgsz=640 cls_pw=0.25
+        ```
+
+!!! tip
+
+    Start with `cls_pw=0.25` for moderately imbalanced datasets and increase to `1.0` if the rare classes still underperform. You can check the computed class weights in the training logs to verify the weight distribution.
+
 ### Can I train YOLO26 models on Apple silicon chips?
 
 Yes, Ultralytics YOLO26 supports training on Apple silicon chips utilizing the Metal Performance Shaders (MPS) framework. Specify 'mps' as your training device.

docs/en/modes/val.md

@@ -70,6 +70,7 @@ Validate a trained YOLO26n model [accuracy](https://www.ultralytics.com/glossary
         metrics.box.map50  # map50
         metrics.box.map75  # map75
         metrics.box.maps  # a list containing mAP50-95 for each category
+        metrics.box.image_metrics  # per-image metrics dictionary with precision, recall, F1, TP, FP, and FN
         ```
 
     === "CLI"
@@ -137,6 +138,42 @@ The below examples showcase YOLO model validation with custom arguments in Pytho
     print(results.confusion_matrix.to_df())
     ```
 
+!!! tip "Per-Image Precision, Recall, and F1"
+
+    Validation stores per-image precision, recall, F1, TP, FP, and FN metrics (at IoU threshold 0.5) for all tasks
+    except classification. Access them through `results.box.image_metrics` for detection and OBB, `results.seg.image_metrics`
+    for segmentation, and `results.pose.image_metrics` for pose after validation completes.
+
+    ```python
+    from ultralytics import YOLO
+
+    # Load a model
+    model = YOLO("yolo26n.pt")
+
+    # Validate and access per-image metrics
+    results = model.val(data="coco8.yaml")
+
+    # image_metrics is a dictionary with image filenames as keys
+    print(results.box.image_metrics)
+    # Output: {'image1.jpg': {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}, ...}
+
+    # Access metrics for a specific image
+    results.box.image_metrics["image1.jpg"]  # {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}
+    ```
+
+    Each entry in `image_metrics` contains the following keys:
+
+    | Key         | Description                                       |
+    |-------------|---------------------------------------------------|
+    | `precision` | Precision score for the image (`tp / (tp + fp)`). |
+    | `recall`    | Recall score for the image (`tp / (tp + fn)`).    |
+    | `f1`        | Harmonic mean of precision and recall.            |
+    | `tp`        | Number of true positives for the image.           |
+    | `fp`        | Number of false positives for the image.          |
+    | `fn`        | Number of false negatives for the image.          |
+
+    This feature is available for detection, segmentation, pose, and OBB tasks.
+
 | Method      | Return Type            | Description                                                                |
 | ----------- | ---------------------- | -------------------------------------------------------------------------- |
 | `summary()` | `List[Dict[str, Any]]` | Converts validation results to a summarized dictionary.                    |
@@ -187,6 +224,7 @@ print(metrics.box.map)  # mAP50-95
 print(metrics.box.map50)  # mAP50
 print(metrics.box.map75)  # mAP75
 print(metrics.box.maps)  # list of mAP50-95 for each category
+print(metrics.box.image_metrics)  # per-image metrics dictionary with precision, recall, F1, TP, FP, and FN
 ```
 
 For a complete performance evaluation, it's crucial to review all these metrics. For more details, refer to the [Key Features of Val Mode](#key-features-of-val-mode).

docs/en/platform/account/activity.md

@@ -103,7 +103,7 @@ Use the search bar to find events by resource name or event description.
 Filter by time period using the date range picker:
 
 - Select a start and end date
-- No default date filter (shows all events)
+- The page defaults to the last 30 days
 - Custom date ranges supported
 
 ![Ultralytics Platform Activity Page Date Range Picker Expanded](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/activity-page-date-range-picker-expanded.avif)
@@ -123,8 +123,8 @@ Each event displays:
 
 Some actions support undo directly from the Activity feed:
 
-- **Settings changes**: Click **Undo** next to a settings update event to revert the change
-- Undo is available for a short time window after the action
+- **Settings changes**: Click **Undo** next to a recent settings update event to revert the change
+- Undo is available for **one hour** after the action; after that, the undo button disappears
 
 ## Pagination
 
@@ -134,9 +134,13 @@ The Activity feed supports pagination:
 - Navigate between pages using the pagination controls
 - Page size is configurable via URL query parameter
 
-## API Access
+## API Routes
 
-Access activity programmatically via the [REST API](../api/index.md#activity-api):
+The Activity feed is powered by browser-authenticated routes — it is not exposed as a public API and cannot be accessed with an API key. The route shapes are listed below for reference; to view, mark, or archive activity, use the Activity feed in the platform UI.
+
+!!! note "Browser Session Only"
+
+    The routes shown below require an active platform browser session. The `Authorization: Bearer YOUR_API_KEY` header in the examples will not authenticate these routes — they are documented only to describe how the in-app feed talks to the server.
 
 === "List Activity"
 

docs/en/platform/account/api-keys.md

@@ -14,11 +14,10 @@ keywords: Ultralytics Platform, API keys, authentication, remote training, secur
 
 Create a new API key:
 
-1. Go to **Settings > Profile**
-2. Scroll to the **API Keys** section
-3. Click **Create Key**
-4. Enter a name for the key (e.g., "Training Server")
-5. Click **Create Key**
+1. Go to **Settings > API Keys**
+2. Click **Create Key**
+3. Enter a name for the key (e.g., "Training Server")
+4. Click **Create Key**
 
 ![Ultralytics Platform Settings Profile Tab Create Api Key Dialog](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/settings-profile-tab-create-api-key-dialog.avif)
 
@@ -115,10 +114,10 @@ Enable metric streaming with your key.
 
 !!! warning "Package Version Requirement"
 
-    Platform integration requires **ultralytics>=8.4.14**. Lower versions will NOT work with Platform.
+    Platform integration requires **ultralytics>=8.4.35**. Lower versions will NOT work with Platform.
 
     ```bash
-    pip install "ultralytics>=8.4.14"
+    pip install "ultralytics>=8.4.35"
     ```
 
 ```bash
@@ -132,7 +131,7 @@ See [Cloud Training](../train/cloud-training.md#remote-training) for the complet
 
 ### View Keys
 
-All keys are listed in `Settings > Profile` under the API Keys section:
+All keys are listed on the `Settings > API Keys` tab:
 
 Each key card shows the key name, the full decrypted key value (copyable), relative creation time, and a revoke button.
 
@@ -208,7 +207,7 @@ Solutions:
 1. Verify key is copied correctly (including the `ul_` prefix)
 2. Check key hasn't been revoked
 3. Confirm environment variable is set
-4. Ensure you're using `ultralytics>=8.4.14`
+4. Ensure you're using `ultralytics>=8.4.35`
 
 ### Permission Denied
 
@@ -246,7 +245,7 @@ Keys don't expire automatically. They remain valid until revoked. Consider imple
 
 ### Can I see my key after creation?
 
-Yes, full key values are visible in the key list on `Settings > Profile`. The Platform decrypts and displays your keys so you can copy them anytime.
+Yes, full key values are visible in the key list on `Settings > API Keys`. The Platform decrypts and displays your keys so you can copy them anytime.
 
 ### Are keys region-specific?
 

docs/en/platform/account/billing.md

@@ -62,7 +62,7 @@ For professionals and small teams ($29/month or $290/year):
 - 10 concurrent cloud trainings
 - 500 GB storage · 20 GB dataset upload limit
 - 10 cloud deployments
-- [Team collaboration](teams.md) (up to 5 members)
+- [Team collaboration](teams.md) with 4-role RBAC (up to 5 members)
 - Access to the best GPUs (H200, B200)
 - Priority support
 
@@ -78,13 +78,12 @@ For organizations with advanced needs:
 - Unlimited models, storage, trainings, and deployments · 50 GB dataset upload limit
 - Enterprise License (commercial use, non-AGPL)
 - SSO / SAML authentication
-- RBAC with 4 roles (Owner, Admin, Editor, Viewer)
 - On-premise deployment (coming soon)
 - ISO/SOC compliance (coming soon)
 - SLA guarantees (coming soon)
 - Enterprise support
 
-Contact [sales@ultralytics.com](mailto:sales@ultralytics.com) for Enterprise pricing.
+See [Ultralytics Licensing](https://www.ultralytics.com/license) for Enterprise plan details.
 
 ## Credits
 
@@ -236,16 +235,17 @@ After upgrading:
 
 ### Cancel Pro
 
-Cancel anytime from the billing portal:
+Cancel anytime from the Plans tab:
 
-1. Go to **Settings > Billing**
-2. Click **Manage Subscription**
-3. Select **Cancel**
-4. Confirm cancellation
+1. Go to **Settings > Plans**
+2. Click **Cancel Subscription** on the Pro plan card
+3. Confirm in the dialog
+
+If you cancel before the end of your billing period, a **Resume Subscription** button appears — click it to undo the cancellation before the period ends.
 
 !!! note "Cancellation Timing"
 
-    Pro features remain active until the end of your billing period. Monthly credits stop at cancellation.
+    Pro features remain active until the end of your current billing period. Monthly credits stop being granted at cancellation.
 
 ### Downgrading to Free
 
@@ -273,13 +273,13 @@ View all transactions in `Settings > Billing`:
 
 ![Ultralytics Platform Settings Billing Tab Transaction History Table](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/settings-billing-tab-transaction-history-table.avif)
 
-| Column      | Description                                                                                                 |
-| ----------- | ----------------------------------------------------------------------------------------------------------- |
-| **Date**    | Transaction date                                                                                            |
-| **Type**    | Signup Bonus, Credit Purchase, Monthly Grant, Training, Refund, Adjustment, Auto Top-Up, Auto Top-Up Failed |
-| **Amount**  | Transaction value (green for credits, red for charges)                                                      |
-| **Balance** | Resulting balance after transaction                                                                         |
-| **Details** | Additional context (model link, receipt, period)                                                            |
+| Column      | Description                                                                                                                            |
+| ----------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| **Date**    | Transaction date                                                                                                                       |
+| **Type**    | Signup, Purchase, Subscription, Monthly Grant, Training, Refund, Adjustment, Promo, Auto Top-Up, Auto Top-Up Failed, Pro Credit Expiry |
+| **Amount**  | Transaction value (green for credits, red for charges)                                                                                 |
+| **Balance** | Resulting balance after transaction                                                                                                    |
+| **Details** | Additional context (model link, receipt, period)                                                                                       |
 
 ## FAQ
 

docs/en/platform/account/index.md

@@ -35,27 +35,28 @@ The Account section helps you:
 
 ## Account Features
 
-| Feature      | Description                                              |
-| ------------ | -------------------------------------------------------- |
-| **Settings** | Profile, social links, emails, data region, and API keys |
-| **Plans**    | Free, Pro, and Enterprise plan comparison                |
-| **Billing**  | Credits, payment methods, and transaction history        |
-| **Teams**    | Members, roles, invites, and seat management             |
-| **Trash**    | Recover deleted items within 30 days                     |
-| **Emails**   | Add, remove, verify, and set primary email address       |
-| **Activity** | Event log with inbox, archive, search, and undo          |
+| Feature      | Description                                                 |
+| ------------ | ----------------------------------------------------------- |
+| **Settings** | Profile, emails, social links, and data region              |
+| **API Keys** | Generate AES-256-GCM encrypted keys for programmatic access |
+| **Plans**    | Free, Pro, and Enterprise plan comparison                   |
+| **Billing**  | Credits, payment methods, and transaction history           |
+| **Teams**    | Members, roles, invites, and seat management                |
+| **Trash**    | Recover deleted items within 30 days                        |
+| **Activity** | Event log with inbox, archive, search, and undo             |
 
 ## Settings Tabs
 
-Account management is organized into tabs within `Settings`:
+Account management is organized into six tabs within `Settings` (in order):
 
-| Tab       | Description                                                      |
-| --------- | ---------------------------------------------------------------- |
-| `Profile` | Display name, bio, company, use case, emails, social links, keys |
-| `Plans`   | Compare Free, Pro, and Enterprise plans                          |
-| `Billing` | Credit balance, top-up, payment methods, transactions            |
-| `Teams`   | Member list, roles, invites, seat allocation                     |
-| `Trash`   | Soft-deleted projects, datasets, and models                      |
+| Tab        | Description                                                             |
+| ---------- | ----------------------------------------------------------------------- |
+| `Profile`  | Display name, bio, company, use case, emails, social links, data region |
+| `API Keys` | Create and manage API keys for remote training and programmatic access  |
+| `Plans`    | Compare Free, Pro, and Enterprise plans                                 |
+| `Billing`  | Credit balance, top-up, payment methods, transactions                   |
+| `Teams`    | Member list, roles, invites, seat allocation                            |
+| `Trash`    | Soft-deleted projects, datasets, and models (30-day recovery)           |
 
 ## Security
 
@@ -129,7 +130,7 @@ Yes, Ultralytics Platform implements:
 No, data region is selected during signup and cannot be changed. To use a different region:
 
 1. Export your data
-2. Create a new account in desired region
+2. Create a new account in the desired region
 3. Re-upload your data
 
 This ensures data residency compliance.

docs/en/platform/account/settings.md

@@ -8,11 +8,11 @@ keywords: Ultralytics Platform, settings, profile, preferences, GDPR, data expor
 
 [Ultralytics Platform](https://platform.ultralytics.com) settings allow you to configure your profile, social links, workspace preferences, and manage your data with GDPR-compliant export and deletion options.
 
-Settings is organized into five tabs: `Profile`, `Plans`, `Billing`, `Teams`, and `Trash`.
+Settings is organized into six tabs (in order): `Profile`, `API Keys`, `Plans`, `Billing`, `Teams`, and `Trash`.
 
 ## Profile Tab
 
-The `Profile` tab contains your profile information, social links, API keys, data region, and account management options.
+The `Profile` tab contains your profile information, social links, data region, and account management options.
 
 ### Profile Information
 
@@ -95,10 +95,6 @@ Manage email addresses linked to your account in the `Profile` tab:
 
     Your primary email is used for notifications and account recovery. Only verified emails can be set as primary.
 
-### API Keys
-
-API keys are managed directly on the `Profile` tab. See [API Keys](api-keys.md) for full documentation.
-
 ### Data Region
 
 View your data region on the `Profile` tab:
@@ -184,7 +180,7 @@ Download all your data:
 1. Go to **Settings > Profile**
 2. Scroll to the bottom section
 3. Click **Export Data**
-4. Receive download link via email
+4. An asynchronous export job runs in the background; a **Download** link appears on the same page when the job completes (download link valid for 1 hour)
 
 Export includes:
 
@@ -192,7 +188,7 @@ Export includes:
 - Dataset metadata
 - Model metadata
 - Training history
-- API key metadata (not secrets)
+- API key metadata (keys themselves are never exported in plaintext)
 
 #### Account Deletion
 
@@ -221,31 +217,108 @@ Permanently delete your account:
 - Server logs (90 days)
 - Legal compliance records
 
+## API Keys Tab
+
+The `API Keys` tab lets you create and manage API keys for remote training and inference. See [API Keys](api-keys.md) for full documentation.
+
 ## Plans Tab
 
-Compare available plans. See [Billing](billing.md) for detailed plan information and pricing.
+The `Plans` tab lets you compare available plans and upgrade or downgrade your subscription.
+
+![Ultralytics Platform Settings Plans Tab Free Pro Enterprise Comparison](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/settings-plans-tab-free-pro-enterprise-comparison.avif)
+
+| Plan           | Storage   | Models    | Deployments | Concurrent Trainings | Team Seats |
+| -------------- | --------- | --------- | ----------- | -------------------- | ---------- |
+| **Free**       | 100 GB    | 100       | 3           | 3                    | —          |
+| **Pro**        | 500 GB    | 500       | 10          | 10                   | Up to 5    |
+| **Enterprise** | Unlimited | Unlimited | Unlimited   | Unlimited            | Up to 50   |
+
+From this tab you can:
+
+- **Compare features** across Free, Pro, and Enterprise tiers
+- **Upgrade to Pro** to unlock more storage, models, team collaboration, and priority GPU access
+- **Review Enterprise** capabilities including SSO/SAML and commercial licensing — see [Ultralytics Licensing](https://www.ultralytics.com/license)
+
+See [Billing](billing.md) for detailed plan information, pricing, and upgrade instructions.
 
 ## Billing Tab
 
-Manage credits, payment methods, and view transaction history. See [Billing](billing.md) for full documentation.
+The `Billing` tab is where you manage credits, payment methods, and review transaction history. Credits are the currency used for cloud training and deployments on the platform.
+
+![Ultralytics Platform Settings Billing Tab Credit Balance And Plan Card](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/settings-billing-tab-credit-balance-and-plan-card.avif)
+
+From this tab you can:
+
+- **View credit balance** and monitor remaining credits
+- **Add credits** via manual top-up (presets from $10–$500 or custom amounts up to $1,000)
+- **Enable auto top-up** to automatically add credits when your balance falls below a threshold, preventing training interruptions
+- **Manage payment methods** and update your billing address
+- **Review transaction history** to track all credit movements including purchases, training costs, and refunds
+
+!!! tip "Training Costs"
+
+    Before each training run, the platform estimates the cost based on your selected GPU, dataset size, and epochs. You're charged for actual usage upon completion — unused estimated credits are returned to your balance.
+
+See [Billing](billing.md) for full documentation on credits, payment, and plan management.
 
 ## Teams Tab
 
-Manage workspace members, roles, and invitations. Teams are available on [Pro and Enterprise plans](billing.md#plans). See [Teams](teams.md) for full documentation on team creation, roles, shared resources, and enterprise features.
+The `Teams` tab lets you manage workspace members, roles, and invitations. Teams are available on [Pro and Enterprise plans](billing.md#plans).
+
+![Ultralytics Platform Teams Member List With Roles](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/settings-teams-tab-member-list-with-roles.avif)
+
+### Roles and Permissions
+
+| Role       | Description                                                          |
+| ---------- | -------------------------------------------------------------------- |
+| **Owner**  | Full control including billing, member management, and team deletion |
+| **Admin**  | Manage members, resources, and settings (cannot delete team)         |
+| **Editor** | Create and edit projects, datasets, and models                       |
+| **Viewer** | Read-only access to shared resources                                 |
 
 ### Manage Members
 
 Owners and admins can manage the team:
 
+- **Invite members** via email (invites stay valid until accepted or canceled; pending invites count against the seat limit)
 - **Change roles**: Click the role dropdown next to a member (only the owner can assign/remove the admin role)
 - **Remove members**: Click the menu and select **Remove**
 - **Cancel invites**: Cancel pending invitations that haven't been accepted
 - **Resend invites**: Resend invitation emails
 - **Transfer ownership**: Transfer workspace ownership to another member (Owner only)
 
+### Shared Resources
+
+All resources created in a team workspace belong to the team, not individual members. Team members share:
+
+- **Datasets, projects, and models** — accessible by all members based on their role
+- **Credit balance** — a single shared pool for training and deployments
+- **Storage and resource limits** — counted at the team level
+
+!!! note "Team Billing"
+
+    On Pro plans, each team member is a paid seat. The team credit balance is shared across all members.
+
+See [Teams](teams.md) for full documentation on team creation, switching workspaces, and enterprise features.
+
 ## Trash Tab
 
-Manage deleted items. See [Trash](trash.md) for full documentation.
+The `Trash` tab shows all deleted items and lets you restore or permanently remove them. Deleted items follow a 30-day soft delete policy before automatic permanent deletion.
+
+![Ultralytics Platform Settings Trash Tab With Items And Storage Treemap](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/settings-trash-tab-with-items-and-storage-treemap.avif)
+
+From this tab you can:
+
+- **Browse deleted items** filtered by type (All, Projects, Datasets, Models)
+- **View the storage treemap** to see the relative size of trashed items
+- **Restore items** to their original location with all data intact
+- **Permanently delete** individual items or use **Empty Trash** to remove everything at once
+
+!!! warning "Storage Impact"
+
+    Items in the trash still count toward your storage quota. To free up space immediately, permanently delete items you no longer need.
+
+See [Trash](trash.md) for full documentation including cascade behavior and API access.
 
 ## Help & Feedback
 

docs/en/platform/account/teams.md

@@ -21,7 +21,7 @@ Teams allow multiple users to work together under a shared workspace:
 
 !!! note "Plan Requirement"
 
-    Creating a team requires a [Pro or Enterprise plan](billing.md#plans). You can upgrade from Settings or when clicking **+ Create Team** in the workspace switcher.
+    Team workspaces require a [Pro or Enterprise plan](billing.md#plans). You can start team setup before upgrading, but the workspace must be on a Pro or Enterprise plan to use team features.
 
 ## Creating a Team
 
@@ -73,7 +73,7 @@ Team members share the workspace credit balance and resource limits. All members
 
 !!! note "Pro Plan Seat Billing"
 
-    On the Pro plan, each team member is a paid seat at $29/month (or $290/year). Monthly credits of $30/seat are added to the shared wallet.
+    On the Pro plan, each team member is a paid seat at $29/month (or $290/year, a ~17% saving). Monthly credits of $30/seat are added to the team's shared wallet at the start of every billing cycle.
 
 ## Inviting Members
 
@@ -87,7 +87,7 @@ Admins and Owners can invite new members to the team:
 
 ![Ultralytics Platform Teams Invite Member Dialog](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/settings-teams-invite-member-dialog.avif)
 
-The invitee receives an email invitation with a link to accept and join the team. Invitations expire after 7 days. Once accepted, the team workspace appears in the invitee's workspace switcher.
+The invitee receives an email invitation with a link to accept and join the team. Invitations remain valid until accepted or canceled. Once accepted, the team workspace appears in the invitee's workspace switcher. If an invite is lost, **Resend** it from the Teams tab to rotate the token and send a fresh email, or **Cancel** it to free up the seat.
 
 !!! note "Admin Invites"
 
@@ -101,17 +101,11 @@ Enterprise plans include additional capabilities for organizations with advanced
 
 !!! warning "License Expiration"
 
-    If your Enterprise license expires, workspace access is blocked until renewed. Contact [sales@ultralytics.com](mailto:sales@ultralytics.com) to renew.
+    If your Enterprise license expires, workspace access is blocked until the license is renewed. See [Ultralytics Licensing](https://www.ultralytics.com/license) for details.
 
 ### Getting Started with Enterprise
 
-Enterprise plans are provisioned by the Ultralytics team:
-
-1. Contact [sales@ultralytics.com](mailto:sales@ultralytics.com)
-2. Discuss your team size, credit needs, and compliance requirements
-3. Receive a provisioning invite with your enterprise configuration
-4. Accept the invite to become the team Owner
-5. Invite your team members
+Enterprise plans are provisioned by the Ultralytics team. See [Ultralytics Licensing](https://www.ultralytics.com/license) for plan details. Once your enterprise configuration is set up, you'll receive a provisioning invite to accept as the team Owner, after which you can invite your team members.
 
 ## FAQ
 
@@ -129,4 +123,4 @@ All team members share a single credit balance. The Owner and Admins can top up
 
 ### How do I upgrade from Pro to Enterprise?
 
-Contact [sales@ultralytics.com](mailto:sales@ultralytics.com) to discuss Enterprise pricing and provisioning. The Ultralytics team will handle the upgrade and configuration.
+Enterprise pricing and provisioning are handled directly by the Ultralytics team. See [Ultralytics Licensing](https://www.ultralytics.com/license) for plan details.

docs/en/platform/account/trash.md

@@ -87,6 +87,8 @@ Recover a deleted item:
 
 The item returns to its original location with all data intact.
 
+If the original slug is already taken, the platform restores the item with a unique available slug so you can access it immediately.
+
 ### Restore Behavior
 
 | Resource | Restore Behavior                                            |
@@ -115,7 +117,7 @@ Permanently delete all items immediately:
 
 !!! warning "Irreversible Action"
 
-    Emptying Trash permanently deletes all items immediately. This action cannot be undone and all data will be lost.
+    Emptying Trash permanently deletes all items immediately. This action cannot be undone and all data will be lost, including attached deployments, export jobs, and stored files tied to the trashed resources.
 
 ### Delete Single Item Permanently
 
@@ -125,6 +127,8 @@ To permanently delete one item without waiting:
 2. Click the **Delete** button
 3. Confirm deletion
 
+For projects, permanent deletion also removes related deployments and export files that belong to the deleted workspace resources.
+
 ## Storage and Trash
 
 Items in Trash still count toward your storage quota:
@@ -162,10 +166,9 @@ Access trash programmatically via the [REST API](../api/index.md#trash-api):
 
 === "Empty Trash"
 
-    ```bash
-    curl -X DELETE -H "Authorization: Bearer YOUR_API_KEY" \
-      https://platform.ultralytics.com/api/trash/empty
-    ```
+    !!! note "Browser session only"
+
+        `DELETE /api/trash/empty` requires an authenticated browser session and cannot be called with an API key. Use the **Empty Trash** button in [**Settings > Trash**](../account/settings.md#trash-tab) instead, or permanently delete individual items via `DELETE /api/trash` (API-key compatible).
 
 ## FAQ
 

docs/en/platform/data/annotation.md

@@ -1,6 +1,6 @@
 ---
 comments: true
-description: Learn to annotate images in Ultralytics Platform with manual tools, skeleton templates for pose estimation, SAM smart annotation, and YOLO auto-labeling for all 5 task types.
+description: Learn to annotate images in Ultralytics Platform with manual tools, skeleton templates for pose estimation, and Smart annotation with SAM and YOLO models for detect, segment, and OBB tasks.
 keywords: Ultralytics Platform, annotation, labeling, SAM, auto-annotation, bounding box, polygon, keypoints, skeleton templates, pose estimation, segmentation, YOLO
 ---
 
@@ -121,10 +121,10 @@ graph LR
 
 The editor provides two annotation modes, selectable from the toolbar:
 
-| Mode      | Description                                             | Shortcut |
-| --------- | ------------------------------------------------------- | -------- |
-| **Draw**  | Manual annotation with task-specific tools              | `V`      |
-| **Smart** | SAM-powered interactive annotation (detect/segment/OBB) | `S`      |
+| Mode       | Description                                                       | Shortcut |
+| ---------- | ----------------------------------------------------------------- | -------- |
+| **Manual** | Draw annotations with task-specific tools (all 5 task types)      | `V`      |
+| **Smart**  | SAM or YOLO model-assisted annotation (detect, segment, OBB only) | `S`      |
 
 ## Manual Annotation Tools
 
@@ -150,8 +150,8 @@ Draw rectangular boxes around objects:
 Draw precise polygon masks:
 
 1. Enter edit mode and select `Draw`
-2. Click to add vertices
-3. Right-click or press `Enter` to close the polygon
+2. Click to add vertices, or hold `Shift` and move the mouse to freehand-draw dense points
+3. Click the first vertex, or press `Enter` or `Escape` to close the polygon
 4. Select a class from the dropdown
 
 ![Ultralytics Platform Annotate Segment Polygon Vertices](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-annotate-segment-polygon-vertices.avif)
@@ -179,13 +179,13 @@ Annotate poses using skeleton templates. Select a template from the toolbar, cli
 
 The editor includes 5 built-in templates:
 
-| Template   | Keypoints | Description                                                                                                        |
-| ---------- | --------- | ------------------------------------------------------------------------------------------------------------------ |
-| **Person** | 17        | [COCO human pose](../../datasets/pose/index.md) — nose, eyes, ears, shoulders, elbows, wrists, hips, knees, ankles |
-| **Hand**   | 21        | MediaPipe hand landmarks — wrist, thumb, index, middle, ring, pinky joints                                         |
-| **Face**   | 68        | [iBUG 300W](https://ibug.doc.ic.ac.uk/resources/300-W/) facial landmarks — jaw, eyebrows, nose, eyes, mouth        |
-| **Dog**    | 18        | Animal pose — nose, head, neck, shoulders, legs, paws, tail                                                        |
-| **Box**    | 4         | Corner keypoints — top-left, top-right, bottom-right, bottom-left                                                  |
+| Template   | Keypoints | Description                                                                                                            |
+| ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| **Person** | 17        | [COCO human body pose](../../datasets/pose/coco.md) — nose, eyes, ears, shoulders, elbows, wrists, hips, knees, ankles |
+| **Hand**   | 21        | [Ultralytics Hand Keypoints](../../datasets/pose/hand-keypoints.md) — wrist, thumb, index, middle, ring, pinky joints  |
+| **Face**   | 68        | [iBUG 300W](https://ibug.doc.ic.ac.uk/resources/300-W/) facial landmarks — jaw, eyebrows, nose, eyes, mouth            |
+| **Dog**    | 18        | AP-10K animal pose — nose, head, neck, shoulders, tailbase, tail, and 4 legs (elbows, knees, paws)                     |
+| **Box**    | 4         | Corner keypoints — top-left, top-right, bottom-right, bottom-left                                                      |
 
 ![Ultralytics Platform Annotate Pose Keypoints Skeleton](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-annotate-pose-keypoints-skeleton.avif)
 
@@ -234,15 +234,18 @@ Assign image-level class labels:
 
 ![Ultralytics Platform Annotate Classify Side Panel](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-annotate-classify-side-panel.avif)
 
-## SAM Smart Annotation
+## Smart Annotation
 
-[Segment Anything Model (SAM)](https://docs.ultralytics.com/models/sam/) enables intelligent annotation with just a few clicks. Smart mode is available for **detect**, **segment**, and **OBB** tasks.
+Smart annotation adds model-assisted annotation to the editor. In Smart mode, you can use [Segment Anything Model (SAM)](https://docs.ultralytics.com/models/sam/) for click-based annotation or use pretrained Ultralytics YOLO models and your own fine-tuned YOLO models to add predictions as annotations. Smart annotation is available for **detect**, **segment**, and **OBB** tasks.
+
+### SAM Smart Annotation
+
+With a SAM model selected:
 
 1. Enter edit mode and select `Smart` or press `S`
-2. **Left-click** to add positive points (include this area)
-3. **Right-click** to add negative points (exclude this area)
-4. SAM generates a precise mask in real-time
-5. Press `Enter` or `Escape` to save the annotation, or enable **auto-apply** for one-click workflows
+2. Click on the object you want to annotate — SAM generates an initial mask in real-time
+3. Refine the mask with additional clicks: click **outside** the current mask to add coverage, or click **inside** the current mask to subtract regions
+4. Press `Enter` or `Escape` to save the annotation, or enable **auto-apply** for one-click workflows
 
 ![Ultralytics Platform Annotate Sam Positive Negative Points Mask](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-annotate-sam-positive-negative-points-mask.avif)
 
@@ -265,14 +268,13 @@ graph LR
 
 !!! tip "SAM Tips"
 
-    - Start with a positive click on the object center
-    - Add negative clicks to exclude background
-    - Hold `Alt`/`Option` to invert click behavior (left-click becomes negative, right-click becomes positive)
-    - Enable **auto-apply** (`A`) for one-click annotation — the mask saves automatically after each click
+    - Start with a click on the object center
+    - Click again outside the mask to expand coverage
+    - Click inside the mask to subtract unwanted regions
+    - Enable **auto-apply** (`A`) for one-click annotation
     - Hold `Shift` while auto-apply is on to place multiple points before the mask is applied
-    - Positive and negative points appear as square markers with `+` and `−` symbols on the canvas
     - Works best for distinct objects with clear edges
-    - Use 2-3 positive points for elongated objects
+    - Use a few refinement clicks for elongated or overlapping objects
 
 SAM smart annotation can generate:
 
@@ -284,15 +286,15 @@ SAM smart annotation can generate:
 
     SAM smart annotation is only available for **detect**, **segment**, and **OBB** tasks. Classification and pose tasks require manual annotation.
 
-### Auto-Apply Mode
+#### Auto-Apply Mode
 
 Auto-apply mode speeds up Smart annotation by automatically saving the SAM mask after each click — no need to press `Enter`. Toggle it with the auto-apply button in the toolbar or press `A`.
 
-| Mode                        | Behavior                                             |
-| --------------------------- | ---------------------------------------------------- |
-| **Auto-apply ON** (default) | Mask applies automatically after each click          |
-| **Auto-apply ON + `Shift`** | Place multiple points first, mask applies on release |
-| **Auto-apply OFF**          | Place points freely, press `Enter` to apply          |
+| Mode                         | Behavior                                             |
+| ---------------------------- | ---------------------------------------------------- |
+| **Auto-apply ON**            | Mask applies automatically after each click          |
+| **Auto-apply ON + `Shift`**  | Place multiple points first, mask applies on release |
+| **Auto-apply OFF** (default) | Place points freely, press `Enter` to apply          |
 
 ![Ultralytics Platform Annotate Sam Auto Apply Toggle](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-annotate-sam-auto-apply-toggle.avif)
 
@@ -300,22 +302,38 @@ Auto-apply mode speeds up Smart annotation by automatically saving the SAM mask
 
     Auto-apply is ideal for datasets with well-separated objects where a single click produces an accurate mask. For complex or overlapping objects, turn auto-apply off and use multiple positive/negative points to refine the mask before saving.
 
-### SAM Model Selection
+#### SAM Model Selection
 
-When Smart mode is active, a model picker appears in the toolbar. Five models are available — choose based on the speed vs. accuracy trade-off that suits your dataset:
+When Smart mode is active, a model picker appears in the toolbar. Five SAM models are available — choose based on the speed vs. accuracy trade-off that suits your dataset:
 
-| Model             | Size    | Speed    | Notes                    |
-| ----------------- | ------- | -------- | ------------------------ |
-| **SAM 2.1 Tiny**  | 74.5 MB | Fastest  |                          |
-| **SAM 2.1 Small** | 88 MB   | Fast     | Default                  |
-| **SAM 2.1 Base**  | 154 MB  | Moderate |                          |
-| **SAM 2.1 Large** | 428 MB  | Slower   | Most accurate of SAM 2.1 |
-| **SAM 3**         | 3.45 GB | Slowest  | Latest generation        |
+| Model             | Size    | Speed    | Notes                      |
+| ----------------- | ------- | -------- | -------------------------- |
+| **SAM 2.1 Tiny**  | 75 MB   | Fastest  |                            |
+| **SAM 2.1 Small** | 88 MB   | Fast     |                            |
+| **SAM 2.1 Base**  | 154 MB  | Moderate |                            |
+| **SAM 2.1 Large** | 428 MB  | Slower   | Most accurate of SAM 2.1   |
+| **SAM 3**         | 3.45 GB | Slowest  | Default, latest generation |
 
 ![Ultralytics Platform Annotate Sam Model Selector](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-annotate-sam-model-selector.avif)
 
 Switching models while Smart mode is active re-initializes the predictor for the current image automatically.
 
+### YOLO Smart Annotation
+
+With a YOLO model selected, Smart annotation can add predictions from pretrained Ultralytics models or your own fine-tuned models.
+
+1. Enter edit mode and select `Smart` or press `S`
+2. Select a YOLO model from the model picker in the toolbar (`Official` or `My Models`)
+3. Click `Predict`
+4. Review the added annotations and make any needed corrections
+
+![Ultralytics Platform Annotate Smart Annotation Yolo Model](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-annotate-yolo-auto-labeling.avif)
+
+!!! tip "YOLO Model Notes"
+
+    - The model picker only lists models that match the current dataset task.
+    - Duplicate predictions are skipped when they overlap an existing annotation of the same class at IoU `0.7` or higher.
+
 ## Class Sidebar
 
 The annotation editor includes a collapsible class sidebar on the right side of the canvas. The sidebar provides:
@@ -362,7 +380,7 @@ In edit mode, a crosshair overlay tracks the cursor position and displays pixel
 
 ## SAM Hover Preview
 
-In Smart mode for **segment** tasks, SAM provides a real-time mask preview as you hover over the image — before clicking any points. This lets you see the predicted segmentation boundary and decide where to click. Once you add positive or negative points, the preview updates to reflect your refinements.
+In Smart mode, SAM provides a real-time hover preview before you click any points. This preview is available for **detect**, **segment**, and **OBB** tasks. Once you add refinement clicks, the preview updates to reflect the current mask and the annotation type for the active task.
 
 ## Polygon Vertex Editing
 
@@ -416,37 +434,42 @@ Efficient annotation with keyboard shortcuts:
 
 === "General"
 
-    | Shortcut               | Action                     |
-    | ---------------------- | -------------------------- |
-    | `Cmd/Ctrl+S`           | Save annotations           |
-    | `Cmd/Ctrl+Z`           | Undo                       |
-    | `Cmd/Ctrl+Shift+Z`     | Redo                       |
-    | `Cmd/Ctrl+Y`           | Redo (alternative)         |
-    | `Escape`               | Save / Deselect / Exit     |
-    | `Delete` / `Backspace` | Delete selected annotation |
-    | `1-9`                  | Select class 1-9           |
-    | `Cmd/Ctrl+Scroll`      | Zoom in/out                |
-    | `Shift+Click`          | Multi-select annotations   |
-    | `Cmd/Ctrl+A`           | Select all annotations     |
+    | Shortcut                      | Action                       |
+    | ----------------------------- | ---------------------------- |
+    | `Cmd/Ctrl+S`                  | Save annotations             |
+    | `Cmd/Ctrl+Z`                  | Undo                         |
+    | `Cmd/Ctrl+Y`                  | Redo                         |
+    | `Escape`                      | Save / Deselect / Exit       |
+    | `Delete` / `Backspace`        | Delete selected annotation   |
+    | `1-9`                         | Select class 1-9             |
+    | `Cmd/Ctrl+Scroll`             | Zoom in/out                  |
+    | `Cmd/Ctrl++` or `Cmd/Ctrl+=`  | Zoom in                      |
+    | `Cmd/Ctrl+-`                  | Zoom out                     |
+    | `Cmd/Ctrl+0`                  | Reset to fit                 |
+    | `Space+Drag`                  | Pan canvas when zoomed       |
+    | `Shift+Click`                 | Multi-select annotations     |
+    | `Cmd/Ctrl+A`                  | Select all annotations       |
 
 === "Modes"
 
-    | Shortcut | Action             |
-    | -------- | ------------------ |
-    | `V`      | Draw mode (manual) |
-    | `S`      | Smart mode (SAM)   |
+    | Shortcut | Action                          |
+    | -------- | ------------------------------- |
+    | `V`      | Manual mode (draw)              |
+    | `S`      | Smart mode (SAM or YOLO model)  |
 
 === "Drawing"
 
-    | Shortcut       | Action                                                                     |
-    | -------------- | ---------------------------------------------------------                  |
-    | `Click+Drag`   | Draw bounding box (detect/OBB)                                             |
-    | `Click`        | Add polygon point (segment) / Place skeleton (pose)                        |
-    | `Right-click`  | Complete polygon / Add SAM negative point                                  |
-    | `Shift` + `click`/`right-click` | Place multiple SAM points before applying (auto-apply on) |
-    | `A`            | Toggle auto-apply (Smart mode)                                             |
-    | `Enter`        | Complete polygon / Confirm pose / Save SAM annotation                      |
-    | `Escape`       | Cancel pose / Save SAM annotation / Deselect / Exit                        |
+    | Shortcut                | Action                                                                                 |
+    | ----------------------- | -------------------------------------------------------------------------------------- |
+    | `Click+Drag`            | Draw bounding box (detect/OBB)                                                         |
+    | `Click`                 | Add polygon point (segment) / Place skeleton (pose) / Place SAM point (smart)          |
+    | `Shift (hold) + Move`   | Freehand draw — continuously adds polygon vertices as the mouse moves                  |
+    | `Click inside mask`     | Subtract region from SAM mask (negative point)                                         |
+    | `Click outside mask`    | Add to SAM mask (positive point)                                                       |
+    | `Shift (hold) + Click`  | Place multiple SAM points before auto-apply commits (Smart mode, auto-apply on)        |
+    | `A`                     | Toggle auto-apply (Smart mode)                                                         |
+    | `Enter`                 | Complete polygon / Confirm pose / Save SAM annotation                                  |
+    | `Escape`                | Cancel pose / Save SAM annotation / Deselect / Exit                                    |
 
 === "Arrange (Z-Order)"
 
@@ -468,7 +491,7 @@ Efficient annotation with keyboard shortcuts:
 The annotation editor maintains a full undo/redo history:
 
 - **Undo**: `Cmd/Ctrl+Z`
-- **Redo**: `Cmd/Ctrl+Shift+Z` or `Cmd/Ctrl+Y`
+- **Redo**: `Cmd/Ctrl+Y`
 
 History tracks:
 
@@ -506,7 +529,7 @@ SAM provides high-quality masks for most objects. Accuracy depends on:
 - Image quality and resolution
 - Number of positive/negative points provided
 
-For best results, start with a positive point on the object center and add negative points to exclude nearby objects.
+For best results, start with a click on the object center, then use outside-mask clicks to add coverage and inside-mask clicks to subtract nearby objects or background.
 
 ### Can I import existing annotations?
 
@@ -527,12 +550,12 @@ The keyboard shortcut `1-9` quickly selects classes.
 Yes, but for best results:
 
 - Label all objects of your target classes in each image
-- Use the label filter set to `Unannotated` to identify unlabeled images
-- Exclude unannotated images from training configuration
+- Use the label filter set to `Unlabeled` to identify images that still need annotation
+- Unlabeled images are excluded from training; only labeled images contribute to the loss
 
 ### Which SAM model should I use?
 
-Start with **SAM 2.1 Small** (the default) — it's fast and accurate for most objects. Switch to **SAM 2.1 Large** when you need higher mask precision on complex shapes. Use **SAM 2.1 Tiny** for maximum speed on simple, high-contrast objects. **SAM 3** is the latest generation model and may produce better results on challenging images, but is significantly slower.
+**SAM 3** is the default and the latest generation model — start there for the highest quality masks. Switch to **SAM 2.1 Small** for a faster interactive workflow on common objects, or **SAM 2.1 Large** when you need higher mask precision on complex shapes. Use **SAM 2.1 Tiny** for maximum speed on simple, high-contrast objects.
 
 ### Which tasks support SAM smart annotation?
 

docs/en/platform/data/datasets.md

@@ -6,7 +6,7 @@ keywords: Ultralytics Platform, datasets, dataset management, dataset versioning
 
 # Datasets
 
-[Ultralytics Platform](https://platform.ultralytics.com) datasets provide a streamlined solution for managing your training data. Once uploaded, datasets can be immediately used for model training, with automatic processing and statistics generation.
+[Ultralytics Platform](https://platform.ultralytics.com) datasets provide a streamlined solution for managing your training data. After upload, the platform processes images, labels, and statistics automatically. A dataset is ready to train once processing has completed and it has at least one image in the `train` split, at least one image in either the `val` or `test` split, at least one labeled image, and a total of at least two images.
 
 ## Upload Dataset
 
@@ -58,7 +58,7 @@ Ultralytics Platform accepts multiple upload formats for flexibility.
 
 ### Preparing Your Dataset
 
-The Platform supports two annotation formats plus raw uploads: [Ultralytics YOLO](../../datasets/detect/index.md#ultralytics-yolo-format), [COCO](https://cocodataset.org/#format-data), and raw (unannotated images):
+The Platform supports [Ultralytics YOLO](../../datasets/detect/index.md#ultralytics-yolo-format), [COCO](https://cocodataset.org/#format-data), [Ultralytics NDJSON](../../datasets/detect/index.md#ultralytics-ndjson-format), and raw (unannotated) uploads:
 
 === "YOLO Format"
 
@@ -125,17 +125,43 @@ The Platform supports two annotation formats plus raw uploads: [Ultralytics YOLO
 
     COCO annotations are automatically converted during upload. Detection (`bbox`), segmentation (`segmentation` polygons), and pose (`keypoints`) tasks are supported. Category IDs are remapped to a dense 0-indexed sequence across all annotation files. For converting between formats, see [format conversion tools](../../datasets/detect/index.md#port-or-convert-label-formats).
 
+=== "Classification Layouts"
+
+    Classification uploads are auto-detected from common folder layouts:
+
+    ```
+    split/class/image.jpg
+    class/split/image.jpg
+    class/image.jpg
+    ```
+
+    Example:
+
+    ```
+    my-classify-dataset/
+    ├── train/
+    │   ├── cats/
+    │   └── dogs/
+    └── val/
+        ├── cats/
+        └── dogs/
+    ```
+
+=== "NDJSON"
+
+    Ultralytics NDJSON exports can be uploaded directly back into Platform. This is useful for moving datasets between workspaces while preserving metadata, classes, splits, and annotations.
+
 !!! tip "Raw Uploads"
 
     **Raw**: Upload unannotated images (no labels). Useful when you plan to annotate directly on the platform using the [annotation editor](annotation.md).
 
 !!! tip "Flat Directory Structure"
 
-    You can also upload images without the train/val folder structure. Images uploaded without split folders are assigned to the `train` split by default. You can reassign them later using the bulk move-to-split feature.
+    You can also upload images without explicit split folders. Platform respects the active split target during upload, and for non-classify datasets it may automatically create a validation split from part of the training set when no split information is provided. You can always reassign images later with bulk move-to-split or split redistribution.
 
 !!! tip "Format Auto-Detection"
 
-    The format is detected automatically: datasets with a `data.yaml` containing `names`, `train`, or `val` keys are treated as YOLO. Datasets with COCO JSON files (containing `images`, `annotations`, and `categories` arrays) are treated as COCO. Datasets with only images and no annotations are treated as raw.
+    The format is detected automatically: datasets with a `data.yaml` containing `names`, `train`, or `val` keys are treated as YOLO. Datasets with COCO JSON files (containing `images`, `annotations`, and `categories` arrays) are treated as COCO. `.ndjson` exports are imported as Ultralytics NDJSON. Datasets with only images and no annotations are treated as raw.
 
 For task-specific format details, see [supported tasks](index.md#supported-tasks) and the [Datasets Overview](../../datasets/index.md).
 
@@ -208,28 +234,31 @@ Images can be sorted and filtered for efficient browsing:
 
 === "Sort Options"
 
-    | Sort            | Description          |
-    | --------------- | -------------------- |
-    | Newest          | Most recently added  |
-    | Oldest          | Earliest added       |
-    | Name A-Z        | Alphabetical         |
-    | Name Z-A        | Reverse alphabetical |
-    | Size (smallest) | Smallest files first |
-    | Size (largest)  | Largest files first  |
-    | Most labels     | Most annotations     |
-    | Fewest labels   | Fewest annotations   |
+    | Sort                 | Description                  |
+    | -------------------- | ---------------------------- |
+    | Newest / Oldest      | Upload / creation order      |
+    | Name A-Z / Z-A       | Filename alphabetical        |
+    | Height ↑/↓           | Image height in pixels       |
+    | Width ↑/↓            | Image width in pixels        |
+    | Size ↑/↓             | File size on disk            |
+    | Annotations ↑/↓      | Annotation count per image   |
+
+    !!! note "Large Datasets"
+
+        For datasets over 100,000 images, name / size / width / height sorts are disabled to keep the gallery responsive. Newest, oldest, and annotation-count sorts remain available.
 
 === "Filters"
 
-    | Filter           | Options                            |
-    | ---------------- | ---------------------------------- |
-    | **Split filter** | Train, Val, Test, or All           |
-    | **Label filter** | All images, Annotated, or Unannotated |
-    | **Search**       | Filter images by filename          |
+    | Filter           | Options                             |
+    | ---------------- | ----------------------------------- |
+    | **Split filter** | Train, Val, Test, or All            |
+    | **Label filter** | All, Labeled, or Unlabeled          |
+    | **Class filter** | Filter by class name                |
+    | **Search**       | Filter images by filename           |
 
 !!! tip "Finding Unlabeled Images"
 
-    Use the label filter set to `Unannotated` to quickly find images that still need annotation. This is especially useful for large datasets where you want to track labeling progress.
+    Use the label filter set to `Unlabeled` to quickly find images that still need annotation. This is especially useful for large datasets where you want to track labeling progress.
 
 ### Fullscreen Viewer
 
@@ -242,7 +271,9 @@ Click any image to open the fullscreen viewer with:
 - **Edit**: Enter annotation mode to add or modify labels
 - **Download**: Download the original image file
 - **Delete**: Delete the image from the dataset
-- **Zoom**: `Cmd/Ctrl+Scroll` to zoom in/out
+- **Zoom**: `Cmd/Ctrl+Scroll`, `Cmd/Ctrl++`, or `Cmd/Ctrl+=` to zoom in, and `Cmd/Ctrl+-` to zoom out
+- **Reset view**: `Cmd/Ctrl + 0` or the reset button to fit the image to the viewer
+- **Pan**: Hold `Space` and drag to pan the canvas when zoomed
 - **Pixel view**: Toggle pixelated rendering for close inspection
 
 ![Ultralytics Platform Datasets Fullscreen Viewer With Metadata Panel](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-datasets-fullscreen-viewer-with-metadata-panel.avif)
@@ -259,7 +290,7 @@ Filter images by their dataset split:
 
 ## Dataset Tabs
 
-Each dataset page has six tabs accessible from the tab bar:
+Each dataset page can show up to six tabs, depending on the dataset state and your permissions:
 
 ### Images Tab
 
@@ -267,6 +298,8 @@ The default view showing the image gallery with annotation overlays. Supports gr
 
 ### Classes Tab
 
+This tab appears when the dataset has images.
+
 Manage annotation classes for your dataset:
 
 - **Class histogram**: Bar chart showing annotation count per class with linear/log scale toggle
@@ -283,6 +316,8 @@ Manage annotation classes for your dataset:
 
 ### Charts Tab
 
+This tab appears when the dataset has images.
+
 Automatic statistics computed from your dataset:
 
 | Chart                    | Description                                                    |
@@ -324,6 +359,8 @@ View all models trained on this dataset in a searchable table:
 
 ### Errors Tab
 
+This tab appears only when one or more files fail processing.
+
 Images that failed processing are listed here with:
 
 - **Error banner**: Total count of failed images and guidance
@@ -360,10 +397,15 @@ To create a version:
 1. Open the **Versions** tab
 2. Optionally enter a description (e.g., "Added 500 training images" or "Fixed mislabeled classes")
 3. Click **+ New Version**
-4. The NDJSON snapshot is generated and downloads automatically
+4. The new version appears in the table
+5. Download the version separately from the table when needed
 
 Each version is numbered sequentially (v1, v2, v3...) and stored permanently. You can download any previous version at any time from the versions table.
 
+!!! note "Ready Datasets Only"
+
+    Version creation is available after the dataset reaches `ready` status.
+
 !!! tip "When to Create Versions"
 
     Create a version before and after major changes to your dataset — adding images, fixing annotations, or rebalancing splits. This lets you compare model performance across different dataset states.
@@ -374,20 +416,13 @@ Each version is numbered sequentially (v1, v2, v3...) and stored permanently. Yo
 
 ## Export Dataset
 
-Export your dataset for offline use. The Platform supports multiple export formats:
-
-| Format         | Description                                        |
-| -------------- | -------------------------------------------------- |
-| **YOLO**       | Standard YOLO format with images and `.txt` labels |
-| **COCO**       | COCO JSON format with annotation arrays            |
-| **Pascal VOC** | XML annotation files per image                     |
-| **NDJSON**     | One JSON object per line (lightweight metadata)    |
+Export your dataset for offline use with an NDJSON download from the dataset header or the Versions tab.
 
 To export:
 
 1. Click the **Export** button in the dataset header
-2. Select the desired format
-3. The export job runs asynchronously — you'll be notified when the download is ready
+2. Download the current NDJSON snapshot directly
+3. Use the **Versions** tab when you want an immutable numbered snapshot you can re-download later
 
 ![Ultralytics Platform Datasets Export Ndjson Download](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-datasets-export-ndjson-download.avif)
 
@@ -438,14 +473,30 @@ You can also drag and drop images onto the split filter tabs in grid view.
 
     Upload all images to one dataset, then use bulk move-to-split to organize subsets into train, validation, and test splits.
 
-### Auto Split Redistribution
+### Split Redistribution
 
-Automatically distribute images across train, validation, and test splits:
+Redistribute all images across train, validation, and test splits using custom ratios:
 
-1. Click the split redistribution button in the dataset toolbar
-2. The Platform automatically assigns images to splits based on standard ratios
+1. Click the **split bar** in the dataset toolbar to open the **Redistribute Splits** dialog
+2. Adjust split percentages using any of the methods below
+3. Review the live image count preview to confirm the distribution
+4. Click **Apply** to randomly reassign all images according to your percentages
 
-This is useful when you upload images without split folders and want to quickly organize them for training.
+![Ultralytics Platform Datasets Split Redistribution Dialog](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-datasets-split-redistribution-dialog.avif)
+
+The dialog provides three ways to set your target split ratios:
+
+| Method   | Description                                                                                  |
+| -------- | -------------------------------------------------------------------------------------------- |
+| **Drag** | Drag the handles between the colored segments to visually adjust split boundaries            |
+| **Type** | Edit the percentage input for any split (the other two splits auto-rebalance proportionally) |
+| **Auto** | One-click to instantly set an 80/20 train/validation split with the test split set to 0%     |
+
+A live preview shows exactly how many images will land in each split before you apply.
+
+!!! tip "Quick 80/20 Split"
+
+    Click the **Auto** button to instantly set the recommended 80/20 train/validation split. This is the most common ratio for training.
 
 ### Bulk Delete
 
@@ -617,7 +668,7 @@ Use the bulk move-to-split feature:
 
 ### What label formats are supported?
 
-Ultralytics Platform supports two annotation formats for upload:
+Ultralytics Platform supports YOLO labels, COCO JSON, Ultralytics NDJSON, and raw image uploads:
 
 === "YOLO Format"
 
@@ -637,6 +688,10 @@ Ultralytics Platform supports two annotation formats for upload:
 
     JSON files with `images`, `annotations`, and `categories` arrays. Supports detection (`bbox`), segmentation (polygon), and pose (`keypoints`) tasks. COCO uses absolute pixel coordinates which are automatically converted to normalized format during upload.
 
+=== "NDJSON"
+
+    Ultralytics NDJSON exports can be re-imported into Platform. This is the most complete way to move dataset metadata, splits, and annotations between workspaces.
+
 ### Can I annotate the same dataset for multiple task types?
 
 Yes. Each image stores annotations for all 5 task types (detect, segment, pose, OBB, classify) together. You can switch the dataset's active task type at any time without losing existing annotations. Only annotations matching the active task type are shown in the editor and included in exports and training — annotations for other tasks are preserved and reappear when you switch back.

docs/en/platform/data/index.md

@@ -65,7 +65,7 @@ Ultralytics Platform supports all 5 YOLO task types:
 
 !!! info "Task Type Selection"
 
-    The task type is set when creating a dataset and determines which annotation tools are available. You can change it later from the dataset settings, but incompatible annotations won't be displayed after switching.
+    The task type is set when creating a dataset and determines which annotation tools are available. You can change it later from the dataset header task selector, but incompatible annotations won't be displayed after switching.
 
 ## Key Features
 
@@ -102,7 +102,7 @@ Create immutable NDJSON snapshots of your dataset for reproducible training. Eac
 
 ### Dataset Tabs
 
-Every dataset page provides six tabs:
+Dataset pages can show up to six tabs, depending on the dataset state and your permissions:
 
 | Tab          | Description                                                                  |
 | ------------ | ---------------------------------------------------------------------------- |
@@ -113,6 +113,8 @@ Every dataset page provides six tabs:
 | **Versions** | Create and download immutable NDJSON snapshots for reproducible training     |
 | **Errors**   | Images that failed processing with error details and fix guidance            |
 
+`Classes` and `Charts` appear when the dataset has images. `Errors` appears only when processing failures exist. `Versions` appears for owners, or for non-owners when versions already exist.
+
 ### Statistics and Visualization
 
 The `Charts` tab provides automatic analysis including:

docs/en/platform/deploy/endpoints.md

@@ -1,12 +1,12 @@
 ---
 comments: true
-description: Deploy YOLO models to dedicated endpoints in 43 global regions with auto-scaling and monitoring on Ultralytics Platform.
+description: Deploy YOLO models to dedicated endpoints in 43 global regions with scale-to-zero behavior and monitoring on Ultralytics Platform.
 keywords: Ultralytics Platform, deployment, endpoints, YOLO, production, scaling, global regions
 ---
 
 # Dedicated Endpoints
 
-[Ultralytics Platform](https://platform.ultralytics.com) enables deployment of YOLO models to dedicated endpoints in 43 global regions. Each endpoint is a single-tenant service with auto-scaling, a unique endpoint URL, and independent monitoring.
+[Ultralytics Platform](https://platform.ultralytics.com) enables deployment of YOLO models to dedicated endpoints in 43 global regions. Each endpoint is a single-tenant service with scale-to-zero behavior, a unique endpoint URL, and independent monitoring.
 
 ![Ultralytics Platform Model Deploy Tab With Region Map And Table](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/model-deploy-tab-with-region-map-and-table.avif)
 
@@ -30,7 +30,7 @@ Create a deployment from the global `Deploy` page in the sidebar:
 1. Click **New Deployment**
 2. Select a model from the model selector
 3. Select a region from the map or table
-4. Optionally customize the deployment name and resources
+4. Review the auto-generated deployment name (editable) and the default resources
 5. Click **Deploy Model**
 
 ![Ultralytics Platform New Deployment Dialog With Model Selector And Region Map](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/new-deployment-dialog-with-model-selector-and-region-map.avif)
@@ -157,12 +157,12 @@ The `New Deployment` dialog provides:
 | **Model**           | Select from completed models | -       |
 | **Region**          | Deployment region            | -       |
 | **Deployment Name** | Auto-generated, editable     | -       |
-| **CPU Cores**       | CPU allocation (1-8)         | 1       |
-| **Memory (GB)**     | Memory allocation (1-32 GB)  | 2       |
+| **CPU Cores**       | Fixed default                | 1       |
+| **Memory (GB)**     | Fixed default                | 2       |
 
 ![Ultralytics Platform New Deployment Dialog Resources Panel Expanded](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/new-deployment-dialog-resources-panel-expanded.avif)
 
-Resource settings are available under the collapsible **Resources** section. Deployments use scale-to-zero by default (min instances = 0, max instances = 1) — you only pay for active inference time.
+Deployments use fixed defaults of `1 CPU`, `2 GiB` memory, `minInstances = 0`, and `maxInstances = 1`. They scale to zero when idle, so you only pay for active inference time.
 
 !!! note "Auto-Generated Names"
 
@@ -344,17 +344,24 @@ Dedicated endpoints are **not subject to the Platform API rate limits**. Request
 
 ### Request Parameters
 
-| Parameter   | Type   | Default | Description                    |
-| ----------- | ------ | ------- | ------------------------------ |
-| `file`      | file   | -       | Image or video file (required) |
-| `conf`      | float  | 0.25    | Minimum confidence threshold   |
-| `iou`       | float  | 0.7     | NMS IoU threshold              |
-| `imgsz`     | int    | 640     | Input image size               |
-| `normalize` | string | -       | Return normalized coordinates  |
+| Parameter   | Type   | Default | Range      | Description                                        |
+| ----------- | ------ | ------- | ---------- | -------------------------------------------------- |
+| `file`      | file   | -       | -          | Image or video file (required)                     |
+| `conf`      | float  | 0.25    | 0.01 – 1.0 | Minimum confidence threshold                       |
+| `iou`       | float  | 0.7     | 0.0 – 0.95 | NMS IoU threshold                                  |
+| `imgsz`     | int    | 640     | 32 – 1280  | Input image size in pixels                         |
+| `normalize` | bool   | false   | -          | Return bounding box coordinates as 0 – 1           |
+| `decimals`  | int    | 5       | 0 – 10     | Decimal precision for coordinate values            |
+| `source`    | string | -       | -          | Image URL or base64 string (alternative to `file`) |
 
 !!! tip "Video Inference"
 
-    Dedicated endpoints accept video files in addition to images. Supported video formats (up to 100MB): ASF, AVI, GIF, M4V, MKV, MOV, MP4, MPEG, MPG, TS, WEBM, WMV. Each frame is processed individually and results are returned per frame. Supported image formats (up to 50MB): AVIF, BMP, DNG, HEIC, JP2, JPEG, JPG, MPO, PNG, TIF, TIFF, WEBP.
+    Dedicated endpoints accept both images and videos via the `file` parameter.
+
+    - **Image formats** (up to 50 MB): AVIF, BMP, DNG, HEIC, JP2, JPEG, JPG, MPO, PNG, TIF, TIFF, WEBP
+    - **Video formats** (up to 100 MB): ASF, AVI, GIF, M4V, MKV, MOV, MP4, MPEG, MPG, TS, WEBM, WMV
+
+    Each video frame is processed individually and results are returned per frame. You can also pass a public image URL or a base64-encoded image via the `source` parameter instead of `file`.
 
 ### Response Format
 

docs/en/platform/deploy/index.md

@@ -26,7 +26,7 @@ The Deployment section helps you:
 - **Test** models directly in the browser with the `Predict` tab
 - **Deploy** to dedicated endpoints in 43 global regions
 - **Monitor** request metrics, logs, and health checks
-- **Scale** automatically with traffic (including scale-to-zero)
+- **Scale to zero** when idle (deployments currently run a single active instance)
 
 ![Ultralytics Platform Deploy Page World Map With Overview Cards](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/deploy-page-world-map-with-overview-cards.avif)
 
@@ -54,12 +54,12 @@ graph LR
     style D fill:#9C27B0,color:#fff
 ```
 
-| Stage         | Description                                                              |
-| ------------- | ------------------------------------------------------------------------ |
-| **Test**      | Validate model with the [`Predict` tab](inference.md)                    |
-| **Configure** | Select region, resources, and deployment name                            |
-| **Deploy**    | Create a dedicated endpoint from the [`Deploy` tab](endpoints.md)        |
-| **Monitor**   | Track requests, latency, errors, and logs in [Monitoring](monitoring.md) |
+| Stage         | Description                                                                 |
+| ------------- | --------------------------------------------------------------------------- |
+| **Test**      | Validate model with the [`Predict` tab](inference.md)                       |
+| **Configure** | Select region and deployment name (deployments use fixed default resources) |
+| **Deploy**    | Create a dedicated endpoint from the [`Deploy` tab](endpoints.md)           |
+| **Monitor**   | Track requests, latency, errors, and logs in [Monitoring](monitoring.md)    |
 
 ## Architecture
 
@@ -73,7 +73,7 @@ graph TB
     API --> Router{Region Router}
     Router -->|US users| US["US Predict Service<br/>Iowa"]
     Router -->|EU users| EU["EU Predict Service<br/>Belgium"]
-    Router -->|AP users| AP["AP Predict Service<br/>Hong Kong"]
+    Router -->|AP users| AP["AP Predict Service<br/>Taiwan"]
 
     style User fill:#f5f5f5,color:#333
     style API fill:#2196F3,color:#fff
@@ -83,11 +83,11 @@ graph TB
     style AP fill:#4CAF50,color:#fff
 ```
 
-| Region | Location                |
-| ------ | ----------------------- |
-| US     | Iowa, USA               |
-| EU     | Belgium, Europe         |
-| AP     | Hong Kong, Asia-Pacific |
+| Region | Location             |
+| ------ | -------------------- |
+| US     | Iowa, USA            |
+| EU     | Belgium, Europe      |
+| AP     | Taiwan, Asia-Pacific |
 
 ### Dedicated Endpoints
 
@@ -100,8 +100,8 @@ Deploy to 43 regions worldwide on Ultralytics Cloud:
 
 Each endpoint is a single-tenant service with:
 
-- Dedicated compute resources (configurable CPU and memory)
-- Auto-scaling (scale-to-zero when idle)
+- Default resources of `1 CPU`, `2 GiB` memory, `minInstances=0`, `maxInstances=1`
+- Scale-to-zero when idle
 - Unique endpoint URL
 - Independent monitoring, logs, and health checks
 
@@ -118,7 +118,7 @@ Access the global deployments page from the sidebar under `Deploy`. This page sh
 
 !!! info "Automatic Polling"
 
-    The page polls every 30 seconds for metric updates. When deployments are in a transitional state (creating, deploying, stopping), polling increases to every 2-3 seconds for near-instant feedback.
+    The page polls every 15 seconds normally. When deployments are in a transitional state (`creating`, `deploying`, or `stopping`), polling increases to every 3 seconds for faster feedback.
 
 ## Key Features
 
@@ -130,12 +130,12 @@ Deploy close to your users with 43 regions covering:
 - Europe, Middle East, Africa
 - Asia Pacific, Oceania
 
-### Auto-Scaling
+### Scaling Behavior
 
-Endpoints scale automatically:
+Endpoints currently behave as follows:
 
 - **Scale to zero**: No cost when idle (default)
-- **Scale up**: Handle traffic spikes automatically
+- **Single active instance**: `maxInstances` is currently capped at `1` on all plans
 
 !!! tip "Cost Savings"
 
@@ -189,7 +189,7 @@ Deploy a model in under 2 minutes:
 | ----------- | --------------- | ------------------------------------ |
 | **Latency** | Variable        | Consistent                           |
 | **Cost**    | Free (included) | Free (basic), usage-based (advanced) |
-| **Scale**   | Limited         | Configurable                         |
+| **Scale**   | Limited         | Scale-to-zero, single instance       |
 | **Regions** | 3               | 43                                   |
 | **URL**     | Generic         | Custom                               |
 | **Rate**    | 20 req/min      | Unlimited                            |
@@ -204,7 +204,7 @@ Dedicated endpoint deployment typically takes 1-2 minutes:
 
 ### Can I deploy multiple models?
 
-Yes, each model can have multiple endpoints in different regions. There's no limit on total endpoints (subject to your plan).
+Yes, each model can have multiple endpoints in different regions. Deployment counts are limited by plan: Free `3`, Pro `10`, Enterprise `unlimited`.
 
 ### What happens when an endpoint is idle?
 

docs/en/platform/deploy/inference.md

@@ -103,11 +103,11 @@ Adjust detection behavior with parameters in the collapsible **Parameters** sect
 
 ![Ultralytics Platform Predict Tab Parameters Sliders](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/predict-tab-parameters-sliders.avif)
 
-| Parameter      | Range          | Default | Description                            |
-| -------------- | -------------- | ------- | -------------------------------------- |
-| **Confidence** | 0.01-1.0       | 0.25    | Minimum confidence threshold           |
-| **IoU**        | 0.0-0.95       | 0.70    | NMS IoU threshold                      |
-| **Image Size** | 320, 640, 1280 | 640     | Input resize dimension (button toggle) |
+| Parameter      | Range                      | Default | Description                                              |
+| -------------- | -------------------------- | ------- | -------------------------------------------------------- |
+| **Confidence** | 0.01 – 1.0                 | 0.25    | Minimum confidence threshold                             |
+| **IoU**        | 0.0 – 0.95                 | 0.7     | NMS IoU threshold                                        |
+| **Image Size** | 320, 640, 1280 (UI toggle) | 640     | Input resize dimension (API accepts any value 32 – 1280) |
 
 !!! note "Auto-Rerun"
 
@@ -127,7 +127,7 @@ Control Non-Maximum Suppression:
 
 - **Higher (0.7+)**: Allow more overlapping boxes
 - **Lower (0.3-0.5)**: Merge nearby detections more aggressively
-- **Default (0.70)**: Balanced NMS behavior for most use cases
+- **Default (0.7)**: Balanced NMS behavior for most use cases
 
 ## Deployment Predict
 
@@ -147,11 +147,11 @@ Authorization: Bearer YOUR_API_KEY
 
 !!! warning "API Key Required"
 
-    To run inference from your own scripts, notebooks, or apps, include an API key. Generate one in [`Settings`](../account/api-keys.md) (API Keys section on the Profile tab).
+    To run inference from your own scripts, notebooks, or apps, include an API key. Generate one in [`Settings > API Keys`](../account/api-keys.md).
 
 ### Endpoint
 
-```
+```http
 POST https://platform.ultralytics.com/api/models/{modelId}/predict
 ```
 
@@ -359,10 +359,10 @@ Common error responses:
 
 ### Can I run inference on video?
 
-It depends on the inference method:
+Both inference methods accept video files:
 
-- **Dedicated endpoints** accept video files directly. Supported formats (up to 100MB): ASF, AVI, GIF, M4V, MKV, MOV, MP4, MPEG, MPG, TS, WEBM, WMV. Each frame is processed individually and results are returned per frame. See [dedicated endpoints](endpoints.md#request-parameters) for details.
-- **Shared inference** (`/api/models/{id}/predict`) accepts images only. For video, extract frames locally, send each frame as a separate request, and aggregate results.
+- **Dedicated endpoints** accept video files directly. Supported formats (up to 100 MB): ASF, AVI, GIF, M4V, MKV, MOV, MP4, MPEG, MPG, TS, WEBM, WMV. Each frame is processed individually and results are returned per frame. See [dedicated endpoints](endpoints.md#request-parameters) for details.
+- **Shared inference** (`/api/models/{id}/predict`) uses the same predict service and accepts the same video formats. However, the browser **Predict tab** in the UI only uploads images — use the REST API directly or a [dedicated endpoint](endpoints.md) for video workflows. The shared endpoint is also [rate-limited to 20 req/min](../api/index.md#per-api-key-limits), so dedicated endpoints are the better choice for heavy video workloads.
 
 ### How do I get the annotated image?
 

docs/en/platform/deploy/monitoring.md

@@ -79,7 +79,7 @@ Below the overview cards, the deployments list shows all endpoints across your p
 
 !!! tip "Real-Time Updates"
 
-    The dashboard polls every 30 seconds for deployment status updates. When deployments are in a transitional state (creating, deploying), polling increases to every 3 seconds. Metric charts refresh every 60 seconds. Click the refresh button for immediate updates.
+    The dashboard polls every 15 seconds for deployment status updates. When deployments are in a transitional state (`creating`, `deploying`, or `stopping`), polling increases to every 3 seconds. Metric charts refresh every 60 seconds. Click the refresh button for immediate updates.
 
 ## Per-Deployment Metrics
 
@@ -230,7 +230,7 @@ The `Predict` tab on each deployment card provides an inline predict panel — t
 
 ### Monitoring Overview
 
-```
+```http
 GET /api/monitoring
 ```
 
@@ -238,7 +238,7 @@ Returns aggregated metrics for all deployments owned by the authenticated user.
 
 ### Deployment Metrics
 
-```
+```http
 GET /api/deployments/{deploymentId}/metrics?sparkline=true&range=24h
 ```
 
@@ -251,7 +251,7 @@ Returns sparkline data and summary metrics for a specific deployment. Refresh in
 
 ### Deployment Logs
 
-```
+```http
 GET /api/deployments/{deploymentId}/logs?limit=50&severity=ERROR,WARNING
 ```
 
@@ -265,7 +265,7 @@ Returns recent log entries with optional severity filter and pagination.
 
 ### Deployment Health
 
-```
+```http
 GET /api/deployments/{deploymentId}/health
 ```
 

docs/en/platform/explore.md

@@ -197,12 +197,12 @@ See [Projects](train/projects.md) for organizing models in your project.
 
 Official `@ultralytics` content is pinned to the top of the Explore page. This includes:
 
-| Project                           | Description                 | Models                       | Tasks                                |
-| --------------------------------- | --------------------------- | ---------------------------- | ------------------------------------ |
-| **[YOLO26](../models/yolo26.md)** | Latest January 2026 release | 25 models (all sizes, tasks) | detect, segment, pose, OBB, classify |
-| **[YOLO11](../models/yolo11.md)** | Current stable release      | 10+ models                   | detect, segment, pose, OBB, classify |
-| **YOLOv8**                        | Previous generation         | Various                      | detect, segment, pose, classify      |
-| **YOLOv5**                        | Legacy, widely adopted      | Various                      | detect, segment, classify            |
+| Project                           | Description                 | Models                         | Tasks                                |
+| --------------------------------- | --------------------------- | ------------------------------ | ------------------------------------ |
+| **[YOLO26](../models/yolo26.md)** | Latest January 2026 release | 25 models (5 sizes × 5 tasks)  | detect, segment, pose, OBB, classify |
+| **[YOLO11](../models/yolo11.md)** | Current stable release      | 25 models (5 sizes × 5 tasks)  | detect, segment, pose, OBB, classify |
+| **YOLOv8**                        | Previous generation         | 20+ models (5 sizes × 4 tasks) | detect, segment, pose, classify      |
+| **YOLOv5**                        | Legacy, widely adopted      | 15+ models                     | detect, segment, classify            |
 
 Official datasets include benchmark datasets like [coco8](../datasets/detect/coco8.md) (8-image COCO subset), [VOC](../datasets/detect/voc.md), [african-wildlife](../datasets/detect/african-wildlife.md), [dota8](../datasets/obb/dota8.md), and other commonly used computer vision datasets.
 
@@ -343,12 +343,12 @@ Contact creators for commercial licensing.
 To report inappropriate content:
 
 1. Navigate to the public page containing the content (project or dataset), if accessible
-2. Click the **Feedback** button in the sidebar
+2. Open the **Help** page from the sidebar
 3. Select **General** as the feedback type
 4. Describe the content and the issue, including a link to the page
 5. Submit the report
 
-If the content is no longer accessible, use the **Feedback** button from any page and include as much detail as possible (URL, username, or description).
+If the content is no longer accessible, use the **Help** page from any page and include as much detail as possible (URL, username, or description).
 
 Our team reviews reports within 24-48 hours.
 

docs/en/platform/index.md

@@ -62,19 +62,19 @@ graph LR
     Data --> Train --> Deploy
 ```
 
-| Stage        | Features                                                                                                                                       |
-| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Upload**   | Images (50MB), videos (1GB), and dataset files (ZIP, TAR including `.tar.gz`/`.tgz`, NDJSON) with automatic processing                         |
-| **Annotate** | Manual tools, SAM smart annotation, YOLO auto-labeling for all 5 task types (see [supported tasks](data/index.md#supported-tasks))             |
-| **Train**    | Cloud GPUs (20 free + 3 Pro-exclusive), real-time metrics, project organization                                                                |
-| **Export**   | [17 deployment formats](../modes/export.md) (ONNX, TensorRT, CoreML, TFLite, etc.; see [supported formats](train/models.md#supported-formats)) |
-| **Deploy**   | 43 global regions with dedicated endpoints, auto-scaling, monitoring                                                                           |
+| Stage        | Features                                                                                                                                                                                                     |
+| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Upload**   | Images (50MB), videos (1GB), and dataset files (ZIP, TAR including `.tar.gz`/`.tgz`, NDJSON) with automatic processing                                                                                       |
+| **Annotate** | Manual tools for all 5 task types, plus [Smart Annotation](data/annotation.md#smart-annotation) with SAM and YOLO models for detect, segment, and OBB (see [supported tasks](data/index.md#supported-tasks)) |
+| **Train**    | Cloud GPUs (20 on all plans + 3 Pro/Enterprise-only: H200 NVL, H200 SXM, B200), real-time metrics, project organization                                                                                      |
+| **Export**   | [17 deployment formats](../modes/export.md) (ONNX, TensorRT, CoreML, TFLite, etc.; see [supported formats](train/models.md#supported-formats))                                                               |
+| **Deploy**   | 43 global regions with dedicated endpoints, scale-to-zero by default (single active instance), and monitoring                                                                                                |
 
 **What you can do:**
 
 - **Upload** images, videos, and dataset files to create training datasets
 - **Visualize** annotations with interactive overlays for all 5 YOLO task types (see [supported tasks](data/index.md#supported-tasks))
-- **Train** models on cloud GPUs (20 free, 23 with Pro) with real-time metrics
+- **Train** models on cloud GPUs (20 on all plans, 23 with Pro or Enterprise for H200 and B200) with real-time metrics
 - **Export** to [17 deployment formats](../modes/export.md) (ONNX, TensorRT, CoreML, TFLite, etc.)
 - **Deploy** to 43 global regions with one-click dedicated endpoints
 - **Monitor** training progress, deployment health, and usage metrics
@@ -84,11 +84,11 @@ graph LR
 
 Your data stays in your region. Ultralytics Platform operates infrastructure in three global regions:
 
-| Region | Label                        | Location                | Best For                                |
-| ------ | ---------------------------- | ----------------------- | --------------------------------------- |
-| **US** | Americas                     | Iowa, USA               | Americas users, fastest for Americas    |
-| **EU** | Europe, Middle East & Africa | Belgium, Europe         | European users, GDPR compliance         |
-| **AP** | Asia Pacific                 | Hong Kong, Asia-Pacific | Asia-Pacific users, lowest APAC latency |
+| Region | Label                        | Location             | Best For                                |
+| ------ | ---------------------------- | -------------------- | --------------------------------------- |
+| **US** | Americas                     | Iowa, USA            | Americas users, fastest for Americas    |
+| **EU** | Europe, Middle East & Africa | Belgium, Europe      | European users, GDPR compliance         |
+| **AP** | Asia Pacific                 | Taiwan, Asia-Pacific | Asia-Pacific users, lowest APAC latency |
 
 You select your region during onboarding, and all your data, models, and deployments remain in that region.
 
@@ -103,8 +103,7 @@ You select your region during onboarding, and all your data, models, and deploym
 - **Dataset Management**: Upload images, videos, or dataset files with automatic processing
 - **Annotation Editor**: Manual annotation for all 5 YOLO task types (detect, segment, pose, OBB, classify; see [supported tasks](data/index.md#supported-tasks))
 - **Skeleton Templates**: Built-in (Person, Hand, Face, Dog, Box) and custom skeleton templates for one-click pose annotation
-- **SAM Smart Annotation**: Click-based intelligent annotation with 5 models — [SAM 2.1](../models/sam-2.md) (Tiny, Small, Base, Large) and the new [SAM 3](../models/sam-3.md) for highest accuracy. Switch models per-image from the annotation toolbar.
-- **Auto-Annotation**: Use trained models to pre-label new data
+- **Smart Annotation**: Use [SAM 2.1](../models/sam-2.md) (Tiny, Small, Base, Large), [SAM 3](../models/sam-3.md), pretrained Ultralytics YOLO models, or your own fine-tuned YOLO models from the annotation toolbar for detect, segment, and OBB tasks
 - **Dataset Versioning**: Create numbered NDJSON snapshots with descriptions for reproducible training
 - **Statistics**: Class distribution, location heatmaps, and dimension analysis
 
@@ -127,7 +126,7 @@ graph LR
 
 ### Model Training
 
-- **Cloud Training**: Train on cloud GPUs (20 free, 23 with [Pro](account/billing.md#plans)) with real-time metrics
+- **Cloud Training**: Train on cloud GPUs (20 on all plans, 23 with [Pro or Enterprise](account/billing.md#plans) for H200 and B200) with real-time metrics
 - **Remote Training**: Train anywhere and stream metrics to the platform (W&B-style)
 - **Project Organization**: Group related models, compare experiments, track activity
 - **17 Export Formats**: ONNX, TensorRT, CoreML, TFLite, and more (see [supported formats](train/models.md#supported-formats))
@@ -147,7 +146,7 @@ You can train models either through the web UI (cloud training) or from your own
 
     ```bash
     # Install ultralytics
-    pip install "ultralytics>=8.4.14"
+    pip install "ultralytics>=8.4.35"
 
     # Set your API key
     export ULTRALYTICS_API_KEY="YOUR_API_KEY"
@@ -178,7 +177,7 @@ You can train models either through the web UI (cloud training) or from your own
 ### Deployment
 
 - **Inference Testing**: Test models directly in the browser with custom images
-- **Dedicated Endpoints**: Deploy to 43 global regions with auto-scaling
+- **Dedicated Endpoints**: Deploy to 43 global regions with scale-to-zero by default (single active instance)
 - **Monitoring**: Real-time metrics, request logs, and performance dashboards
 
 ```mermaid
@@ -244,17 +243,17 @@ Once deployed, call your endpoint from any language:
 
 !!! info "Plan Tiers"
 
-    | Feature              | Free           | Pro ($29/mo)        | Enterprise     |
-    | -------------------- | -------------- | ------------------- | -------------- |
-    | Signup Credit        | $5 / $25*      | -                   | Custom         |
-    | Monthly Credit       | -              | $30/seat/month      | Custom         |
-    | Models               | 100            | 500                 | Unlimited      |
-    | Concurrent Trainings | 3              | 10                  | Unlimited      |
-    | Deployments          | 3              | 10                  | Unlimited      |
-    | Storage              | 100 GB         | 500 GB              | Unlimited      |
-    | Cloud GPU Types      | 20             | 23 (incl. H200/B200)| 23             |
-    | Teams                | -              | Up to 5 members     | Up to 50       |
-    | Support              | Community      | Priority            | Dedicated      |
+    | Feature              | Free           | Pro ($29/mo)            | Enterprise     |
+    | -------------------- | -------------- | ----------------------- | -------------- |
+    | Signup Credit        | $5 / $25*      | -                       | Custom         |
+    | Monthly Credit       | -              | $30/seat/month          | Custom         |
+    | Models               | 100            | 500                     | Unlimited      |
+    | Concurrent Trainings | 3              | 10                      | Unlimited      |
+    | Deployments          | 3              | 10                      | Unlimited      |
+    | Storage              | 100 GB         | 500 GB                  | Unlimited      |
+    | Cloud GPU Types      | 20             | 23 (incl. H200 / B200)  | 23             |
+    | Teams                | -              | Up to 5 members         | Up to 50       |
+    | Support              | Community      | Priority                | Dedicated      |
 
     *$5 at signup, or $25 with a verified company/work email.
 
@@ -300,7 +299,7 @@ For a detailed guide, see the [Quickstart](quickstart.md) page.
 - **Real-Time Metrics**: Stream training progress and monitor deployments
 - **43 Deploy Regions**: Deploy models close to your users worldwide
 - **5 Task Types**: Support for detection, segmentation, pose, OBB, and classification (see [task docs](../tasks/index.md))
-- **AI-Assisted Annotation**: SAM and auto-labeling to speed up data preparation
+- **AI-Assisted Annotation**: [Smart annotation](data/annotation.md#smart-annotation) with SAM and YOLO models to speed up data preparation
 
 ### What GPU options are available for cloud training?
 
@@ -316,10 +315,10 @@ You can train models on your own hardware and stream real-time metrics to the pl
 
 !!! warning "Package Version Requirement"
 
-    Platform integration requires **ultralytics>=8.4.14**. Lower versions will NOT work with Platform.
+    Platform integration requires **ultralytics>=8.4.35**. Lower versions will NOT work with Platform.
 
     ```bash
-    pip install "ultralytics>=8.4.14"
+    pip install "ultralytics>=8.4.35"
     ```
 
 === "CLI"
@@ -367,19 +366,19 @@ The Platform includes a full-featured annotation editor supporting:
 
 - **Manual Tools**: Bounding boxes, polygons, keypoints with skeleton templates, oriented boxes, classification
 - **Skeleton Templates**: Place all keypoints at once using built-in (Person, Hand, Face, Dog, Box) or custom templates
-- **SAM Smart Annotation**: Click to generate precise masks — choose from [SAM 2.1](../models/sam-2.md) Tiny/Small/Base/Large or the new [SAM 3](../models/sam-3.md) via the toolbar model picker
+- **Smart Annotation**: Use [SAM 2.1](../models/sam-2.md) or [SAM 3](../models/sam-3.md) for click-based annotation, or run pretrained Ultralytics YOLO models and your own fine-tuned YOLO models from the toolbar for detect, segment, and OBB
 - **Keyboard Shortcuts**: Efficient workflows with hotkeys
 
-| Shortcut  | Action                     |
-| --------- | -------------------------- |
-| `V`       | Select mode                |
-| `S`       | SAM smart annotation mode  |
-| `A`       | Auto-annotate mode         |
-| `1` - `9` | Select class by number     |
-| `Delete`  | Delete selected annotation |
-| `Ctrl+Z`  | Undo                       |
-| `Ctrl+Y`  | Redo                       |
-| `Escape`  | Cancel current action      |
+| Shortcut  | Action                            |
+| --------- | --------------------------------- |
+| `V`       | Manual (draw) mode                |
+| `S`       | Smart mode (SAM or YOLO model)    |
+| `A`       | Toggle auto-apply (in Smart mode) |
+| `1` - `9` | Select class by number            |
+| `Delete`  | Delete selected annotation        |
+| `Ctrl+Z`  | Undo                              |
+| `Ctrl+Y`  | Redo                              |
+| `Escape`  | Save / deselect / exit            |
 
 See [Annotation](data/annotation.md) for the complete guide.
 
@@ -413,12 +412,12 @@ See [Models Export](train/models.md#export-model), the [Export mode guide](../mo
 
 ### Dataset Issues
 
-| Problem                | Solution                                                                                                                                                  |
-| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Dataset won't process  | Check file format is supported (JPEG, PNG, WebP, etc.). Max file size: images 50MB, videos 1GB, datasets 10GB on Free / 20GB on Pro / 50GB on Enterprise  |
-| Missing annotations    | Verify labels are in [YOLO format](../datasets/detect/index.md#ultralytics-yolo-format) with `.txt` files matching image filenames                        |
-| "Train split required" | Add `train/` folder to your dataset structure, or create splits in [dataset settings](data/datasets.md#filter-by-split)                                   |
-| Class names undefined  | Add a `data.yaml` file with `names:` list (see [YOLO format](../datasets/detect/index.md#ultralytics-yolo-format)), or define classes in dataset settings |
+| Problem                | Solution                                                                                                                                                                                                      |
+| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Dataset won't process  | Check file format is supported (JPEG, PNG, WebP, TIFF, HEIC, AVIF, BMP, JP2, DNG, MPO for images). Max file size: images 50 MB, videos 1 GB, dataset archives 10 GB (Free) / 20 GB (Pro) / 50 GB (Enterprise) |
+| Missing annotations    | Verify labels are in [YOLO format](../datasets/detect/index.md#ultralytics-yolo-format) with `.txt` files matching image filenames, or upload COCO JSON                                                       |
+| "Train split required" | Add `train/` folder to your dataset structure, or redistribute splits via the [split bar](data/datasets.md#split-redistribution)                                                                              |
+| Class names undefined  | Add a `data.yaml` file with `names:` list (see [YOLO format](../datasets/detect/index.md#ultralytics-yolo-format)), or define classes in the [Classes tab](data/datasets.md#classes-tab)                      |
 
 ### Training Issues
 
@@ -474,4 +473,4 @@ See [Models Export](train/models.md#export-model), the [Export mode guide](../mo
 
 ??? question "Can I use Platform models commercially?"
 
-    Free and Pro plans use AGPL license. For commercial use without AGPL requirements, contact sales@ultralytics.com for Enterprise licensing.
+    Free and Pro plans use the AGPL license. For commercial use without AGPL requirements, see [Ultralytics Licensing](https://www.ultralytics.com/license).

docs/en/platform/quickstart.md

@@ -19,21 +19,20 @@ keywords: Ultralytics Platform, Quickstart, YOLO models, dataset upload, model t
   <strong>Watch:</strong> Get Started with Ultralytics Platform - QuickStart
 </p>
 
+The following interactive diagram outlines the four primary stages of the Ultralytics Platform workflow. Click any stage or sub-step to access detailed instructions for that section.
+
 ```mermaid
-journey
-    title Your First Model in 5 Minutes
-    section Sign Up
-      Create account: 5: User
-      Select region: 5: User
-    section Prepare Data
-      Upload dataset: 5: User
-      Review images: 4: User
-    section Train
-      Configure training: 5: User
-      Monitor progress: 3: Platform
-    section Deploy
-      Test model: 5: User
-      Deploy endpoint: 5: User
+graph LR
+    A(Sign Up) --> B(Prepare Data) --> C(Train) --> D(Deploy)
+    A -.- A1["<a href='#get-started'>Create account</a><br/><a href='#region-selection'>Select region</a>"]
+    B -.- B1["<a href='#upload-your-first-dataset'>Upload dataset</a><br/><a href='#create-your-first-project'>Create Project</a>"]
+    C -.- C1["<a href='#training-configuration'>Configure training</a><br/><a href='#monitor-training'>Monitor progress</a>"]
+    D -.- D1["<a href='#test-your-model'>Test model</a><br/><a href='#deploy-to-production'>Deploy endpoint</a>"]
+
+    click A "#get-started"
+    click B "#upload-your-first-dataset"
+    click C "#train-your-first-model"
+    click D "#deploy-to-production"
 ```
 
 ## Get Started
@@ -48,11 +47,11 @@ During onboarding, you'll be asked to select your data region. The Platform auto
 
 ![Ultralytics Platform Onboarding Region Map With Latency](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-onboarding-region-map-with-latency.avif)
 
-| Region | Label                        | Location                | Best For                                |
-| ------ | ---------------------------- | ----------------------- | --------------------------------------- |
-| **US** | Americas                     | Iowa, USA               | Americas users, fastest for Americas    |
-| **EU** | Europe, Middle East & Africa | Belgium, Europe         | European users, GDPR compliance         |
-| **AP** | Asia Pacific                 | Hong Kong, Asia-Pacific | Asia-Pacific users, lowest APAC latency |
+| Region | Label                        | Location             | Best For                                |
+| ------ | ---------------------------- | -------------------- | --------------------------------------- |
+| **US** | Americas                     | Iowa, USA            | Americas users, fastest for Americas    |
+| **EU** | Europe, Middle East & Africa | Belgium, Europe      | European users, GDPR compliance         |
+| **AP** | Asia Pacific                 | Taiwan, Asia-Pacific | Asia-Pacific users, lowest APAC latency |
 
 !!! warning "Region is Permanent"
 
@@ -105,7 +104,7 @@ The sidebar provides access to all Platform sections:
 |                 | Deploy   | Your active deployments                          |
 | **Bottom**      | Trash    | Deleted items (recoverable for 30 days)          |
 |                 | Settings | Account, billing, and preferences                |
-|                 | Feedback | Send feedback to Ultralytics                     |
+|                 | Help     | Open help, docs, and feedback tools              |
 
 ### Welcome Card
 
@@ -242,13 +241,13 @@ From your project, click `Train Model` to start cloud training.
 3. **Set Epochs**: Number of training iterations (default: 100)
 4. **Select GPU**: Choose compute resources based on your budget and model size
 
-| Model   | Size        | Speed    | Accuracy | Recommended GPU      |
-| ------- | ----------- | -------- | -------- | -------------------- |
-| YOLO26n | Nano        | Fastest  | Good     | RTX PRO 6000 (96 GB) |
-| YOLO26s | Small       | Fast     | Better   | RTX PRO 6000 (96 GB) |
-| YOLO26m | Medium      | Moderate | High     | RTX PRO 6000 (96 GB) |
-| YOLO26l | Large       | Slower   | Higher   | A100 (80 GB)         |
-| YOLO26x | Extra Large | Slowest  | Best     | H100 (80 GB)         |
+| Model   | Size        | Speed    | Accuracy | Recommended GPU                                                         |
+| ------- | ----------- | -------- | -------- | ----------------------------------------------------------------------- |
+| YOLO26n | Nano        | Fastest  | Good     | RTX PRO 6000 (96 GB) or RTX 4090 (24 GB)                                |
+| YOLO26s | Small       | Fast     | Better   | RTX PRO 6000 (96 GB)                                                    |
+| YOLO26m | Medium      | Moderate | High     | RTX PRO 6000 (96 GB)                                                    |
+| YOLO26l | Large       | Slower   | Higher   | RTX PRO 6000 (96 GB) or A100 SXM (80 GB)                                |
+| YOLO26x | Extra Large | Slowest  | Best     | H100 SXM (80 GB); H200 (141 GB) or B200 (180 GB) with Pro or Enterprise |
 
 !!! info "GPU Selection"
 
@@ -352,7 +351,7 @@ graph LR
 Your endpoint will be ready in about a minute with:
 
 - **Unique URL**: HTTPS endpoint for API calls
-- **Auto-Scaling**: Scales with traffic automatically
+- **Scale-to-zero behavior**: No idle compute cost (deployments currently run a single active instance)
 - **Monitoring**: Request metrics and logs
 
 !!! info "Deployment Lifecycle"
@@ -367,7 +366,7 @@ Read more about [endpoints](deploy/endpoints.md).
 
 If you prefer to train on your own hardware, you can stream metrics to the platform using your API key. This works like Weights & Biases — train anywhere, monitor on the platform.
 
-1. Generate an API key in [`Settings > Profile`](account/api-keys.md) (API Keys section)
+1. Generate an API key in [`Settings > API Keys`](account/api-keys.md)
 2. Set the environment variable and train with a `project/name` format:
 
 ```bash
@@ -384,7 +383,7 @@ Read more about [API keys](account/api-keys.md), [dataset URIs](data/datasets.md
 
 ## Feedback & Help
 
-Use the **Help** page in the sidebar footer to send feedback directly to Ultralytics. You can rate your experience, choose a feedback type (bug report, feature request, or general), and attach screenshots.
+The **Help** page in the sidebar footer includes an in-app feedback form. You can rate your experience, choose a feedback type (bug, feature request, or general), and attach screenshots.
 
 If you need more help:
 

docs/en/platform/train/cloud-training.md

@@ -62,12 +62,12 @@ Choose a dataset to train on (see [Datasets](../data/datasets.md)):
 
 Set core training parameters:
 
-| Parameter      | Description                                                                 | Default |
-| -------------- | --------------------------------------------------------------------------- | ------- |
-| **Epochs**     | Number of training iterations                                               | 100     |
-| **Batch Size** | Samples per iteration                                                       | 16      |
-| **Image Size** | Input resolution (320/416/512/640/1280 dropdown, or 32-4096 in YAML editor) | 640     |
-| **Run Name**   | Optional name for the training run                                          | auto    |
+| Parameter      | Description                                                                                      | Default   |
+| -------------- | ------------------------------------------------------------------------------------------------ | --------- |
+| **Epochs**     | Number of training iterations                                                                    | 100       |
+| **Batch Size** | Samples per iteration                                                                            | -1 (auto) |
+| **Image Size** | Input resolution (320/416/512/640/1280 dropdown, any multiple of 32 from 32-4096 in YAML editor) | 640       |
+| **Run Name**   | Optional name for the training run                                                               | auto      |
 
 ### Step 4: Advanced Settings (Optional)
 
@@ -76,7 +76,7 @@ Expand **Advanced Settings** to access the full YAML-based parameter editor with
 | Group                   | Parameters                                                                       |
 | ----------------------- | -------------------------------------------------------------------------------- |
 | **Learning Rate**       | lr0, lrf, momentum, weight_decay, warmup_epochs, warmup_momentum, warmup_bias_lr |
-| **Optimizer**           | SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax                           |
+| **Optimizer**           | auto (default), SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax           |
 | **Loss Weights**        | box, cls, dfl, pose, kobj, label_smoothing                                       |
 | **Color Augmentation**  | hsv_h, hsv_s, hsv_v                                                              |
 | **Geometric Augment.**  | degrees, translate, scale, shear, perspective                                    |
@@ -109,10 +109,11 @@ Choose your GPU from Ultralytics Cloud:
 
 !!! tip "GPU Selection"
 
-    - **RTX PRO 6000**: 96 GB Blackwell generation, recommended default for most jobs
-    - **A100 SXM**: Required for large batch sizes or big models
-    - **H100/H200**: Maximum performance for time-sensitive training (H200 requires [Pro or Enterprise](../account/billing.md#plans))
-    - **B200**: NVIDIA Blackwell architecture for cutting-edge workloads (requires [Pro or Enterprise](../account/billing.md#plans))
+    - **RTX PRO 6000**: 96 GB Blackwell, recommended default for most jobs
+    - **A100 SXM**: 80 GB HBM2e — strong choice for large batch sizes or bigger models
+    - **H100 PCIe / H100 SXM / H100 NVL**: 80–94 GB Hopper for time-sensitive training (available on all plans)
+    - **H200 NVL / H200 SXM**: 141–143 GB Hopper — requires [Pro or Enterprise](../account/billing.md#plans)
+    - **B200**: 180 GB NVIDIA Blackwell for cutting-edge workloads — requires [Pro or Enterprise](../account/billing.md#plans)
 
 The dialog shows your current **balance** and a **Top Up** button. An estimated cost and duration are calculated based on your configuration (model size, dataset images, epochs, GPU speed).
 
@@ -169,11 +170,7 @@ Real-time GPU utilization, memory, temperature, CPU, and disk usage.
 
 ### Checkpoints
 
-Checkpoints are saved automatically:
-
-- **Every epoch**: Latest weights saved
-- **Best model**: Highest mAP checkpoint preserved
-- **Final model**: Weights at training completion
+After training completes, the **best model** (`best.pt`, the highest-mAP checkpoint) is uploaded to the platform and made available for download, export, and deployment.
 
 ## Cancel Training
 
@@ -181,7 +178,7 @@ Click **Cancel Training** on the model page to stop a running job:
 
 - The compute instance is terminated
 - Credits stop being charged
-- Checkpoints saved up to that point are preserved
+- The best checkpoint remains available if it was reached before cancellation
 
 ## Remote Training
 
@@ -201,7 +198,7 @@ Train on your own hardware while streaming metrics to the platform.
 
 !!! warning "Package Version Requirement"
 
-    Platform integration requires **ultralytics>=8.4.14**. Lower versions will NOT work with Platform.
+    Platform integration requires **ultralytics>=8.4.35**. Lower versions will NOT work with Platform.
 
     ```bash
     pip install -U ultralytics
@@ -209,7 +206,7 @@ Train on your own hardware while streaming metrics to the platform.
 
 ### Setup API Key
 
-1. Go to [`Settings > Profile`](../account/api-keys.md) (API Keys section)
+1. Go to [`Settings > API Keys`](../account/api-keys.md)
 2. Create a new key (or the platform auto-creates one when you open the Local Training tab)
 3. Set the environment variable:
 
@@ -466,11 +463,11 @@ Yes, the **Train** button on dataset pages opens the training dialog with the da
 
 === "Core"
 
-    | Parameter      | Type | Default | Range    | Description                          |
-    | -------------- | ---- | ------- | -------- | ------------------------------------ |
-    | `epochs`       | int  | 100     | 1-10000  | Number of training epochs            |
-    | `batch`        | int  | 16      | 1-512    | Batch size                     |
-    | `imgsz`        | int  | 640     | 32-4096  | Input image size                     |
+    | Parameter      | Type | Default   | Range     | Description                                      |
+    | -------------- | ---- | --------- | --------- | ------------------------------------------------ |
+    | `epochs`       | int  | 100       | 1-10000   | Number of training epochs                        |
+    | `batch`        | int  | -1 (auto) | -1 to 512 | Batch size (`-1` = auto-fit to available VRAM)   |
+    | `imgsz`        | int  | 640       | 32-4096   | Input image size                                 |
     | `patience`     | int  | 100     | 1-1000   | Early stopping patience              |
     | `seed`         | int  | 0       | 0-2147483647 | Random seed for reproducibility  |
     | `deterministic`| bool | True    | -        | Deterministic training mode          |

docs/en/platform/train/index.md

@@ -105,7 +105,7 @@ graph LR
 
 !!! info "Automatic Checkpoints"
 
-    The Platform automatically saves checkpoints at every epoch. The **best model** (highest mAP) and **final model** are always preserved.
+    For cloud training, the **best model** (`best.pt`, the highest-mAP checkpoint) is saved automatically and made available for download, export, and deployment after training completes.
 
 ## Quick Start
 

docs/en/platform/train/models.md

@@ -139,7 +139,7 @@ GPU and system metrics during training:
 
 Run interactive inference directly in the browser:
 
-- Upload an image, paste a URL, or use webcam
+- Upload an image, use example images, or use webcam
 - Results display with bounding boxes, masks, or keypoints
 - Auto-inference when an image is provided
 - Supports all task types ([detect](../../tasks/detect.md), [segment](../../tasks/segment.md), [pose](../../tasks/pose.md), [OBB](../../tasks/obb.md), [classify](../../tasks/classify.md))
@@ -269,11 +269,17 @@ Export jobs progress through the following statuses:
 
 Some export formats have architecture or task restrictions:
 
-| Format           | Restriction                                                     |
-| ---------------- | --------------------------------------------------------------- |
-| **IMX500**       | Only available for YOLOv8 and YOLO11 models                     |
-| **Axelera**      | Not available for YOLO26 segmentation models                    |
-| **PaddlePaddle** | Not available for YOLO26 detection/segmentation/pose/OBB models |
+| Format           | Restriction                                             |
+| ---------------- | ------------------------------------------------------- |
+| **IMX500**       | Available only for `YOLOv8n` and `YOLO11n`              |
+| **Axelera**      | Detect models only                                      |
+| **PaddlePaddle** | Not available for YOLO26 detect/segment/pose/OBB models |
+
+!!! 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
 

docs/en/platform/train/projects.md

@@ -40,7 +40,7 @@ Enter your project details:
 - **Name**: A descriptive name for your project (a random name is auto-generated)
 - **Description**: Optional notes about the project purpose
 - **Visibility**: Public (anyone can view) or Private (only you can access)
-- **License**: Optional license for your project (AGPL-3.0, Apache-2.0, MIT, GPL-3.0, BSD-3-Clause, LGPL-3.0, MPL-2.0, EUPL-1.1, Unlicense, Ultralytics-Enterprise, and more). The **Ultralytics-Enterprise** license is for commercial use without AGPL requirements — contact [sales@ultralytics.com](mailto:sales@ultralytics.com) for details.
+- **License**: Optional license for your project (AGPL-3.0, Apache-2.0, MIT, GPL-3.0, BSD-3-Clause, LGPL-3.0, MPL-2.0, EUPL-1.1, Unlicense, Ultralytics-Enterprise, and more). The **Ultralytics-Enterprise** license is for commercial use without AGPL requirements and is available with an Enterprise plan — see [Ultralytics Licensing](https://www.ultralytics.com/license).
 
 ![Ultralytics Platform New Project Dialog Name Visibility License](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-new-project-dialog-name-visibility-license.avif)
 
@@ -81,10 +81,11 @@ Action buttons in the header:
 
 ### View Modes
 
-Toggle between two view modes using the view controls:
+Toggle between three view modes using the view controls:
 
-- **Charts view**: Interactive charts dashboard showing loss curves and metric comparisons for selected models
-- **Table view**: Comparison table showing training arguments and final metrics side-by-side with a diff mode to highlight differing columns
+- **Cards**: Full-width models sidebar with the Charts dashboard on the right — loss curves and metric comparisons for checked models.
+- **Compact**: Condensed models sidebar with the Charts dashboard on the right — more vertical room for models in projects with many experiments.
+- **Table**: Comparison table showing training arguments and final metrics side-by-side. Enable **Diff** to highlight only the columns where values differ across models.
 
 ![Ultralytics Platform Project Comparison Table View](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/platform-project-comparison-table-view.avif)
 

docs/en/solutions/index.md

@@ -141,7 +141,7 @@ For more details, refer to the [`SolutionResults` class documentation](https://d
 
     Most of the Solutions can be used directly through the command-line interface, including:
 
-    `Count`, `Crop`, `Blur`, `Workout`, `Heatmap`, `Isegment`, `Visioneye`, `Speed`, `Queue`, `Analytics`, `Inference`
+    `Count`, `Crop`, `Blur`, `Workout`, `Heatmap`, `Isegment`, `Visioneye`, `Speed`, `Queue`, `Analytics`, `Inference`, `Trackzone`
 
     **Syntax**
 

docs/en/tasks/classify.md

@@ -146,7 +146,7 @@ Train YOLO26n-cls on the MNIST160 dataset for 100 [epochs](https://www.ultralyti
 
 ### Dataset format
 
-YOLO classification dataset format can be found in detail in the [Dataset Guide](../datasets/classify/index.md).
+YOLO classification dataset format can be found in detail in the [Dataset Guide](../datasets/classify/index.md). Classification datasets can also be managed and labeled on [Ultralytics Platform](https://platform.ultralytics.com).
 
 ## Val
 

docs/en/tasks/detect.md

@@ -72,9 +72,11 @@ Train YOLO26n on the COCO8 dataset for 100 [epochs](https://www.ultralytics.com/
         yolo detect train data=coco8.yaml model=yolo26n.yaml pretrained=yolo26n.pt epochs=100 imgsz=640
         ```
 
+See full `train` mode details in the [Train](../modes/train.md) page. Detection models can also be trained on cloud GPUs through [Ultralytics Platform](https://platform.ultralytics.com).
+
 ### Dataset format
 
-YOLO detection dataset format can be found in detail in the [Dataset Guide](../datasets/detect/index.md). To convert your existing dataset from other formats (like COCO etc.) to YOLO format, please use [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics.
+YOLO detection dataset format can be found in detail in the [Dataset Guide](../datasets/detect/index.md). To convert your existing dataset from other formats (like COCO etc.) to YOLO format, please use [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics. You can also annotate and manage detection datasets directly on [Ultralytics Platform](https://platform.ultralytics.com) with AI-assisted labeling tools.
 
 ## Val
 
@@ -97,6 +99,7 @@ Validate trained YOLO26n model [accuracy](https://www.ultralytics.com/glossary/a
         metrics.box.map50  # map50
         metrics.box.map75  # map75
         metrics.box.maps  # a list containing mAP50-95 for each category
+        metrics.box.image_metrics  # per-image metrics dictionary with precision, recall, F1, TP, FP, and FN
         ```
 
     === "CLI"
@@ -177,6 +180,10 @@ See full `export` details in the [Export](../modes/export.md) page.
 
 ## FAQ
 
+### Can I train and deploy detection models without coding?
+
+Yes. [Ultralytics Platform](https://platform.ultralytics.com) provides a browser-based workflow for annotating datasets, training detection models on cloud GPUs, and deploying them to inference endpoints. See the [Platform quickstart](../platform/quickstart.md) to get started.
+
 ### How do I train a YOLO26 model on my custom dataset?
 
 Training a YOLO26 model on a custom dataset involves a few steps:

docs/en/tasks/obb.md

@@ -66,7 +66,7 @@ Train YOLO26n-obb on the DOTA8 dataset for 100 [epochs](https://www.ultralytics.
         # Load a model
         model = YOLO("yolo26n-obb.yaml")  # build a new model from YAML
         model = YOLO("yolo26n-obb.pt")  # load a pretrained model (recommended for training)
-        model = YOLO("yolo26n-obb.yaml").load("yolo26n.pt")  # build from YAML and transfer weights
+        model = YOLO("yolo26n-obb.yaml").load("yolo26n-obb.pt")  # build from YAML and transfer weights
 
         # Train the model
         results = model.train(data="dota8.yaml", epochs=100, imgsz=640)
@@ -98,7 +98,7 @@ Train YOLO26n-obb on the DOTA8 dataset for 100 [epochs](https://www.ultralytics.
 
 ### Dataset format
 
-OBB dataset format can be found in detail in the [Dataset Guide](../datasets/obb/index.md). The YOLO OBB format designates bounding boxes by their four corner points with coordinates normalized between 0 and 1, following this structure:
+OBB dataset format can be found in detail in the [Dataset Guide](../datasets/obb/index.md). The YOLO OBB format designates bounding boxes by their four corner points with coordinates normalized between 0 and 1, following this structure. [Ultralytics Platform](https://platform.ultralytics.com) supports OBB annotation with a dedicated oriented bounding box drawing tool:
 
 ```
 class_index x1 y1 x2 y2 x3 y3 x4 y4
@@ -127,6 +127,7 @@ Validate trained YOLO26n-obb model [accuracy](https://www.ultralytics.com/glossa
         metrics.box.map50  # map50(B)
         metrics.box.map75  # map75(B)
         metrics.box.maps  # a list containing mAP50-95(B) for each category
+        metrics.box.image_metrics  # per-image metrics dictionary with precision, recall, F1, TP, FP, and FN
         ```
 
     === "CLI"

docs/en/tasks/pose.md

@@ -93,9 +93,11 @@ Train a YOLO26-pose model on the COCO8-pose dataset. The [COCO8-pose dataset](ht
         yolo pose train data=coco8-pose.yaml model=yolo26n-pose.yaml pretrained=yolo26n-pose.pt epochs=100 imgsz=640
         ```
 
+See full `train` mode details in the [Train](../modes/train.md) page. Pose models can also be trained on cloud GPUs through [Ultralytics Platform](https://platform.ultralytics.com).
+
 ### Dataset format
 
-YOLO pose dataset format can be found in detail in the [Dataset Guide](../datasets/pose/index.md). To convert your existing dataset from other formats (like [COCO](https://docs.ultralytics.com/datasets/pose/coco/) etc.) to YOLO format, please use the [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics.
+YOLO pose dataset format can be found in detail in the [Dataset Guide](../datasets/pose/index.md). To convert your existing dataset from other formats (like [COCO](https://docs.ultralytics.com/datasets/pose/coco/) etc.) to YOLO format, please use the [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics. [Ultralytics Platform](https://platform.ultralytics.com) also supports pose annotation with built-in skeleton templates for person, hand, face, and custom keypoint layouts.
 
 For custom pose estimation tasks, you can also explore specialized datasets like [Tiger-Pose](https://docs.ultralytics.com/datasets/pose/tiger-pose/) for animal pose estimation, [Hand Keypoints](https://docs.ultralytics.com/datasets/pose/hand-keypoints/) for hand tracking, or [Dog-Pose](https://docs.ultralytics.com/datasets/pose/dog-pose/) for canine pose analysis.
 
@@ -120,10 +122,12 @@ Validate trained YOLO26n-pose model [accuracy](https://www.ultralytics.com/gloss
         metrics.box.map50  # map50
         metrics.box.map75  # map75
         metrics.box.maps  # a list containing mAP50-95 for each category
+        metrics.box.image_metrics  # per-image metrics dictionary for box with precision, recall, F1, TP, FP, and FN
         metrics.pose.map  # map50-95(P)
         metrics.pose.map50  # map50(P)
         metrics.pose.map75  # map75(P)
         metrics.pose.maps  # a list containing mAP50-95(P) for each category
+        metrics.pose.image_metrics  # per-image metrics dictionary for pose with precision, recall, F1, TP, FP, and FN
         ```
 
     === "CLI"

docs/en/tasks/segment.md

@@ -54,7 +54,7 @@ Train YOLO26n-seg on the COCO8-seg dataset for 100 [epochs](https://www.ultralyt
         # Load a model
         model = YOLO("yolo26n-seg.yaml")  # build a new model from YAML
         model = YOLO("yolo26n-seg.pt")  # load a pretrained model (recommended for training)
-        model = YOLO("yolo26n-seg.yaml").load("yolo26n.pt")  # build from YAML and transfer weights
+        model = YOLO("yolo26n-seg.yaml").load("yolo26n-seg.pt")  # build from YAML and transfer weights
 
         # Train the model
         results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
@@ -73,9 +73,11 @@ Train YOLO26n-seg on the COCO8-seg dataset for 100 [epochs](https://www.ultralyt
         yolo segment train data=coco8-seg.yaml model=yolo26n-seg.yaml pretrained=yolo26n-seg.pt epochs=100 imgsz=640
         ```
 
+See full `train` mode details in the [Train](../modes/train.md) page. Segmentation models can also be trained on cloud GPUs through [Ultralytics Platform](https://platform.ultralytics.com).
+
 ### Dataset format
 
-YOLO segmentation dataset format can be found in detail in the [Dataset Guide](../datasets/segment/index.md). To convert your existing dataset from other formats (like COCO etc.) to YOLO format, please use [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics.
+YOLO segmentation dataset format can be found in detail in the [Dataset Guide](../datasets/segment/index.md). To convert your existing dataset from other formats (like COCO etc.) to YOLO format, please use [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics. You can also create segmentation masks on [Ultralytics Platform](https://platform.ultralytics.com) using polygon tools and SAM-powered smart annotation.
 
 ## Val
 
@@ -98,10 +100,12 @@ Validate trained YOLO26n-seg model [accuracy](https://www.ultralytics.com/glossa
         metrics.box.map50  # map50(B)
         metrics.box.map75  # map75(B)
         metrics.box.maps  # a list containing mAP50-95(B) for each category
+        metrics.box.image_metrics  # per-image metrics dictionary for det with precision, recall, F1, TP, FP, and FN
         metrics.seg.map  # map50-95(M)
         metrics.seg.map50  # map50(M)
         metrics.seg.map75  # map75(M)
         metrics.seg.maps  # a list containing mAP50-95(M) for each category
+        metrics.seg.image_metrics  # per-image metrics dictionary for seg with precision, recall, F1, TP, FP, and FN
         ```
 
     === "CLI"

docs/en/usage/callbacks.md

@@ -87,22 +87,22 @@ Below are all the supported callbacks. For more details, refer to the callbacks
 
 ### Trainer Callbacks
 
-| Callback                    | Description                                                                                  |
-| --------------------------- | -------------------------------------------------------------------------------------------- |
-| `on_pretrain_routine_start` | Triggered at the beginning of the pre-training routine.                                      |
-| `on_pretrain_routine_end`   | Triggered at the end of the pre-training routine.                                            |
-| `on_train_start`            | Triggered when the training starts.                                                          |
-| `on_train_epoch_start`      | Triggered at the start of each training [epoch](https://www.ultralytics.com/glossary/epoch). |
-| `on_train_batch_start`      | Triggered at the start of each training batch.                                               |
-| `optimizer_step`            | Triggered during the optimizer step.                                                         |
-| `on_before_zero_grad`       | Triggered before gradients are zeroed.                                                       |
-| `on_train_batch_end`        | Triggered at the end of each training batch.                                                 |
-| `on_train_epoch_end`        | Triggered at the end of each training epoch.                                                 |
-| `on_fit_epoch_end`          | Triggered at the end of each fit epoch.                                                      |
-| `on_model_save`             | Triggered when the model is saved.                                                           |
-| `on_train_end`              | Triggered when the training process ends.                                                    |
-| `on_params_update`          | Triggered when model parameters are updated.                                                 |
-| `teardown`                  | Triggered when the training process is being cleaned up.                                     |
+| Callback                    | Description                                                                                                                                                                                                                                                                                                                      |
+| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `on_pretrain_routine_start` | Triggered at the beginning of the pre-training routine, before data loading and model setup.                                                                                                                                                                                                                                     |
+| `on_pretrain_routine_end`   | Triggered at the end of the pre-training routine, after data loading and model setup are complete.                                                                                                                                                                                                                               |
+| `on_train_start`            | Triggered when the training starts, before the first [epoch](https://www.ultralytics.com/glossary/epoch) begins.                                                                                                                                                                                                                 |
+| `on_train_epoch_start`      | Triggered at the start of each training [epoch](https://www.ultralytics.com/glossary/epoch), before batch iteration begins.                                                                                                                                                                                                      |
+| `on_train_batch_start`      | Triggered at the start of each training batch, before the forward pass.                                                                                                                                                                                                                                                          |
+| `optimizer_step`            | Triggered during the optimizer step. Reserved for custom integrations; not called by the default training loop.                                                                                                                                                                                                                  |
+| `on_before_zero_grad`       | Triggered before gradients are zeroed. Reserved for custom integrations; not called by the default training loop.                                                                                                                                                                                                                |
+| `on_train_batch_end`        | Triggered at the end of each training batch, after the backward pass. The optimizer step may be deferred due to gradient accumulation.                                                                                                                                                                                           |
+| `on_train_epoch_end`        | Triggered at the end of each training epoch, after all batches are processed but **before** validation. Validation metrics and fitness may not be available yet.                                                                                                                                                                 |
+| `on_model_save`             | Triggered when the model checkpoint is saved, after validation.                                                                                                                                                                                                                                                                  |
+| `on_fit_epoch_end`          | Triggered at the end of each fit epoch (train + val), **after** validation and any checkpoint save. Validation metrics are available, and fitness is available for the per-epoch training call. This callback is also called during final best-model evaluation, where no checkpoint save occurs and fitness may not be present. |
+| `on_train_end`              | Triggered when the training process ends, after final evaluation of the best model.                                                                                                                                                                                                                                              |
+| `on_params_update`          | Triggered when model parameters are updated. Reserved for custom integrations; not called by the default training loop.                                                                                                                                                                                                          |
+| `teardown`                  | Triggered when the training process is being cleaned up.                                                                                                                                                                                                                                                                         |
 
 ### Validator Callbacks
 

docs/en/usage/cfg.md

@@ -168,11 +168,19 @@ Effective management of these aspects helps track progress and makes debugging a
 | Argument   | Default  | Description                                                                                                                                                                                                                                                                                               |
 | ---------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `project`  | `'runs'` | Specifies the root directory for saving training runs. Each run is saved in a separate subdirectory.                                                                                                                                                                                                      |
-| `name`     | `'exp'`  | Defines the experiment name. If unspecified, YOLO increments this name for each run (e.g., `exp`, `exp2`) to avoid overwriting.                                                                                                                                                                           |
+| `name`     | `'exp'`  | Defines the experiment name. If unspecified, YOLO increments this name for each run (e.g., `exp`, `exp-2`) to avoid overwriting.                                                                                                                                                                          |
 | `exist_ok` | `False`  | Determines whether to overwrite an existing experiment directory. `True` allows overwriting; `False` prevents it.                                                                                                                                                                                         |
 | `plots`    | `True`   | Controls the generation and saving of training and validation plots. Set to `True` to create plots like loss curves, [precision](https://www.ultralytics.com/glossary/precision)-[recall](https://www.ultralytics.com/glossary/recall) curves, and sample predictions for visual tracking of performance. |
 | `save`     | `True`   | Enables saving training checkpoints and final model weights. Set to `True` to save model states periodically, allowing training resumption or model deployment.                                                                                                                                           |
 
+## Custom Configuration File
+
+Load a saved YAML to reuse a full set of arguments without passing them inline. The `cfg` argument overrides values from `default.yaml`, while additional arguments passed alongside still take precedence.
+
+| Argument | Default | Description                                                                                                                                                            |
+| -------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `cfg`    | `None`  | Path to a YAML file whose values replace `default.yaml` entries. See [Overriding Default Config File](cli.md#overriding-default-config-file) for a worked CLI example. |
+
 ## FAQ
 
 ### How do I improve my YOLO model's performance during training?

docs/en/usage/cli.md

@@ -237,7 +237,7 @@ You can then pass this file as `cfg=default_copy.yaml` along with any additional
 
 ## Solutions Commands
 
-Ultralytics provides ready-to-use solutions for common computer vision applications through the CLI. These solutions simplify the implementation of complex tasks like object counting, workout monitoring, and queue management.
+Ultralytics provides ready-to-use solutions for common computer vision applications through the CLI. The `yolo solutions` command exposes object counting, cropping, blurring, workout monitoring, heatmaps, instance segmentation, VisionEye, speed estimation, queue management, analytics, Streamlit inference, and zone-based tracking — see the [Solutions](../solutions/index.md) page for the full catalog. Run `yolo solutions help` to list every supported solution and its arguments.
 
 !!! example
 
@@ -250,6 +250,26 @@ Ultralytics provides ready-to-use solutions for common computer vision applicati
         yolo solutions count source="path/to/video.mp4" # specify video file path
         ```
 
+    === "Crop"
+
+        Crop detected objects and save them to disk:
+
+        ```bash
+        yolo solutions crop show=True
+        yolo solutions crop source="path/to/video.mp4" # specify video file path
+        yolo solutions crop classes="[0, 2]"           # crop only selected classes
+        ```
+
+    === "Blur"
+
+        Blur detected objects in a video for privacy or to highlight other regions:
+
+        ```bash
+        yolo solutions blur show=True
+        yolo solutions blur source="path/to/video.mp4" # specify video file path
+        yolo solutions blur classes="[0, 5]"           # blur only selected classes
+        ```
+
     === "Workout"
 
         Monitor workout exercises using a pose model:
@@ -259,8 +279,49 @@ Ultralytics provides ready-to-use solutions for common computer vision applicati
         yolo solutions workout source="path/to/video.mp4" # specify video file path
 
         # Use keypoints for ab-workouts
-        yolo solutions workout kpts=[5, 11, 13] # left side
-        yolo solutions workout kpts=[6, 12, 14] # right side
+        yolo solutions workout kpts="[5, 11, 13]" # left side
+        yolo solutions workout kpts="[6, 12, 14]" # right side
+        ```
+
+    === "Heatmap"
+
+        Generate a heatmap showing object density and movement patterns:
+
+        ```bash
+        yolo solutions heatmap show=True
+        yolo solutions heatmap source="path/to/video.mp4"                                # specify video file path
+        yolo solutions heatmap colormap=cv2.COLORMAP_INFERNO                             # customize colormap
+        yolo solutions heatmap region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]" # restrict heatmap to a region
+        ```
+
+    === "Isegment"
+
+        Run instance segmentation with tracking on a video:
+
+        ```bash
+        yolo solutions isegment show=True
+        yolo solutions isegment source="path/to/video.mp4" # specify video file path
+        yolo solutions isegment classes="[0, 5]"           # segment only selected classes
+        ```
+
+    === "VisionEye"
+
+        Draw object-to-observer sightlines with VisionEye:
+
+        ```bash
+        yolo solutions visioneye show=True
+        yolo solutions visioneye source="path/to/video.mp4" # specify video file path
+        yolo solutions visioneye classes="[0, 5]"           # monitor only selected classes
+        ```
+
+    === "Speed"
+
+        Estimate the speed of moving objects in a video:
+
+        ```bash
+        yolo solutions speed show=True
+        yolo solutions speed source="path/to/video.mp4" # specify video file path
+        yolo solutions speed meter_per_pixel=0.05       # set scale for real-world units
         ```
 
     === "Queue"
@@ -273,6 +334,18 @@ Ultralytics provides ready-to-use solutions for common computer vision applicati
         yolo solutions queue region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]" # configure queue coordinates
         ```
 
+    === "Analytics"
+
+        Generate analytical charts (line, bar, area, or pie) from tracked detections:
+
+        ```bash
+        yolo solutions analytics show=True
+        yolo solutions analytics source="path/to/video.mp4" # specify video file path
+        yolo solutions analytics analytics_type="pie" show=True
+        yolo solutions analytics analytics_type="bar" show=True
+        yolo solutions analytics analytics_type="area" show=True
+        ```
+
     === "Inference"
 
         Perform object detection, instance segmentation, or pose estimation in a web browser using Streamlit:
@@ -282,6 +355,44 @@ Ultralytics provides ready-to-use solutions for common computer vision applicati
         yolo solutions inference model="path/to/model.pt" # use custom model
         ```
 
+    === "TrackZone"
+
+        Track objects only inside a specified polygonal zone:
+
+        ```bash
+        yolo solutions trackzone show=True
+        yolo solutions trackzone source="path/to/video.mp4"                                  # specify video file path
+        yolo solutions trackzone region="[(150, 150), (1130, 150), (1130, 570), (150, 570)]" # configure zone coordinates
+        ```
+
+    === "Region"
+
+        Count objects inside specific polygonal regions:
+
+        ```bash
+        yolo solutions region show=True
+        yolo solutions region source="path/to/video.mp4"                                # specify video file path
+        yolo solutions region region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]" # configure region coordinates
+        ```
+
+    === "Security"
+
+        Run security alarm monitoring with object detection:
+
+        ```bash
+        yolo solutions security show=True
+        yolo solutions security source="path/to/video.mp4" # specify video file path
+        ```
+
+    === "Parking"
+
+        Monitor parking lot occupancy using pre-defined zones:
+
+        ```bash
+        yolo solutions parking source="path/to/video.mp4" json_file="bounding_boxes.json" # requires pre-built JSON
+        yolo solutions parking source="path/to/video.mp4" json_file="bounding_boxes.json" model="yolo26n.pt"
+        ```
+
     === "Help"
 
         View available solutions and their options:

docs/en/usage/simple-utilities.md

@@ -731,7 +731,7 @@ auto_annotate(
 )
 ```
 
-For more details, check the [auto_annotate reference section](../reference/data/annotator.md#ultralytics.data.annotator.auto_annotate).
+For more details, check the [auto_annotate reference section](../reference/data/annotator.md#ultralytics.data.annotator.auto_annotate), or use [Ultralytics Platform](https://platform.ultralytics.com/) as a hosted, no-code alternative with click-based masking via [SAM 2.1](../models/sam-2.md) or [SAM 3](../models/sam-3.md), or predictions from pretrained and fine-tuned YOLO models for detect, segment, and OBB tasks.
 
 ### How do I convert COCO dataset annotations to YOLO format in Ultralytics?
 
@@ -750,9 +750,9 @@ convert_coco(
 
 For additional information, visit the [convert_coco reference page](../reference/data/converter.md#ultralytics.data.converter.convert_coco).
 
-### What is the purpose of the YOLO Data Explorer in the Ultralytics package?
+### How can I analyze my dataset composition and distribution?
 
-The [YOLO Explorer](../datasets/explorer/index.md) is a powerful tool introduced in the `8.1.0` update to enhance dataset understanding. It allows you to use text queries to find object instances in your dataset, making it easier to analyze and manage your data. This tool provides valuable insights into dataset composition and distribution, helping to improve model training and performance.
+[Ultralytics Platform](https://platform.ultralytics.com/) provides automatic dataset analytics: the `Charts` tab shows split distribution, top class counts, image-dimension histograms, and 2D heatmaps of annotation positions, helping you spot imbalances and outliers before training.
 
 ### How can I convert bounding boxes to segments in Ultralytics?
 

docs/en/yolov5/environments/google_cloud_quickstart_tutorial.md

@@ -8,7 +8,7 @@ keywords: YOLOv5, Google Cloud Platform, GCP, Deep Learning VM, object detection
 
 Embarking on the journey of [artificial intelligence (AI)](https://www.ultralytics.com/glossary/artificial-intelligence-ai) and [machine learning (ML)](https://www.ultralytics.com/glossary/machine-learning-ml) can be exhilarating, especially when you leverage the power and flexibility of a [cloud computing](https://www.ultralytics.com/glossary/cloud-computing) platform. Google Cloud Platform (GCP) offers robust tools tailored for ML enthusiasts and professionals alike. One such tool is the Deep Learning VM, preconfigured for data science and ML tasks. In this tutorial, we will navigate the process of setting up [Ultralytics YOLOv5](../../models/yolov5.md) on a [GCP Deep Learning VM](https://docs.cloud.google.com/deep-learning-vm/docs). Whether you're taking your first steps in ML or you're a seasoned practitioner, this guide provides a clear pathway to implementing [object detection](https://www.ultralytics.com/glossary/object-detection) models powered by YOLOv5.
 
-🆓 Plus, if you're a new GCP user, you're in luck with a [$300 free credit offer](https://cloud.google.com/free/docs/free-cloud-features#free-trial) to kickstart your projects.
+🆓 Plus, if you're a new GCP user, you're in luck with a [$300 free credit offer](https://docs.cloud.google.com/free/docs/free-cloud-features) to kickstart your projects.
 
 In addition to GCP, explore other accessible quickstart options for YOLOv5, like our [Google Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"> for a browser-based experience, or the scalability of [Amazon AWS](./aws_quickstart_tutorial.md). Furthermore, container aficionados can utilize our official Docker image available on [Docker Hub](https://hub.docker.com/r/ultralytics/yolov5) <img src="https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker" alt="Docker Pulls"> for an encapsulated environment, following our [Docker Quickstart Guide](../../guides/docker-quickstart.md).