Upload folder using huggingface_hub (part 24)

.gitattributes

@@ -821,3 +821,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.14/site-packages/ultralytics/nn/__pycache__/tasks.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.14/site-packages/ultralytics/nn/modules/__pycache__/block.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.14/site-packages/ultralytics/nn/modules/__pycache__/head.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.14/site-packages/ultralytics/utils/__pycache__/metrics.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.14/site-packages/yaml/_yaml.cpython-314-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venv/share/jupyter/nbextensions/pydeck/index.js.map filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.14/site-packages/ultralytics-8.4.83.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv/lib/python3.14/site-packages/ultralytics-8.4.83.dist-info/METADATA

@@ -0,0 +1,398 @@
+Metadata-Version: 2.4
+Name: ultralytics
+Version: 8.4.83
+Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation, classification, and oriented object detection.
+Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
+Maintainer-email: Ultralytics <hello@ultralytics.com>
+License: AGPL-3.0
+Project-URL: Homepage, https://ultralytics.com
+Project-URL: Source, https://github.com/ultralytics/ultralytics
+Project-URL: Documentation, https://docs.ultralytics.com
+Project-URL: Bug Reports, https://github.com/ultralytics/ultralytics/issues
+Project-URL: Changelog, https://github.com/ultralytics/ultralytics/releases
+Keywords: machine-learning,deep-learning,computer-vision,ML,DL,AI,RT-DETR,SAM3,YOLO,YOLOv3,YOLOv5,YOLOv8,YOLO11,YOLO26,Platform,Ultralytics
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23.0
+Requires-Dist: matplotlib>=3.3.0
+Requires-Dist: opencv-python>=4.6.0
+Requires-Dist: pillow>=7.1.2
+Requires-Dist: pyyaml>=5.3.1
+Requires-Dist: requests>=2.23.0
+Requires-Dist: torch>=1.8.0
+Requires-Dist: torch!=2.4.0,>=1.8.0; sys_platform == "win32"
+Requires-Dist: torchvision>=0.9.0
+Requires-Dist: psutil>=5.8.0
+Requires-Dist: polars>=0.20.0
+Requires-Dist: nvidia-ml-py>=12.0.0
+Requires-Dist: ultralytics-thop>=2.0.18
+Provides-Extra: dev
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0.0; extra == "dev"
+Requires-Dist: coverage[toml]; extra == "dev"
+Requires-Dist: zensical>=0.0.15; python_version >= "3.10" and extra == "dev"
+Requires-Dist: mkdocs-ultralytics-plugin>=0.2.4; extra == "dev"
+Requires-Dist: minijinja>=2.0.0; extra == "dev"
+Provides-Extra: export-base
+Requires-Dist: onnx>=1.12.0; platform_system != "Darwin" and extra == "export-base"
+Requires-Dist: onnx<1.18.0,>=1.12.0; (platform_system == "Darwin" and python_version < "3.13") and extra == "export-base"
+Requires-Dist: onnx>=1.20.0; (platform_system == "Darwin" and python_version >= "3.13") and extra == "export-base"
+Requires-Dist: onnxslim>=0.1.82; extra == "export-base"
+Requires-Dist: onnxruntime<1.20.0; (python_version < "3.11" and (platform_machine != "aarch64" or platform_system != "Linux")) and extra == "export-base"
+Requires-Dist: onnxruntime>=1.20.0; python_version >= "3.11" and extra == "export-base"
+Requires-Dist: nncf<3.0.0,>=2.14.0; python_version >= "3.9" and extra == "export-base"
+Requires-Dist: openvino>=2024.0.0; extra == "export-base"
+Requires-Dist: packaging>=26.0; (platform_machine == "aarch64" and platform_system == "Linux" and python_version >= "3.9") and extra == "export-base"
+Provides-Extra: export-legacy-torch
+Requires-Dist: numpy<2; extra == "export-legacy-torch"
+Requires-Dist: setuptools<81.0.0; python_version >= "3.9" and extra == "export-legacy-torch"
+Provides-Extra: export-tensorflow
+Requires-Dist: numpy<2.0.0; python_version < "3.13" and extra == "export-tensorflow"
+Requires-Dist: tensorflow<=2.19.0,>=2.0.0; python_version < "3.13" and extra == "export-tensorflow"
+Requires-Dist: tensorflow>2.19.0; python_version >= "3.13" and extra == "export-tensorflow"
+Requires-Dist: ydf<0.13.0; (platform_machine != "aarch64" and python_version <= "3.12") and extra == "export-tensorflow"
+Requires-Dist: googleapis-common-protos<1.74.0; python_version <= "3.12" and extra == "export-tensorflow"
+Requires-Dist: tensorstore>=0.1.63; (platform_machine == "aarch64" and python_version >= "3.9") and extra == "export-tensorflow"
+Requires-Dist: h5py!=3.11.0; platform_machine == "aarch64" and extra == "export-tensorflow"
+Provides-Extra: export-coreml
+Requires-Dist: numpy<=2.3.5; python_version >= "3.13" and extra == "export-coreml"
+Requires-Dist: coremltools>=9.0; (platform_system != "Windows" and python_version <= "3.13") and extra == "export-coreml"
+Requires-Dist: scikit-learn>=1.3.2; (platform_system != "Windows" and python_version <= "3.13") and extra == "export-coreml"
+Provides-Extra: export-executorch
+Requires-Dist: executorch; extra == "export-executorch"
+Requires-Dist: numpy<=2.3.5; extra == "export-executorch"
+Provides-Extra: export-deepx
+Requires-Dist: dx_com; extra == "export-deepx"
+Requires-Dist: numpy<2; extra == "export-deepx"
+Provides-Extra: export-litert
+Requires-Dist: litert-torch>=0.9.0; ((platform_system == "Linux" and platform_machine == "x86_64") or platform_system == "Darwin") and extra == "export-litert"
+Requires-Dist: ai-edge-litert>=2.1.4; ((platform_system == "Linux" and platform_machine == "x86_64") or platform_system == "Darwin") and extra == "export-litert"
+Requires-Dist: ai-edge-quantizer>=0.6.0; ((platform_system == "Linux" and platform_machine == "x86_64") or platform_system == "Darwin") and extra == "export-litert"
+Provides-Extra: export
+Requires-Dist: ultralytics[export-base]; extra == "export"
+Requires-Dist: ultralytics[export-tensorflow]; extra == "export"
+Requires-Dist: ultralytics[export-coreml]; extra == "export"
+Requires-Dist: ultralytics[export-litert]; extra == "export"
+Provides-Extra: solutions
+Requires-Dist: shapely>=2.0.0; extra == "solutions"
+Requires-Dist: lap>=0.5.12; extra == "solutions"
+Requires-Dist: streamlit>=1.51.0; python_version >= "3.10" and extra == "solutions"
+Requires-Dist: streamlit<1.51.0,>=1.29.0; (python_version < "3.10" and (platform_machine != "aarch64" or platform_system != "Linux")) and extra == "solutions"
+Requires-Dist: flask>=3.0.1; extra == "solutions"
+Provides-Extra: logging
+Requires-Dist: wandb; extra == "logging"
+Requires-Dist: tensorboard; extra == "logging"
+Requires-Dist: mlflow; extra == "logging"
+Provides-Extra: extra
+Requires-Dist: ipython; extra == "extra"
+Requires-Dist: albumentations>=1.4.6; extra == "extra"
+Requires-Dist: faster-coco-eval>=1.6.7; extra == "extra"
+Provides-Extra: typing
+Requires-Dist: types-pillow; extra == "typing"
+Requires-Dist: types-psutil; extra == "typing"
+Requires-Dist: types-pyyaml; extra == "typing"
+Requires-Dist: types-requests; extra == "typing"
+Requires-Dist: types-shapely; extra == "typing"
+Dynamic: license-file
+
+<div align="center">
+  <p>
+    <a href="https://platform.ultralytics.com/?utm_source=github&utm_medium=referral&utm_campaign=platform_launch&utm_content=banner&utm_term=ultralytics_github" target="_blank">
+      <img width="100%" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="Ultralytics YOLO banner"></a>
+  </p>
+
+[中文](https://docs.ultralytics.com/zh) | [한국어](https://docs.ultralytics.com/ko) | [日本語](https://docs.ultralytics.com/ja) | [Русский](https://docs.ultralytics.com/ru) | [Deutsch](https://docs.ultralytics.com/de) | [Français](https://docs.ultralytics.com/fr) | [Español](https://docs.ultralytics.com/es) | [Português](https://docs.ultralytics.com/pt) | [Türkçe](https://docs.ultralytics.com/tr) | [Tiếng Việt](https://docs.ultralytics.com/vi) | [العربية](https://docs.ultralytics.com/ar) <br>
+
+<div>
+    <a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml/badge.svg" alt="Ultralytics CI"></a>
+    <a href="https://clickpy.clickhouse.com/dashboard/ultralytics"><img src="https://static.pepy.tech/badge/ultralytics" alt="Ultralytics Downloads"></a>
+    <a href="https://discord.com/invite/ultralytics"><img alt="Ultralytics Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a>
+    <a href="https://community.ultralytics.com/"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a>
+    <a href="https://www.reddit.com/r/ultralytics/"><img alt="Ultralytics Reddit" src="https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue"></a>
+    <br>
+    <a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run Ultralytics on Gradient"></a>
+    <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Ultralytics In Colab"></a>
+    <a href="https://www.kaggle.com/models/ultralytics/yolo26"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open Ultralytics In Kaggle"></a>
+    <a href="https://mybinder.org/v2/gh/ultralytics/ultralytics/HEAD?labpath=examples%2Ftutorial.ipynb"><img src="https://mybinder.org/badge_logo.svg" alt="Open Ultralytics In Binder"></a>
+</div>
+</div>
+<br>
+
+<div align="center">
+  <a href="https://trendshift.io/repositories/1556?utm_source=repository-badge&amp;utm_medium=badge&amp;utm_campaign=badge-repository-1556" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/repositories/1556" alt="ultralytics%2Fultralytics | Trendshift" width="250" height="55"/></a>
+</div>
+<br>
+
+[Ultralytics](https://www.ultralytics.com/) creates cutting-edge, state-of-the-art (SOTA) [YOLO models](https://www.ultralytics.com/yolo) built on years of foundational research in computer vision and AI. Constantly updated for performance and flexibility, our models are **fast**, **accurate**, and **easy to use**. They excel at [object detection](https://docs.ultralytics.com/tasks/detect), [tracking](https://docs.ultralytics.com/modes/track), [instance segmentation](https://docs.ultralytics.com/tasks/segment), [semantic segmentation](https://docs.ultralytics.com/tasks/semantic), [image classification](https://docs.ultralytics.com/tasks/classify), and [pose estimation](https://docs.ultralytics.com/tasks/pose) tasks.
+
+Find detailed documentation in the [Ultralytics Docs](https://docs.ultralytics.com/). Get support via [GitHub Issues](https://github.com/ultralytics/ultralytics/issues/new/choose). Join discussions on [Discord](https://discord.com/invite/ultralytics), [Reddit](https://www.reddit.com/r/ultralytics/), and the [Ultralytics Community Forums](https://community.ultralytics.com/)!
+
+Request an Enterprise License for commercial use at [Ultralytics Licensing](https://www.ultralytics.com/license).
+
+<a href="https://platform.ultralytics.com/ultralytics/yolo26" target="_blank">
+  <img width="100%" src="https://raw.githubusercontent.com/ultralytics/assets/refs/heads/main/yolo/performance-comparison.png" alt="YOLO26 performance plots">
+</a>
+
+<div align="center">
+  <a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="2%" alt="Ultralytics GitHub"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
+  <a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="2%" alt="Ultralytics LinkedIn"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
+  <a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="2%" alt="Ultralytics Twitter"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
+  <a href="https://www.youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="2%" alt="Ultralytics YouTube"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
+  <a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="2%" alt="Ultralytics TikTok"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
+  <a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="2%" alt="Ultralytics BiliBili"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
+  <a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="2%" alt="Ultralytics Discord"></a>
+</div>
+
+## 📄 Documentation
+
+See below for quickstart installation and usage examples. For comprehensive guidance on training, validation, prediction, and deployment, refer to our full [Ultralytics Docs](https://docs.ultralytics.com/).
+
+<details open>
+<summary>Install</summary>
+
+Install the `ultralytics` package, including all [requirements](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml), in a [**Python>=3.8**](https://www.python.org/) environment with [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/).
+
+[![PyPI - Version](https://img.shields.io/pypi/v/ultralytics?logo=pypi&logoColor=white)](https://pypi.org/project/ultralytics/) [![Ultralytics Downloads](https://static.pepy.tech/badge/ultralytics)](https://clickpy.clickhouse.com/dashboard/ultralytics) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ultralytics?logo=python&logoColor=gold)](https://pypi.org/project/ultralytics/)
+
+```bash
+pip install ultralytics
+```
+
+For alternative installation methods, including [Conda](https://anaconda.org/conda-forge/ultralytics), [Docker](https://hub.docker.com/r/ultralytics/ultralytics), and building from source via Git, please consult the [Quickstart Guide](https://docs.ultralytics.com/quickstart).
+
+[![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics?logo=condaforge)](https://anaconda.org/conda-forge/ultralytics) [![Docker Image Version](https://img.shields.io/docker/v/ultralytics/ultralytics?sort=semver&logo=docker)](https://hub.docker.com/r/ultralytics/ultralytics) [![Ultralytics Docker Pulls](https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker)](https://hub.docker.com/r/ultralytics/ultralytics)
+
+</details>
+
+<details open>
+<summary>Usage</summary>
+
+### CLI
+
+You can use Ultralytics YOLO directly from the Command Line Interface (CLI) with the `yolo` command:
+
+```bash
+# Predict using a pretrained YOLO model (e.g., YOLO26n) on an image
+yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'
+```
+
+The `yolo` command supports various tasks and modes, accepting additional arguments like `imgsz=640`. Explore the YOLO [CLI Docs](https://docs.ultralytics.com/usage/cli) for more examples.
+
+### Python
+
+Ultralytics YOLO can also be integrated directly into your Python projects. It accepts the same [configuration arguments](https://docs.ultralytics.com/usage/cfg) as the CLI:
+
+```python
+from ultralytics import YOLO
+
+# Load a pretrained YOLO26n model
+model = YOLO("yolo26n.pt")
+
+# Train the model on the COCO8 dataset for 100 epochs
+train_results = model.train(
+    data="coco8.yaml",  # Path to dataset configuration file
+    epochs=100,  # Number of training epochs
+    imgsz=640,  # Image size for training
+    device="cpu",  # Device to run on (e.g., 'cpu', 0, [0,1,2,3])
+)
+
+# Evaluate the model's performance on the validation set
+metrics = model.val()
+
+# Perform object detection on an image
+results = model("path/to/image.jpg")  # Predict on an image
+results[0].show()  # Display results
+
+# Export the model to ONNX format for deployment
+path = model.export(format="onnx")  # Returns the path to the exported model
+```
+
+Discover more examples in the YOLO [Python Docs](https://docs.ultralytics.com/usage/python).
+
+</details>
+
+## ✨ Models
+
+Ultralytics supports a wide range of YOLO models, from early versions like [YOLOv3](https://docs.ultralytics.com/models/yolov3) to the latest [YOLO26](https://docs.ultralytics.com/models/yolo26). The tables below showcase YOLO26 models pretrained on [COCO](https://docs.ultralytics.com/datasets/detect/coco) for [Detection](https://docs.ultralytics.com/tasks/detect), [Segmentation](https://docs.ultralytics.com/tasks/segment), and [Pose Estimation](https://docs.ultralytics.com/tasks/pose). [Semantic Segmentation](https://docs.ultralytics.com/tasks/semantic) models are pretrained on [Cityscapes](https://docs.ultralytics.com/datasets/semantic/cityscapes), and [Classification](https://docs.ultralytics.com/tasks/classify) models are pretrained on [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet). [Tracking](https://docs.ultralytics.com/modes/track) mode is compatible with Detection, Segmentation, and Pose models. All [Models](https://docs.ultralytics.com/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+<a href="https://docs.ultralytics.com/tasks" target="_blank">
+    <img width="100%" src="https://raw.githubusercontent.com/ultralytics/assets/main/docs/ultralytics-yolov8-tasks-banner.avif" alt="Ultralytics YOLO supported tasks">
+</a>
+<br>
+<br>
+
+<details open><summary>Detection (COCO)</summary>
+
+Explore the [Detection Docs](https://docs.ultralytics.com/tasks/detect) for usage examples. These models are trained on the [COCO dataset](https://cocodataset.org/), featuring 80 object classes.
+
+| Model                                                                                | size<br><sup>(pixels)</sup> | mAP<sup>val<br>50-95</sup> | mAP<sup>val<br>50-95(e2e)</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
+| ------------------------------------------------------------------------------------ | --------------------------- | -------------------------- | ------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
+| [YOLO26n](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt) | 640                         | 40.9                       | 40.1                            | 38.9 ± 0.7                           | 1.7 ± 0.0                                 | 2.4                      | 5.4                     |
+| [YOLO26s](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s.pt) | 640                         | 48.6                       | 47.8                            | 87.2 ± 0.9                           | 2.5 ± 0.0                                 | 9.5                      | 20.7                    |
+| [YOLO26m](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m.pt) | 640                         | 53.1                       | 52.5                            | 220.0 ± 1.4                          | 4.7 ± 0.1                                 | 20.4                     | 68.2                    |
+| [YOLO26l](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l.pt) | 640                         | 55.0                       | 54.4                            | 286.2 ± 2.0                          | 6.2 ± 0.2                                 | 24.8                     | 86.4                    |
+| [YOLO26x](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x.pt) | 640                         | 57.5                       | 56.9                            | 525.8 ± 4.0                          | 11.8 ± 0.2                                | 55.7                     | 193.9                   |
+
+- **mAP<sup>val</sup>** values refer to single-model single-scale performance on the [COCO val2017](https://cocodataset.org/) dataset. See [YOLO Performance Metrics](https://docs.ultralytics.com/guides/yolo-performance-metrics) for details. <br>Reproduce with `yolo val detect data=coco.yaml device=0`
+- **Speed** metrics are averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce with `yolo val detect data=coco.yaml batch=1 device=0|cpu`
+
+</details>
+
+<details><summary>Segmentation (COCO)</summary>
+
+Refer to the [Segmentation Docs](https://docs.ultralytics.com/tasks/segment) for usage examples. These models are trained on [COCO-Seg](https://docs.ultralytics.com/datasets/segment/coco), including 80 classes.
+
+| Model                                                                                        | size<br><sup>(pixels)</sup> | mAP<sup>box<br>50-95(e2e)</sup> | mAP<sup>mask<br>50-95(e2e)</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
+| -------------------------------------------------------------------------------------------- | --------------------------- | ------------------------------- | -------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
+| [YOLO26n-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-seg.pt) | 640                         | 39.6                            | 33.9                             | 53.3 ± 0.5                           | 2.1 ± 0.0                                 | 2.7                      | 9.1                     |
+| [YOLO26s-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-seg.pt) | 640                         | 47.3                            | 40.0                             | 118.4 ± 0.9                          | 3.3 ± 0.0                                 | 10.4                     | 34.2                    |
+| [YOLO26m-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-seg.pt) | 640                         | 52.5                            | 44.1                             | 328.2 ± 2.4                          | 6.7 ± 0.1                                 | 23.6                     | 121.5                   |
+| [YOLO26l-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-seg.pt) | 640                         | 54.4                            | 45.5                             | 387.0 ± 3.7                          | 8.0 ± 0.1                                 | 28.0                     | 139.8                   |
+| [YOLO26x-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-seg.pt) | 640                         | 56.5                            | 47.0                             | 787.0 ± 6.8                          | 16.4 ± 0.1                                | 62.8                     | 313.5                   |
+
+- **mAP<sup>val</sup>** values are for single-model single-scale on the [COCO val2017](https://cocodataset.org/) dataset. See [YOLO Performance Metrics](https://docs.ultralytics.com/guides/yolo-performance-metrics) for details. <br>Reproduce with `yolo val segment data=coco.yaml device=0`
+- **Speed** metrics are averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce with `yolo val segment data=coco.yaml batch=1 device=0|cpu`
+
+</details>
+
+<details><summary>Semantic Segmentation (Cityscapes)</summary>
+
+See the [Semantic Segmentation Docs](https://docs.ultralytics.com/tasks/semantic) for usage examples. These models are trained on [Cityscapes](https://docs.ultralytics.com/datasets/semantic/cityscapes), including 19 classes.
+
+| Model                                                                                        | size<br><sup>(pixels)</sup> | mIoU<sup>val</sup> | Speed<br><sup>RTX3090 PyTorch<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
+| -------------------------------------------------------------------------------------------- | --------------------------- | ------------------ | ------------------------------------------- | ------------------------ | ----------------------- |
+| [YOLO26n-sem](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-sem.pt) | 1024 &times; 2048           | 78.3               | 4.4 ± 0.0                                   | 1.6                      | 22.7                    |
+| [YOLO26s-sem](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-sem.pt) | 1024 &times; 2048           | 80.8               | 8.4 ± 0.0                                   | 6.5                      | 88.8                    |
+| [YOLO26m-sem](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-sem.pt) | 1024 &times; 2048           | 82.0               | 19.9 ± 0.1                                  | 14.3                     | 304.5                   |
+| [YOLO26l-sem](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-sem.pt) | 1024 &times; 2048           | 82.9               | 26.5 ± 0.1                                  | 17.9                     | 384.7                   |
+| [YOLO26x-sem](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-sem.pt) | 1024 &times; 2048           | 83.6               | 48.9 ± 0.2                                  | 40.2                     | 861.7                   |
+
+- **mIoU<sup>val</sup>** values are for single-model single-scale on the [Cityscapes](https://www.cityscapes-dataset.com/) validation set. <br>Reproduce with `yolo semantic val data=cityscapes.yaml device=0 imgsz=2048`
+- **Speed** metrics are averaged over Cityscapes validation images using an RTX3090 instance. <br>Reproduce with `yolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048`
+
+</details>
+
+<details><summary>Classification (ImageNet)</summary>
+
+Consult the [Classification Docs](https://docs.ultralytics.com/tasks/classify) for usage examples. These models are trained on [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet), covering 1000 classes.
+
+| Model                                                                                        | size<br><sup>(pixels)</sup> | acc<br><sup>top1</sup> | acc<br><sup>top5</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B) at 224</sup> |
+| -------------------------------------------------------------------------------------------- | --------------------------- | ---------------------- | ---------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ------------------------------ |
+| [YOLO26n-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-cls.pt) | 224                         | 71.4                   | 90.1                   | 5.0 ± 0.3                            | 1.1 ± 0.0                                 | 2.8                      | 0.5                            |
+| [YOLO26s-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-cls.pt) | 224                         | 76.0                   | 92.9                   | 7.9 ± 0.2                            | 1.3 ± 0.0                                 | 6.7                      | 1.6                            |
+| [YOLO26m-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-cls.pt) | 224                         | 78.1                   | 94.2                   | 17.2 ± 0.4                           | 2.0 ± 0.0                                 | 11.6                     | 4.9                            |
+| [YOLO26l-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-cls.pt) | 224                         | 79.0                   | 94.6                   | 23.2 ± 0.3                           | 2.8 ± 0.0                                 | 14.1                     | 6.2                            |
+| [YOLO26x-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-cls.pt) | 224                         | 79.9                   | 95.0                   | 41.4 ± 0.9                           | 3.8 ± 0.0                                 | 29.6                     | 13.6                           |
+
+- **acc** values represent model accuracy on the [ImageNet](https://www.image-net.org/) dataset validation set. <br>Reproduce with `yolo val classify data=path/to/ImageNet device=0`
+- **Speed** metrics are averaged over ImageNet val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce with `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
+
+</details>
+
+<details><summary>Pose (COCO)</summary>
+
+See the [Pose Estimation Docs](https://docs.ultralytics.com/tasks/pose) for usage examples. These models are trained on [COCO-Pose](https://docs.ultralytics.com/datasets/pose/coco), focusing on the 'person' class.
+
+| Model                                                                                          | size<br><sup>(pixels)</sup> | mAP<sup>pose<br>50-95(e2e)</sup> | mAP<sup>pose<br>50(e2e)</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
+| ---------------------------------------------------------------------------------------------- | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
+| [YOLO26n-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-pose.pt) | 640                         | 57.2                             | 83.3                          | 40.3 ± 0.5                           | 1.8 ± 0.0                                 | 2.9                      | 7.5                     |
+| [YOLO26s-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-pose.pt) | 640                         | 63.0                             | 86.6                          | 85.3 ± 0.9                           | 2.7 ± 0.0                                 | 10.4                     | 23.9                    |
+| [YOLO26m-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-pose.pt) | 640                         | 68.8                             | 89.6                          | 218.0 ± 1.5                          | 5.0 ± 0.1                                 | 21.5                     | 73.1                    |
+| [YOLO26l-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-pose.pt) | 640                         | 70.4                             | 90.5                          | 275.4 ± 2.4                          | 6.5 ± 0.1                                 | 25.9                     | 91.3                    |
+| [YOLO26x-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-pose.pt) | 640                         | 71.6                             | 91.6                          | 565.4 ± 3.0                          | 12.2 ± 0.2                                | 57.6                     | 201.7                   |
+
+- **mAP<sup>val</sup>** values are for single-model single-scale on the [COCO Keypoints val2017](https://docs.ultralytics.com/datasets/pose/coco) dataset. See [YOLO Performance Metrics](https://docs.ultralytics.com/guides/yolo-performance-metrics) for details. <br>Reproduce with `yolo val pose data=coco-pose.yaml device=0`
+- **Speed** metrics are averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce with `yolo val pose data=coco-pose.yaml batch=1 device=0|cpu`
+
+</details>
+
+<details><summary>Oriented Bounding Boxes (DOTAv1)</summary>
+
+Check the [OBB Docs](https://docs.ultralytics.com/tasks/obb) for usage examples. These models are trained on [DOTAv1](https://docs.ultralytics.com/datasets/obb/dota-v2#dota-v10), including 15 classes.
+
+| Model                                                                                        | size<br><sup>(pixels)</sup> | mAP<sup>test<br>50-95(e2e)</sup> | mAP<sup>test<br>50(e2e)</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
+| -------------------------------------------------------------------------------------------- | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
+| [YOLO26n-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-obb.pt) | 1024                        | 52.4                             | 78.9                          | 97.7 ± 0.9                           | 2.8 ± 0.0                                 | 2.5                      | 14.0                    |
+| [YOLO26s-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-obb.pt) | 1024                        | 54.8                             | 80.9                          | 218.0 ± 1.4                          | 4.9 ± 0.1                                 | 9.8                      | 55.1                    |
+| [YOLO26m-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-obb.pt) | 1024                        | 55.3                             | 81.0                          | 579.2 ± 3.8                          | 10.2 ± 0.3                                | 21.2                     | 183.3                   |
+| [YOLO26l-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-obb.pt) | 1024                        | 56.2                             | 81.6                          | 735.6 ± 3.1                          | 13.0 ± 0.2                                | 25.6                     | 230.0                   |
+| [YOLO26x-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-obb.pt) | 1024                        | 56.7                             | 81.7                          | 1485.7 ± 11.5                        | 30.5 ± 0.9                                | 57.6                     | 516.5                   |
+
+- **mAP<sup>test</sup>** values are for single-model multiscale performance on the [DOTAv1 test set](https://captain-whu.github.io/DOTA/dataset.html). <br>Reproduce by `yolo val obb data=DOTAv1.yaml device=0 split=test` and submit merged results to the [DOTA evaluation server](https://captain-whu.github.io/DOTA/evaluation.html).
+- **Speed** metrics are averaged over [DOTAv1 val images](https://docs.ultralytics.com/datasets/obb/dota-v2#dota-v10) using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce by `yolo val obb data=DOTAv1.yaml batch=1 device=0|cpu`
+
+</details>
+
+## 🧩 Integrations
+
+Our key integrations with leading AI platforms extend the functionality of Ultralytics' offerings, enhancing tasks like dataset labeling, training, visualization, and model management. Discover how Ultralytics, in collaboration with partners like [Weights & Biases](https://docs.ultralytics.com/integrations/weights-biases), [Comet ML](https://docs.ultralytics.com/integrations/comet), [Roboflow](https://docs.ultralytics.com/integrations/roboflow), and [Intel OpenVINO](https://docs.ultralytics.com/integrations/openvino), can optimize your AI workflow. Explore more at [Ultralytics Integrations](https://docs.ultralytics.com/integrations).
+
+<a href="https://platform.ultralytics.com" target="_blank">
+    <img width="100%" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics active learning integrations">
+</a>
+
+## 🤝 Contribute
+
+We thrive on community collaboration! Ultralytics YOLO wouldn't be the SOTA framework it is without contributions from developers like you. Please see our [Contributing Guide](https://docs.ultralytics.com/help/contributing) to get started. We also welcome your feedback—share your experience by completing our [Survey](https://www.ultralytics.com/survey?utm_source=github&utm_medium=social&utm_campaign=Survey). A huge **Thank You** 🙏 to everyone who contributes!
+
+<!-- SVG image from https://opencollective.com/ultralytics/contributors.svg?width=1280 -->
+
+[![Ultralytics open-source contributors](https://raw.githubusercontent.com/ultralytics/assets/main/im/image-contributors.png)](https://github.com/ultralytics/ultralytics/graphs/contributors)
+
+We look forward to your contributions to help make the Ultralytics ecosystem even better!
+
+## 📜 License
+
+Ultralytics offers two licensing options to suit different needs:
+
+- **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**: For development and production use, this license enables seamless integration of Ultralytics software and AI models into business products and services, including internal tools, automated workflows, and production deployments, bypassing the open-source requirements of AGPL-3.0. To get started, please contact us via [Ultralytics Licensing](https://www.ultralytics.com/license).
+
+## 📞 Contact
+
+For bug reports and feature requests related to Ultralytics software, please visit [GitHub Issues](https://github.com/ultralytics/ultralytics/issues). For questions, discussions, and community support, join our active communities on [Discord](https://discord.com/invite/ultralytics), [Reddit](https://www.reddit.com/r/ultralytics/), and the [Ultralytics Community Forums](https://community.ultralytics.com/). We're here to help with all things Ultralytics!
+
+<br>
+<div align="center">
+  <a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://www.youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="3%" alt="Ultralytics BiliBili"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
+</div>

.venv/lib/python3.14/site-packages/ultralytics-8.4.83.dist-info/RECORD

@@ -0,0 +1,604 @@
+../../../bin/ultralytics,sha256=lvXJu3IMtOnv6tRwpHYHFJ0EXUyLBlj3sqdCStE-Q64,225
+../../../bin/yolo,sha256=lvXJu3IMtOnv6tRwpHYHFJ0EXUyLBlj3sqdCStE-Q64,225
+tests/__init__.py,sha256=aBOT1alCmdyNRPWC4VLK7yvNozZFYLB7BhLhEIkN2Vc,1382
+tests/__pycache__/__init__.cpython-314.pyc,,
+tests/__pycache__/cache_test_assets.cpython-314.pyc,,
+tests/__pycache__/conftest.cpython-314.pyc,,
+tests/__pycache__/test_cli.cpython-314.pyc,,
+tests/__pycache__/test_cuda.cpython-314.pyc,,
+tests/__pycache__/test_engine.cpython-314.pyc,,
+tests/__pycache__/test_exports.cpython-314.pyc,,
+tests/__pycache__/test_integrations.cpython-314.pyc,,
+tests/__pycache__/test_python.cpython-314.pyc,,
+tests/__pycache__/test_solutions.cpython-314.pyc,,
+tests/cache_test_assets.py,sha256=v0EU7gS3AXoCwUmlCszJUlEwZ6FNF20RVnCgtowwySc,3937
+tests/conftest.py,sha256=1jSGGXfYmE4zVBkB1w2vjaQepPf2AWUA0qcm93jtvVA,5263
+tests/test_cli.py,sha256=_KVuji9NvnJlNDPLmkBo7PgJBYMyDyt3ax6YovRqZ84,7196
+tests/test_cuda.py,sha256=5YdMbv2iFup23CbwPMMinwu_FNDapq7bgPxlIiNoUDo,8844
+tests/test_engine.py,sha256=NMPaSJdY7JHhIPyHMgiEdiRzH6oNzlL4jYaWPS42xgU,15276
+tests/test_exports.py,sha256=7LpOpkjTJ0rp4qk_KXYjOWG1ow4ncOozb88QKwQheiY,23502
+tests/test_integrations.py,sha256=H3ND6namUB8Ajwvb_ul12aRFeemslwwa1f7aMmZdAlg,6481
+tests/test_python.py,sha256=KbIr7qjsU0Q7TPAWFhmtZRd8AhufEpjr1m5mzgBdcSc,40607
+tests/test_solutions.py,sha256=nvTP6MtuwU742pdlzqexdEo8lCkybHURmwALZzwBxHo,14158
+ultralytics-8.4.83.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+ultralytics-8.4.83.dist-info/METADATA,sha256=FVTZQev05uLqMTu5_c3nOAenvByDHl4ld8fcOJHfjPs,41801
+ultralytics-8.4.83.dist-info/RECORD,,
+ultralytics-8.4.83.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ultralytics-8.4.83.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ultralytics-8.4.83.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.4.83.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.4.83.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics/__init__.py,sha256=EvUELO5v2GlZOoi7JxmL0HR1evkt3TPDlWh9knVhtFs,1301
+ultralytics/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
+ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
+ultralytics/cfg/__init__.py,sha256=d_Aj9m6tCjQy9SKnJvn4LFf9yS8t5QsU9yrvfqEL_bg,45019
+ultralytics/cfg/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/cfg/datasets/Argoverse.yaml,sha256=VLuhz_gPQZTAaBFHEzSC9PxMOY3z8TUyUBZVBAm_HFE,3353
+ultralytics/cfg/datasets/DOTAv1.5.yaml,sha256=X-u1bHSwFqf5-vgPIWiJfYev3KK9LHhXZz1ShQNkcc0,1212
+ultralytics/cfg/datasets/DOTAv1.yaml,sha256=GOPKL5JUbdFU_B7jWtOPdz27OnX_DJMCm7WIWrZABr8,1182
+ultralytics/cfg/datasets/GlobalWheat2020.yaml,sha256=_GjE5sxGcpLov7r-M06XsjWlolMiy3xLxs4ksw2lZRc,2143
+ultralytics/cfg/datasets/HomeObjects-3K.yaml,sha256=uQ-wWTT9W-Hr7hiuqa4rMS5ATnkQeMuGReaJsqxeP7U,933
+ultralytics/cfg/datasets/ImageNet.yaml,sha256=06smoReuJ9Q0XmzKlK0Y48z----SeaqgC6zdORy3b28,42528
+ultralytics/cfg/datasets/Objects365.yaml,sha256=fKgiwvntM-RpbfJmAgPmfL3k1lyXl0JZZb6e_RE8v14,9648
+ultralytics/cfg/datasets/SKU-110K.yaml,sha256=cVXoMAOHbik-MAOKqtke6TU2QCaEyn9cBlytqQeKh20,2608
+ultralytics/cfg/datasets/TT100K.yaml,sha256=CMb94ZxiADjg1oKZThY2DrSt7VsqxrxIK3zlCotfQHw,6895
+ultralytics/cfg/datasets/VOC.yaml,sha256=p-ZqQf5aP26FDqCfHZjfYOrDtzHB9VE5gpKlGlU9X2g,3802
+ultralytics/cfg/datasets/VisDrone.yaml,sha256=z0lG4KNLohaNKbVBHoMh4avjpbKCv90CyLs__roJu58,3396
+ultralytics/cfg/datasets/ade20k.yaml,sha256=DLj7DKcOa0rZHuJp72GgcU2XnBlypwp9ub-9tKdlid4,4322
+ultralytics/cfg/datasets/african-wildlife.yaml,sha256=GH81S5fG5dAibTw_p1c0ivaLnnvXlGF3kzWtbyU3ejo,914
+ultralytics/cfg/datasets/brain-tumor.yaml,sha256=y5Skd-Yy9wmAfF3E40LYvHQkYsgbDlWU5aKg0EhOwJY,799
+ultralytics/cfg/datasets/carparts-seg.yaml,sha256=6Xy2UDEzsdUk-s3qgOSrrCFFByiunaJ7qHpL-JrsXb8,1252
+ultralytics/cfg/datasets/cityscapes.yaml,sha256=hvqK65DEjCM0Xjl9xTqlQxUkYyBQjfRQ2zn561GCnEA,2998
+ultralytics/cfg/datasets/cityscapes8.yaml,sha256=MM7KLZW1Jh2duhIaNM5v6PkUtlFgIypzXDrdnhL5kII,1623
+ultralytics/cfg/datasets/coco-pose.yaml,sha256=fgiCiMjacLl9g-npcl19AqFJd9kkitUZEOHFakAmQc4,1927
+ultralytics/cfg/datasets/coco.yaml,sha256=fgUmbfvfIGlPWgkm0GBb1xJKzkSc8tzow4nOAJ2jctA,2572
+ultralytics/cfg/datasets/coco12-formats.yaml,sha256=ZzXepkW2h3u9xJpYYZCPNS9E7htGLKfzxGLTq-aioQo,1952
+ultralytics/cfg/datasets/coco128-seg.yaml,sha256=lr8lrEnrsIM4bqG1YI9hYBrAfygf5CMu9opG8FXJf5Y,1992
+ultralytics/cfg/datasets/coco128.yaml,sha256=B6CDxu3TCY1Mm3x-iRXEbM2N1IyOuXC_sU2ViVg5KEQ,1967
+ultralytics/cfg/datasets/coco8-grayscale.yaml,sha256=ZbTr4lQpqVWCHw9d4Pghi9e3fJagrMLqXqX0wtU06G8,1960
+ultralytics/cfg/datasets/coco8-multispectral.yaml,sha256=mDcNFGmSKT-bBk88EDDnIvuy18utSjAXlso1S581Aok,2062
+ultralytics/cfg/datasets/coco8-pose.yaml,sha256=oaFyz668gJUfiL83UleJSch6UNV-biiL2rLTM6RrZPs,1335
+ultralytics/cfg/datasets/coco8-seg.yaml,sha256=iXAMV5GP2xIO2PHl1JDHXvyIob2neo8RlKHkOVDac7Q,1912
+ultralytics/cfg/datasets/coco8.yaml,sha256=Awqv-gj4oWHcNYfSFqqVbAyJR-WUstnYUVo2uaxE-fo,1887
+ultralytics/cfg/datasets/construction-ppe.yaml,sha256=iSa27Cwowv1vycVK_o3hK8UXwHE8EdNTI6NvDVBynck,1007
+ultralytics/cfg/datasets/crack-seg.yaml,sha256=jY7IZUxOamioCdcBdNO5eXt8fVeS40gCmbebouQpzkM,836
+ultralytics/cfg/datasets/dog-pose.yaml,sha256=OboPj_y8QlEGH9ECqLNuT32RY_YapEo3IUn8Walvym0,1407
+ultralytics/cfg/datasets/dota128.yaml,sha256=Kzktc64z93wTZdg3hvHrZyszlhNTZ4oPVsbXkkmtVGg,1079
+ultralytics/cfg/datasets/dota8-multispectral.yaml,sha256=sZzrP1SUMryEJe8syMb6BsAghIbyfMQuqHI0BxiMRS4,1216
+ultralytics/cfg/datasets/dota8.yaml,sha256=W_3Bcp8dRHeOL0VFWsaaNEXq8Kj2PzgYwVEQqeOtNqQ,1058
+ultralytics/cfg/datasets/hand-keypoints.yaml,sha256=wPLYeZmGQ8lWI89oLwRVMDGnBka6H7yPZCtxeg8P878,1362
+ultralytics/cfg/datasets/kitti.yaml,sha256=PRyDF6bkfG3X4aYv6PTUTSGHiCUsVAA2i9i8KO9OElI,894
+ultralytics/cfg/datasets/lvis.yaml,sha256=0XwKkQW5d7VVkIHJP8KmLq2oxaUYPcR2L-mlp1hA870,29595
+ultralytics/cfg/datasets/medical-pills.yaml,sha256=5GLYrB0rwkOrDSe1KswZAuly1LWdNyW1GsASRGHaKEM,791
+ultralytics/cfg/datasets/open-images-v7.yaml,sha256=SXRor53GRNFJEB78CQcn08b9ZEWR9MwujFresA9K2Eg,12115
+ultralytics/cfg/datasets/package-seg.yaml,sha256=uBzKJHCJtyfV-Omza8Fww6h_NDpNGIQco2wN513vj5w,848
+ultralytics/cfg/datasets/signature.yaml,sha256=134eo-EpaK9XxISzTZnUP2bNtn3Hb-5j_-nO4Pt-JJM,773
+ultralytics/cfg/datasets/tiger-pose.yaml,sha256=DQk5S7uH5JbP3pD6Q7I12AAagNRA3AKiZTeubsjhYR4,1195
+ultralytics/cfg/datasets/xView.yaml,sha256=m2pWXw_SheDPwkPdNEVLIlx9uLhTEOTgOxePe7MG2Jo,5405
+ultralytics/cfg/default.yaml,sha256=9uGatyKIJjQcxjcLzIx40QR40r1gTiWhPZl1te_JtBA,9690
+ultralytics/cfg/models/11/yolo11-cls-resnet18.yaml,sha256=1Ycp9qMrwpb8rq7cqht3Q-1gMN0R87U35nm2j_isdro,524
+ultralytics/cfg/models/11/yolo11-cls.yaml,sha256=17l5GdN-Vst4LvafsK2-q6Li9VX9UlUcT5ClCtikweE,1412
+ultralytics/cfg/models/11/yolo11-obb.yaml,sha256=FHo7xWrhKdN2BBn2xdZ099T2NcqcUJiuyQ0a6zdvrqY,2031
+ultralytics/cfg/models/11/yolo11-pose.yaml,sha256=dWOT9VBRxD8h-jmQC0qWEOvFvyx1CUa0tekt1kOdvmk,2131
+ultralytics/cfg/models/11/yolo11-seg.yaml,sha256=xyTWVhFoSszF1LhNEIznIW8QGKU1z0EAIvkp4OwYtls,2046
+ultralytics/cfg/models/11/yolo11.yaml,sha256=Q9inyGrMdygt30lm1lJuCR5bBkwUDtSm5MC2jsvDeEw,2012
+ultralytics/cfg/models/11/yoloe-11-seg.yaml,sha256=j053cYgHMCRFUxJ7MumNkHz7eq6hxvcMMuNOzNsdV1w,2072
+ultralytics/cfg/models/11/yoloe-11.yaml,sha256=qxKDa8Xt-embNVOLOthfQlt1N0kFFHnGFO74R_CQzUw,2038
+ultralytics/cfg/models/12/yolo12-cls.yaml,sha256=yJBuDOXRYLa-LQipGkLBT97ujKSyXx755zts612JVWc,1407
+ultralytics/cfg/models/12/yolo12-obb.yaml,sha256=2cPJKV7kU1thYxnnNsCJPfWNoTk0l29ZD22U4XTX3wQ,1972
+ultralytics/cfg/models/12/yolo12-pose.yaml,sha256=eBo-9b3o_qv3-jftgCaX0FedeJWOfKHDLJPPfCMwu7M,2072
+ultralytics/cfg/models/12/yolo12-seg.yaml,sha256=0JTqSjyhOTLNTIrIFAOuu6F7yQqMkq1soscAkSZtsz8,1985
+ultralytics/cfg/models/12/yolo12.yaml,sha256=ZeA8LuymJXPNjZ5xkxkZHkcktDaKDzUBb2Kc3gCLC1w,1953
+ultralytics/cfg/models/26/yolo26-cls.yaml,sha256=GmaLvnB62X6r9_mZwpx0b2LTRYIXzVYqSqR3Mcy336g,1432
+ultralytics/cfg/models/26/yolo26-obb.yaml,sha256=A9Ng5nZOow74tYkejxoVyGB2wztIi_cuNqxYrqB5T38,2146
+ultralytics/cfg/models/26/yolo26-p2.yaml,sha256=Dbwvo9_t5e3NolZquMfqFQrQZuop155o1sTaK6tHYnk,2405
+ultralytics/cfg/models/26/yolo26-p6.yaml,sha256=YFWaH6NAOHoLYmH4Te3edcj5-c7QJ-glzri-xPFk4U0,2457
+ultralytics/cfg/models/26/yolo26-pose.yaml,sha256=B7qC2WNwI_Jh5SbDj6muuKsF2RF2b_2M9PSM0z8nGI0,2245
+ultralytics/cfg/models/26/yolo26-seg.yaml,sha256=U8A0ijaj4Zu8O9T2lfUMu_yXowWfYumyUfJ4rXT918s,2156
+ultralytics/cfg/models/26/yolo26-sem.yaml,sha256=rX3g2vBk7U9T7ejtCjLWqjOaXaPNMEeR2BWq2oe5nYI,1850
+ultralytics/cfg/models/26/yolo26.yaml,sha256=sdH6DGns7WT5k5U2A4vY1pfDLnIgCzQYenZ95DGvfvA,2120
+ultralytics/cfg/models/26/yoloe-26-seg.yaml,sha256=QlyK3awjLOjs9q0raj0we5QCG1tDy-NvQ2uQzKDoBYk,2223
+ultralytics/cfg/models/26/yoloe-26.yaml,sha256=YWsBS4D3f7QhqLQzYT-LVdCOISo0VaTILIaLKmujDdo,2191
+ultralytics/cfg/models/rt-detr/rtdetr-l.yaml,sha256=hXFvYmdpy13fANWfz2yvtYFKrRljKBAL3HyTMG9lDoM,2043
+ultralytics/cfg/models/rt-detr/rtdetr-resnet101.yaml,sha256=5vCPfihyzXMKCR7kYYIDSHbSHvAzYlWbOZ5Wp9m84Ms,1696
+ultralytics/cfg/models/rt-detr/rtdetr-resnet50.yaml,sha256=Xm-U_m-_okdspiW7qxb5mgN_NPZPvyjXrS1A1KcoaFo,1692
+ultralytics/cfg/models/rt-detr/rtdetr-x.yaml,sha256=QHa3B5Pwd9TA9B3W5lEwrUl-_bAvwGXVqSlvnLSbKNs,2250
+ultralytics/cfg/models/v10/yolov10b.yaml,sha256=W9K-lqgUEKOCpV0Ae7dk8iBUFpSTTFzDPDL3AHnMKfs,1488
+ultralytics/cfg/models/v10/yolov10l.yaml,sha256=YtdL74ivxWxY2jUsYkkUX_WraWsLJtcOKhRNioCwvJg,1488
+ultralytics/cfg/models/v10/yolov10m.yaml,sha256=YQuxn4KjiGqxwK-3BuRSprt86aWxcxn2VngIlHQKxy4,1479
+ultralytics/cfg/models/v10/yolov10n.yaml,sha256=iL9T4XUrTnf001i6e9qF9wEBCUoral_fF5bjIFxJdMU,1474
+ultralytics/cfg/models/v10/yolov10s.yaml,sha256=dG_z0fSweIzCi7Km9OY-Q9IztEOjX67wFsdP4Eam_to,1483
+ultralytics/cfg/models/v10/yolov10x.yaml,sha256=IFIYR5p46OECsHK3yz5UO5CMxR1JNDWeXKzUQQvxM_M,1491
+ultralytics/cfg/models/v3/yolov3-spp.yaml,sha256=hsM-yhdWv-8XlWuaSOVqFJcHUVZ-FmjH4QjkA9CHJZU,1625
+ultralytics/cfg/models/v3/yolov3-tiny.yaml,sha256=SYrSg0m1A6ErUapdrJDI5E-edLaH0oF-NRb558DZgmQ,1330
+ultralytics/cfg/models/v3/yolov3.yaml,sha256=Fvt4_PTwLBpRw3R4v4VQ-1PIiojpoFZD1uuTZySUYSw,1612
+ultralytics/cfg/models/v5/yolov5-p6.yaml,sha256=VKEWykksykSlzvuy7if4yFo9WlblC3hdqcNxJ9bwHek,1994
+ultralytics/cfg/models/v5/yolov5.yaml,sha256=QD8dRe5e5ys52wXPKvNJn622H_3iX0jPzE_2--2dZx0,1626
+ultralytics/cfg/models/v6/yolov6.yaml,sha256=tl04iHe4dVg_78jgupVul5gbqOn5hBhtLKfP3xYxcWA,1813
+ultralytics/cfg/models/v8/yoloe-v8-seg.yaml,sha256=5cjZ2xCMUF2pV7gv1ZoRFEV6Lo6v4slMQt1lU7_Jqtc,2064
+ultralytics/cfg/models/v8/yoloe-v8.yaml,sha256=dujtgHql2RzqqEEpB4UzsEpAXMRarkltnt8vb1usILc,2015
+ultralytics/cfg/models/v8/yolov8-cls-resnet101.yaml,sha256=TAiAkZwUckzjWdY6yn_ulGzM-lnHaY7Yx9v8rI-2WoA,1014
+ultralytics/cfg/models/v8/yolov8-cls-resnet50.yaml,sha256=gbIttNMvj02Rk3eKjq45qgjdmdCo5n_mV9R5xt65OdU,1010
+ultralytics/cfg/models/v8/yolov8-cls.yaml,sha256=G50mnw-C0SWrZpZl5wzov1dugdjZMM6zT30t5cQrcJQ,1019
+ultralytics/cfg/models/v8/yolov8-ghost-p2.yaml,sha256=5MX8D3_8lkj9aKVwpAIC1PZAaMoTFs_Wq-XZUTVn9PU,2505
+ultralytics/cfg/models/v8/yolov8-ghost-p6.yaml,sha256=c7YYnEPx2vrwHjbgr4o_Q9f_NI2X1dx2MrLo9xeOvXc,2575
+ultralytics/cfg/models/v8/yolov8-ghost.yaml,sha256=nxzIlvntFajHbu4DN8ujEx65PREgn7o0Dd6cHp8pHSM,2198
+ultralytics/cfg/models/v8/yolov8-obb.yaml,sha256=Owlncx5peKBTNo3xhkbVxz_1qlzVJR4Z2zNeoR_NDxg,2016
+ultralytics/cfg/models/v8/yolov8-p2.yaml,sha256=ulQ2Pp8oPo9gsPoIQ-s3EVCTM41vknPM1PdPYGOXVPQ,1831
+ultralytics/cfg/models/v8/yolov8-p6.yaml,sha256=TqIsa8gNEW04KmdLxxC9rqhd7PCHlUqkzoiDxnMTio0,2363
+ultralytics/cfg/models/v8/yolov8-pose-p6.yaml,sha256=tfgfYrbVu5biWCWmdTZRr7ZRC-zlAzycsRyaJbDtI1g,2047
+ultralytics/cfg/models/v8/yolov8-pose.yaml,sha256=LdzbiIVknZQMLYB2wzCHqul3NilfKp4nx5SdaGQsF6s,1676
+ultralytics/cfg/models/v8/yolov8-rtdetr.yaml,sha256=5cupHKPHD43cuvd3H3zvNijiqpW9-bFLKg-KMeRzOPE,2055
+ultralytics/cfg/models/v8/yolov8-seg-p6.yaml,sha256=7FlNlY-sB8bCcVty2Hf_nYD8fxZpsqaTgGxTfac8DRI,1958
+ultralytics/cfg/models/v8/yolov8-seg.yaml,sha256=hFeiOFVwTV4zv08IrmTIuzJcUZmYkY7SIi2oV322e6U,1587
+ultralytics/cfg/models/v8/yolov8-world.yaml,sha256=2hNQoybITO5FBNnKKz05Pk9ygeAf4qW7XvkMEfBd90A,2174
+ultralytics/cfg/models/v8/yolov8-worldv2.yaml,sha256=UkdRhk7pauLIZto7QdOrWpW8Mb-3J61RdRuxS5lZC24,2124
+ultralytics/cfg/models/v8/yolov8.yaml,sha256=QFo8MC62CWEDqZr02CwdLYsrv_RpoijFWqyUSywZZyo,1977
+ultralytics/cfg/models/v9/yolov9c-seg.yaml,sha256=UBHoQ_cJV2yp6rMzHXRp46uBAUmKIrbgd3jiEBPRvqI,1447
+ultralytics/cfg/models/v9/yolov9c.yaml,sha256=x1kus_2mQdU9V3ZGg0XdE5WTUU3j8fwGe1Ou3x2aX5I,1426
+ultralytics/cfg/models/v9/yolov9e-seg.yaml,sha256=WVpU5jHgoUuCMVirvmn_ScOmH9d1MyVVIX8XAY8787c,2377
+ultralytics/cfg/models/v9/yolov9e.yaml,sha256=Olr2PlADpkD6N1TiVyAJEMzkrA7SbNul1nOaUF8CS38,2355
+ultralytics/cfg/models/v9/yolov9m.yaml,sha256=WcKQ3xRsC1JMgA42Hx4xzr4FZmtE6B3wKvqhlQxkqw8,1411
+ultralytics/cfg/models/v9/yolov9s.yaml,sha256=cWkQtYNWWOckOBXjd8XrJ_q5v6T_C54xGMP1S3qnpZU,1392
+ultralytics/cfg/models/v9/yolov9t.yaml,sha256=Q8GpSXE7fumhuJiQg4a2SkuS_UmnXqp-eoZxW_C0vEo,1375
+ultralytics/cfg/trackers/botsort.yaml,sha256=jNiJMNO-VVe-B3fzhO7P8KNqcBGFD-YT_ApoF4v9WwE,1385
+ultralytics/cfg/trackers/bytetrack.yaml,sha256=OVcB2UenSRed7j4yexGBtzDEypjnysWiqwUoCq5XO4s,856
+ultralytics/cfg/trackers/deepocsort.yaml,sha256=2N6cOrpVc5LYSWsVRS0NxtWM86LotVLT2iZvImwlLMA,1901
+ultralytics/cfg/trackers/fasttrack.yaml,sha256=YAeLULJ9sh54zQ3BCTY5yO53tPhqzNvFZlfTrClEPtc,1584
+ultralytics/cfg/trackers/ocsort.yaml,sha256=VduR8U2z8BRm2Banrw-fqu63T0SF2mMBnH7WmpqvtuM,1267
+ultralytics/cfg/trackers/tracktrack.yaml,sha256=M_zQz0ICP6vBz_k-h2n5SeP5Kjkhmot94Vf8YSod43o,1889
+ultralytics/data/__init__.py,sha256=KsV__8wWRNzjd-iUeIX57Pvtmet28MSxjHqG1ux-YoM,702
+ultralytics/data/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/data/__pycache__/annotator.cpython-314.pyc,,
+ultralytics/data/__pycache__/augment.cpython-314.pyc,,
+ultralytics/data/__pycache__/base.cpython-314.pyc,,
+ultralytics/data/__pycache__/build.cpython-314.pyc,,
+ultralytics/data/__pycache__/converter.cpython-314.pyc,,
+ultralytics/data/__pycache__/dataset.cpython-314.pyc,,
+ultralytics/data/__pycache__/loaders.cpython-314.pyc,,
+ultralytics/data/__pycache__/split.cpython-314.pyc,,
+ultralytics/data/__pycache__/split_dota.cpython-314.pyc,,
+ultralytics/data/__pycache__/utils.cpython-314.pyc,,
+ultralytics/data/annotator.py,sha256=iu1En-LzlR4RyR3ocftthnAog_peQHV9ForPRo_QcX8,2985
+ultralytics/data/augment.py,sha256=gjcuITBVF8mdeOzbtotdSWJspmk-77gE83Nu0lyfYJw,137544
+ultralytics/data/base.py,sha256=aRWZbN8aApEmycYRcdZbpgz4Y6IFV77S4q88NM6csCk,21125
+ultralytics/data/build.py,sha256=aH-W8UzHZHntjJtq_tSQ-Q7IbuqJj86wCrfbz8Fdlvc,17816
+ultralytics/data/converter.py,sha256=r4JcwdMWHy6LIRo1Mgk-OS2-H03D8t4h2SzIAPDiizA,41508
+ultralytics/data/dataset.py,sha256=dpAKQkdPsTt4ciZ9FMbJZFqecGBAagz7Athtw5ITaQM,50820
+ultralytics/data/loaders.py,sha256=3S6ypo1pamNk5MWBHGzeVtB-kiXBMwQQHhYY2AXnmyM,31697
+ultralytics/data/scripts/download_weights.sh,sha256=0y8XtZxOru7dVThXDFUXLHBuICgOIqZNUwpyL4Rh6lg,595
+ultralytics/data/scripts/get_coco.sh,sha256=UuJpJeo3qQpTHVINeOpmP0NYmg8PhEFE3A8J3jKrnPw,1768
+ultralytics/data/scripts/get_coco128.sh,sha256=qmRQl_hOKrsdHrTrnyQuFIH01oDz3lfaz138OgGfLt8,650
+ultralytics/data/scripts/get_imagenet.sh,sha256=hr42H16bM47iT27rgS7MpEo-GeOZAYUQXgr0B2cwn48,1705
+ultralytics/data/split.py,sha256=Ds8Etjc9lLpfNmY3mChxvg_wuuWd350QLf2mQHu7-kg,5122
+ultralytics/data/split_dota.py,sha256=dqz3DApL8eAkMCKeD8UEyR2UV8rjXbCqQzUrrd702Fk,12873
+ultralytics/data/utils.py,sha256=XqVrAiI2vBJREwkvGKFXlsOWHwqjpaFHIGHFawmnqc4,40392
+ultralytics/engine/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6DXppv1-QUM,70
+ultralytics/engine/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/engine/__pycache__/exporter.cpython-314.pyc,,
+ultralytics/engine/__pycache__/model.cpython-314.pyc,,
+ultralytics/engine/__pycache__/predictor.cpython-314.pyc,,
+ultralytics/engine/__pycache__/results.cpython-314.pyc,,
+ultralytics/engine/__pycache__/trainer.cpython-314.pyc,,
+ultralytics/engine/__pycache__/tuner.cpython-314.pyc,,
+ultralytics/engine/__pycache__/validator.cpython-314.pyc,,
+ultralytics/engine/exporter.py,sha256=I1MOSeVAdqWWMi0IAodhOLTYvC8heHbyioOyv9YGaFE,74087
+ultralytics/engine/model.py,sha256=4xxyMqTMTE6VtcKX0SV0ypTpPTXpuy3JZ0TlxFchUxc,55936
+ultralytics/engine/predictor.py,sha256=LcgTiMZqEKBpv-pUnHe0txE6Sfbel8SwcRaaghPgg9A,23490
+ultralytics/engine/results.py,sha256=sUc7ir53VOk3bVarmNHDcHFgRQ8DTF_AULVOJO-MDdo,71545
+ultralytics/engine/trainer.py,sha256=RINrpq_oAfyWsg_IssVcFpRfql82gWUdFYUvAuRAI1M,63982
+ultralytics/engine/tuner.py,sha256=0hP39op56BS8GX29RLdO-a5h3YTNjc-xExcp1gxSgkc,27999
+ultralytics/engine/validator.py,sha256=yaOtrP0W2a_Oh1-L92B2foDQShXRajj7wVQdsBZtqYI,18703
+ultralytics/hub/__init__.py,sha256=7LyzMguIzOnUz1CgrXYvAy93w_navq9oGuoVa3iZmII,6729
+ultralytics/hub/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/hub/__pycache__/auth.cpython-314.pyc,,
+ultralytics/hub/__pycache__/session.cpython-314.pyc,,
+ultralytics/hub/__pycache__/utils.cpython-314.pyc,,
+ultralytics/hub/auth.py,sha256=sNT8jyHXTHe5egiy9WvRgyIWjI22I57enGiHkhQlJXM,6699
+ultralytics/hub/google/__init__.py,sha256=r06Ld4TuZEBOqg4iagpeN-eMAkg43T2OTxOH4_7IfkM,8445
+ultralytics/hub/google/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/hub/session.py,sha256=bHUYgKkhzWSzH_VHd6Tg3MrlrEwnODx5hQ4McMB1jWY,18354
+ultralytics/hub/utils.py,sha256=NyG2aQdA-OJtHhJfETZ5QQCuZ-CICIkNDneDWb5lidg,6822
+ultralytics/models/__init__.py,sha256=ZJ0u7d_x0DTU1BLrF8L-8E4QoUHtrEiQ41jIFNWLBW0,642
+ultralytics/models/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/fastsam/__init__.py,sha256=Ku89Fy_X8ok3YPEUajjUZ5i4O08jdJMjJHt-3Z99Frk,231
+ultralytics/models/fastsam/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/fastsam/__pycache__/model.cpython-314.pyc,,
+ultralytics/models/fastsam/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/fastsam/__pycache__/utils.cpython-314.pyc,,
+ultralytics/models/fastsam/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/fastsam/model.py,sha256=HN6CAHCTwMmyBCQlXx4wMBU7XqkvVHyUawRaxn2Gur8,3426
+ultralytics/models/fastsam/predict.py,sha256=01araYUgwWO_Yz_W6mTZusOj7v-S3175eUqkpbxv5P8,8853
+ultralytics/models/fastsam/utils.py,sha256=de9ieh4pBUuTNh5HTiNdRpWZhXAaSfNo3R1FNMt2GOE,879
+ultralytics/models/fastsam/val.py,sha256=MJUKx_NpFEeuqSq9ynX1FJSK6F5RhUJB-PqhQp2Q0YM,2091
+ultralytics/models/nas/__init__.py,sha256=Q4ZQak8xNWtV5YSw_pFu0anbCyDxxEAuMMDfMzu6-0s,207
+ultralytics/models/nas/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/nas/__pycache__/model.cpython-314.pyc,,
+ultralytics/models/nas/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/nas/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/nas/model.py,sha256=as1NSv1pCDbyA-vNzD6pgmEIJVlinx4y20slISYsIoY,3910
+ultralytics/models/nas/predict.py,sha256=4nbuo9nbvnvI3qVH1ylhLCjo-7oW39MumIesm-1eU3Y,2692
+ultralytics/models/nas/val.py,sha256=MIRym3LQNDIRxnYs5xcOiLkKOgv3enZFXh5_g9Pq2hA,1543
+ultralytics/models/rtdetr/__init__.py,sha256=F4NEQqtcVKFxj97Dh7rkn2Vu3JG4Ea_nxqrBB-9P1vc,225
+ultralytics/models/rtdetr/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/rtdetr/__pycache__/model.cpython-314.pyc,,
+ultralytics/models/rtdetr/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/rtdetr/__pycache__/train.cpython-314.pyc,,
+ultralytics/models/rtdetr/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/rtdetr/model.py,sha256=jJzSh_5E__rVQO7_IkmncpC4jIdu9xNiIxlTTIaFJVw,2269
+ultralytics/models/rtdetr/predict.py,sha256=SU5UPoyxLmFCZ2IsSaYb6vux8bsrw90K79FajFDdl80,3969
+ultralytics/models/rtdetr/train.py,sha256=exPmset_CWK3ZBer3btEvDLttgMPXusMr21WsJF3bkg,3740
+ultralytics/models/rtdetr/val.py,sha256=dvDDlV44X3Yi51EJ-vln_8_JOTuX0b4pPIMcqDg2qbo,8936
+ultralytics/models/sam/__init__.py,sha256=hofz9cGGhxEWpZXX8yLp5k_LQUmWL_Shd9kfzK4U6z0,592
+ultralytics/models/sam/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/sam/__pycache__/amg.cpython-314.pyc,,
+ultralytics/models/sam/__pycache__/build.cpython-314.pyc,,
+ultralytics/models/sam/__pycache__/build_sam3.cpython-314.pyc,,
+ultralytics/models/sam/__pycache__/model.cpython-314.pyc,,
+ultralytics/models/sam/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/sam/amg.py,sha256=aYvJ7jQMkTR3X9KV7SHi3qP3yNchQggWNUurTRZwxQg,11786
+ultralytics/models/sam/build.py,sha256=si1hdoTAeHK4tNd8GhpzTTlPvis_baGDlYm-EVelkPU,12860
+ultralytics/models/sam/build_sam3.py,sha256=dFlaZIdEP7ZPPWD4p5vV8YzrnNnFvEdnigee6xF3kFU,12206
+ultralytics/models/sam/model.py,sha256=uySve5lRbaKqzpyeAMWazzrghXvEf2Hhat9NrlY8d5g,7372
+ultralytics/models/sam/modules/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6DXppv1-QUM,70
+ultralytics/models/sam/modules/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/sam/modules/__pycache__/blocks.cpython-314.pyc,,
+ultralytics/models/sam/modules/__pycache__/decoders.cpython-314.pyc,,
+ultralytics/models/sam/modules/__pycache__/encoders.cpython-314.pyc,,
+ultralytics/models/sam/modules/__pycache__/memory_attention.cpython-314.pyc,,
+ultralytics/models/sam/modules/__pycache__/sam.cpython-314.pyc,,
+ultralytics/models/sam/modules/__pycache__/tiny_encoder.cpython-314.pyc,,
+ultralytics/models/sam/modules/__pycache__/transformer.cpython-314.pyc,,
+ultralytics/models/sam/modules/__pycache__/utils.cpython-314.pyc,,
+ultralytics/models/sam/modules/blocks.py,sha256=8YzIRTXywRovNb-ds6VMcvHd-gPsij336Muo8LzPV3U,44466
+ultralytics/models/sam/modules/decoders.py,sha256=MGUC8zs8FFtSacBwrp4Nva7sgYmCXpULPW-TmVXz4wg,25045
+ultralytics/models/sam/modules/encoders.py,sha256=dggzE0L6f-Yt3UCQRUBfihZtmAspgCyySb6TqdFZW1U,35521
+ultralytics/models/sam/modules/memory_attention.py,sha256=x8AjFkmK7sx4qXDCdJ_yBsxtQBqeldYNBMRe8ntpLHs,13287
+ultralytics/models/sam/modules/sam.py,sha256=91DEeUIwHhREoJ7Bxr6lD5ztonGUlnZOV9fR7x98ho8,61669
+ultralytics/models/sam/modules/tiny_encoder.py,sha256=xnroC5KLwHG4rdcto2IWyJrR7hbUUF7201-meGh5XlM,42355
+ultralytics/models/sam/modules/transformer.py,sha256=qGcEt5coPyWeaXjK1nzt-ID5HW2Q30u6tAxSyOkx3Sg,14884
+ultralytics/models/sam/modules/utils.py,sha256=HwHAf_yxMnYc1cs5bAnPIDyOkIbrUMw0qha9TB8olU0,21371
+ultralytics/models/sam/predict.py,sha256=-YXDCbX-fIn1bFlZZzInmdnwFXnVcp0UaPqsrK-HW2U,204699
+ultralytics/models/sam/sam3/__init__.py,sha256=aM4-KimnYgIFe-e5ctLT8e6k9PagvuvKFaHaagDZM7E,144
+ultralytics/models/sam/sam3/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/decoder.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/encoder.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/geometry_encoders.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/maskformer_segmentation.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/model_misc.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/necks.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/sam3_image.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/text_encoder_ve.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/vitdet.cpython-314.pyc,,
+ultralytics/models/sam/sam3/__pycache__/vl_combiner.cpython-314.pyc,,
+ultralytics/models/sam/sam3/decoder.py,sha256=pjNDET-GRcaDhB9oWnuAOGED_pTsM-3MGjL7LSBLj5U,23006
+ultralytics/models/sam/sam3/encoder.py,sha256=zHDR-8W5e9dH_2KG4BbXb89PnHY08V2v-bzrEOSYnjc,21751
+ultralytics/models/sam/sam3/geometry_encoders.py,sha256=C2u5RD0sCdShp6KsrratSOwpNUmqRQ72wJ409-_q5oE,17667
+ultralytics/models/sam/sam3/maskformer_segmentation.py,sha256=jf9qJj7xyTVGp7OZ5uJQF0EUD468EOnBm1PsjiTO2ug,10735
+ultralytics/models/sam/sam3/model_misc.py,sha256=rA0ZOMH-S2NrO7tyBcVDmmI0DdAmWRyR827AZIHi3nA,7926
+ultralytics/models/sam/sam3/necks.py,sha256=SmkgJZBJSMXW5XBY5rEsSu5mjtWT2IE0jH4eWtwLOFA,4767
+ultralytics/models/sam/sam3/sam3_image.py,sha256=IxwnI0TM1oRiUcOjAmOolDlFNcWTirtlIeA8QpYE6GE,13454
+ultralytics/models/sam/sam3/text_encoder_ve.py,sha256=iv8-6VA3t4yJ1M42RPjHDlFuH9P_nNRSNyaoFn2sjMw,12283
+ultralytics/models/sam/sam3/vitdet.py,sha256=Ni6fR3WBfp_FLvOP8MVdnRUk_1jOae16yjyox4cSJBg,22130
+ultralytics/models/sam/sam3/vl_combiner.py,sha256=l7IiBmljzotrNb3egQG4aGEp2RZIKugeQ25MJn3QBE4,6998
+ultralytics/models/utils/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6DXppv1-QUM,70
+ultralytics/models/utils/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/utils/__pycache__/loss.cpython-314.pyc,,
+ultralytics/models/utils/__pycache__/ops.cpython-314.pyc,,
+ultralytics/models/utils/loss.py,sha256=JlSDpkqrndY-VrP6GoZLg4kW3d3suiHa-yEh_FE7v68,21142
+ultralytics/models/utils/ops.py,sha256=7yEfr8ESpxUwWoBw8AU_rDj69ND58ovATZHJoRJFF3g,15203
+ultralytics/models/yolo/__init__.py,sha256=eV7Rvr7cwHILl0LYbCiqNChori_FPk_yahpNge_x_6M,329
+ultralytics/models/yolo/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/yolo/__pycache__/model.cpython-314.pyc,,
+ultralytics/models/yolo/classify/__init__.py,sha256=9--HVaNOfI1K7rn_rRqclL8FUAnpfeBrRqEQIaQw2xM,383
+ultralytics/models/yolo/classify/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/yolo/classify/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/yolo/classify/__pycache__/train.cpython-314.pyc,,
+ultralytics/models/yolo/classify/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/yolo/classify/predict.py,sha256=pRNrwGVdAuDJdm-0rSY5C7MCdjmHA75tmTk8phtPACI,4202
+ultralytics/models/yolo/classify/train.py,sha256=1PeNeMtgkQJsb_fFNB-Ll6hEVqnu8uZJJNUjpw8mW2Q,10161
+ultralytics/models/yolo/classify/val.py,sha256=PSpCXXG9sSMCffRX4rM4bFlHMvq6VWVaq3ygnnx48os,10534
+ultralytics/models/yolo/detect/__init__.py,sha256=GIRsLYR-kT4JJx7lh4ZZAFGBZj0aebokuU0A7JbjDVA,257
+ultralytics/models/yolo/detect/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/yolo/detect/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/yolo/detect/__pycache__/train.cpython-314.pyc,,
+ultralytics/models/yolo/detect/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/yolo/detect/predict.py,sha256=L01OgXeC2lbZ1oZAhHJ6lXal0nY3DMGBFDViKUGiOF0,5474
+ultralytics/models/yolo/detect/train.py,sha256=w4XGYTfd0QkHBb9sv35haasRR9onQXikp1YTu9DA00Y,12565
+ultralytics/models/yolo/detect/val.py,sha256=VQaL4b0y3cNJHP47C_UUnOtG_TAavwAm5mmSZPaWRWo,24109
+ultralytics/models/yolo/model.py,sha256=RMWkHQercvbdtqrLK3Byv8G34OqqrArXW_k3zNc1smk,19181
+ultralytics/models/yolo/obb/__init__.py,sha256=tQmpG8wVHsajWkZdmD6cjGohJ4ki64iSXQT8JY_dydo,221
+ultralytics/models/yolo/obb/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/yolo/obb/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/yolo/obb/__pycache__/train.cpython-314.pyc,,
+ultralytics/models/yolo/obb/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/yolo/obb/predict.py,sha256=VA5yRo32IVakZ_5nY75KArfaXnZbANzTkxMVGDm-co4,2634
+ultralytics/models/yolo/obb/train.py,sha256=I7mxTdoR1-BtAgMAI9jkhzm6QuTr546jeT_ere4nzyI,3437
+ultralytics/models/yolo/obb/val.py,sha256=Vchk94T5AOUXmKncCPIOlnfmDlkzgD6oglZm6BrOc58,14563
+ultralytics/models/yolo/pose/__init__.py,sha256=_9OFLj19XwvJHBRxQtVW5CV7rvJ_3hDPE97miit0sPc,227
+ultralytics/models/yolo/pose/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/yolo/pose/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/yolo/pose/__pycache__/train.cpython-314.pyc,,
+ultralytics/models/yolo/pose/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/yolo/pose/predict.py,sha256=a_D6-0qCRhTL_ccFe6UTNB1jgaB3Mp1wedLDQpeLPeM,3175
+ultralytics/models/yolo/pose/train.py,sha256=OpySjq7H_0zgGaHlMPne_0etFginGHzrfrMiyQ9rhwA,5073
+ultralytics/models/yolo/pose/val.py,sha256=cynNhSzq7PEpTAr1Tc-e7t8ed5YGaoYXn_9faVFFCcU,12111
+ultralytics/models/yolo/segment/__init__.py,sha256=3IThhZ1wlkY9FvmWm9cE-5-ZyE6F1FgzAtQ6jOOFzzw,275
+ultralytics/models/yolo/segment/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/yolo/segment/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/yolo/segment/__pycache__/train.cpython-314.pyc,,
+ultralytics/models/yolo/segment/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/yolo/segment/predict.py,sha256=L4DCWXgvMwsSs_S16xE0VBa4PpnWr4baO75ZQIm94Bw,5556
+ultralytics/models/yolo/segment/train.py,sha256=o5sz1iTc5jZqc9dq1ZEdW_-KSaVBnltppJjlYbls1Hk,3042
+ultralytics/models/yolo/segment/val.py,sha256=CANSHjE1Pz4OJIEfPBCeCqT7XibZYgA_6-1lIr0vtsk,13374
+ultralytics/models/yolo/semantic/__init__.py,sha256=yzL8Q1Ap2etFevc5YPsPv57zDFXldRM0X2vRjArFP7E,323
+ultralytics/models/yolo/semantic/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/yolo/semantic/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/yolo/semantic/__pycache__/train.cpython-314.pyc,,
+ultralytics/models/yolo/semantic/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/yolo/semantic/predict.py,sha256=froSr3vLy1B4MpSzsTw_pezKAJhHJm5BR-99KDAfAbM,4133
+ultralytics/models/yolo/semantic/train.py,sha256=Mw7U5xq-u1yq95IQCAT9guEuk-Uqub_chgwp0eqs3JU,6359
+ultralytics/models/yolo/semantic/val.py,sha256=7xDs1eraL_BYzMn9qwKpdSnRy8mKwQ0xXAky9G-rtbs,8556
+ultralytics/models/yolo/world/__init__.py,sha256=nlh8I6t8hMGz_vZg8QSlsUW1R-2eKvn9CGUoPPQEGhA,131
+ultralytics/models/yolo/world/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/yolo/world/__pycache__/train.cpython-314.pyc,,
+ultralytics/models/yolo/world/__pycache__/train_world.cpython-314.pyc,,
+ultralytics/models/yolo/world/train.py,sha256=Q9cYDLkS3V-ijwA1nGNRyhzfix_ghILv7wsZoVNP4YQ,7960
+ultralytics/models/yolo/world/train_world.py,sha256=yb0FVhOGAlhbc6-pqPPjEtFZpYdQyb4nwvfyskt8ZVE,9449
+ultralytics/models/yolo/yoloe/__init__.py,sha256=zaZo1_ommaxNv7mD7xpdSomNF4s8mpOcCVTXspg0ncY,760
+ultralytics/models/yolo/yoloe/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/models/yolo/yoloe/__pycache__/predict.cpython-314.pyc,,
+ultralytics/models/yolo/yoloe/__pycache__/train.cpython-314.pyc,,
+ultralytics/models/yolo/yoloe/__pycache__/train_seg.cpython-314.pyc,,
+ultralytics/models/yolo/yoloe/__pycache__/val.cpython-314.pyc,,
+ultralytics/models/yolo/yoloe/predict.py,sha256=LOoVkBxoUYIlZppnEVL8bJKSPoF1mhdk821ci6r74N4,7097
+ultralytics/models/yolo/yoloe/train.py,sha256=9ac3_1F6LRgCTAt6AIVcoL5kKERcjgEMpPrMgw5nDTQ,12595
+ultralytics/models/yolo/yoloe/train_seg.py,sha256=dZ3zxIOWIQ4myqrfWmQswr_r4VGtFirdMHPzHUMojg4,5097
+ultralytics/models/yolo/yoloe/val.py,sha256=VWBIeuBeK0k_U6S1t-mDHxg-t9hokqmVAERAwHccunk,9713
+ultralytics/nn/__init__.py,sha256=538LZPUKKvc3JCMgiQ4VLGqRN2ZAaVLFcQbeNNHFkEA,545
+ultralytics/nn/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/nn/__pycache__/autobackend.cpython-314.pyc,,
+ultralytics/nn/__pycache__/distill_model.cpython-314.pyc,,
+ultralytics/nn/__pycache__/tasks.cpython-314.pyc,,
+ultralytics/nn/__pycache__/text_model.cpython-314.pyc,,
+ultralytics/nn/autobackend.py,sha256=46Ziy87SJzVV5Q1YzXNDTHGKaxbEJV9YaKICLaFhrBE,15549
+ultralytics/nn/backends/__init__.py,sha256=BOZ1KMblYX5Pj0CP5piUuj30bU2ey5x_s6C22fnsTwM,1444
+ultralytics/nn/backends/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/axelera.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/base.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/coreml.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/deepx.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/executorch.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/litert.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/mnn.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/ncnn.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/onnx.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/openvino.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/paddle.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/pytorch.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/qnn.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/rknn.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/tensorflow.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/tensorrt.cpython-314.pyc,,
+ultralytics/nn/backends/__pycache__/triton.cpython-314.pyc,,
+ultralytics/nn/backends/axelera.py,sha256=ICm5vWpmG0Kj9n7u8NdSk1OMYMbnmcKSIhWZKsqoqzw,1808
+ultralytics/nn/backends/base.py,sha256=oKiRw45T5D_65bHmTQQPxVevChVZQimPLMJzMlC8hMQ,5610
+ultralytics/nn/backends/coreml.py,sha256=K6MwsadI1pWGvOn1g2A-C0nchc4Uc7RbbJ2F6elpHk8,2914
+ultralytics/nn/backends/deepx.py,sha256=M4Zfvbft2fSNLilO5Pr_nHwNf-jfNB5xlSa5_KvwCtQ,2795
+ultralytics/nn/backends/executorch.py,sha256=-Wi2Rc1iw6y-919AzcbM6OiQz4wkXAo3fUHUw2lZdXs,1867
+ultralytics/nn/backends/litert.py,sha256=7yRTtCVSpA-U5OM52FNkftLtviKwgJcljO6GinSVnUw,5472
+ultralytics/nn/backends/mnn.py,sha256=8egQJ1oiYZIe4QXXCwPuEhsiIFwX45eB_Qiy5-lU8ho,1954
+ultralytics/nn/backends/ncnn.py,sha256=9ra3OfcpGQbAqV0UO8VyGLZ3IGQVT1kx_q4_Q4ikT_o,2474
+ultralytics/nn/backends/onnx.py,sha256=DTUupgde6zNPegexEKJomRkI2KX5irDEezRSptLbIHo,8892
+ultralytics/nn/backends/openvino.py,sha256=G_DpC_roE9x2Er0lzWppipAPK94DW4IeT7D0XQE3e1Y,4330
+ultralytics/nn/backends/paddle.py,sha256=AQGdiQk9SHZl0waOm_5B5wD46mOMsB1spYxPtrg6MRY,3020
+ultralytics/nn/backends/pytorch.py,sha256=IqJQtsLXBN1oKO7N1ZiE_Qbq0LmKaW_cUVEOIuAR6q4,5512
+ultralytics/nn/backends/qnn.py,sha256=QlPu7L3VaYQGBAdN-kX1WIMe0n7_Ok48aYUi4JpRMkA,3402
+ultralytics/nn/backends/rknn.py,sha256=3rt5VxIAnX339fyieASo2WQZntoVe9L454SuKBZJ5Kw,2303
+ultralytics/nn/backends/tensorflow.py,sha256=_AuU2xXUs-vxioKvj7FUjtd74iEpVoLo4nw5IorT_7o,7670
+ultralytics/nn/backends/tensorrt.py,sha256=FKTIpxa-CkCzNsRmxuO8h9XhXKJqr9Q7O3ejLl3VutI,6128
+ultralytics/nn/backends/triton.py,sha256=tfPmifMNxSlH95BPiqASGQd-6k_9URGHYE9HTlQpYFc,1463
+ultralytics/nn/distill_model.py,sha256=iZufaosRy4RIb0qWRuYZFYeguwZBXiLuiL9J3YrK99Y,13607
+ultralytics/nn/modules/__init__.py,sha256=hwd6eMhbHFCcf3WYzZhZ5byX7fjh47v0iB5BrBaaZOY,3366
+ultralytics/nn/modules/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/nn/modules/__pycache__/activation.cpython-314.pyc,,
+ultralytics/nn/modules/__pycache__/block.cpython-314.pyc,,
+ultralytics/nn/modules/__pycache__/conv.cpython-314.pyc,,
+ultralytics/nn/modules/__pycache__/head.cpython-314.pyc,,
+ultralytics/nn/modules/__pycache__/transformer.cpython-314.pyc,,
+ultralytics/nn/modules/__pycache__/utils.cpython-314.pyc,,
+ultralytics/nn/modules/activation.py,sha256=J6n-CJKFK0YbhwcRDqm9zEJM9pSAEycj5quQss_3x6E,2219
+ultralytics/nn/modules/block.py,sha256=IO2ga-etf-pp24FhyR9mgTcapq7bHcrhjbGgBHg-HL0,74891
+ultralytics/nn/modules/conv.py,sha256=yALzbqFZbYkQ8rZR1Xh3tQpJYIV7l8u1og1Eodu6p3Q,21090
+ultralytics/nn/modules/head.py,sha256=VwERbYaIGCesnh50Yt-qRMM5N71o4jMkdjRZaFcp4G8,82857
+ultralytics/nn/modules/transformer.py,sha256=XWxpBPt3NyLrhYZj3k2GAXMdDvvac04vprpocHLGdIs,32713
+ultralytics/nn/modules/utils.py,sha256=DBtRQkH8Xc7SU5j287Ow9cJHiKXl65MMUhggY0EyYRE,5665
+ultralytics/nn/tasks.py,sha256=ZkwUIshXWgi20KTp8kbyeZ6UnHgp0WlC0PyJbp8tDiQ,85035
+ultralytics/nn/text_model.py,sha256=Dd0UszKWIJd-hECeTQv7ROzrg_uejxz7b-LbOXP9IuA,15429
+ultralytics/optim/__init__.py,sha256=Sl3Dx2eiaJd_u4VbmqcBqWWDF8FHnO5W0nBEL8_M_C4,130
+ultralytics/optim/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/optim/__pycache__/muon.cpython-314.pyc,,
+ultralytics/optim/muon.py,sha256=Iu-WCU6JFpbMuLsUwXxmmh4uIZaYlD8uKapV2ygSwe4,14241
+ultralytics/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
+ultralytics/solutions/__init__.py,sha256=Jj7OcRiYjHH-e104H4xTgjjR5W6aPB4mBRndbaSPmgU,1209
+ultralytics/solutions/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/ai_gym.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/analytics.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/config.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/distance_calculation.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/heatmap.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/instance_segmentation.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/object_blurrer.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/object_counter.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/object_cropper.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/parking_management.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/queue_management.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/region_counter.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/security_alarm.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/similarity_search.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/solutions.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/speed_estimation.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/streamlit_inference.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/trackzone.cpython-314.pyc,,
+ultralytics/solutions/__pycache__/vision_eye.cpython-314.pyc,,
+ultralytics/solutions/ai_gym.py,sha256=MuoDqkaNm8Et8L9Ze3ryH31wvlM0wsT338HEH3iwdxk,5246
+ultralytics/solutions/analytics.py,sha256=UpOwO15NVJhLzBhHLay6TCbUk8EWSUKAplQMb6KWIxI,12776
+ultralytics/solutions/config.py,sha256=S-OF0oUnRKnO85v_Naj8FjTaoMhbR7tLY03Cm5PPKY4,5857
+ultralytics/solutions/distance_calculation.py,sha256=RcpRDodEHAJUug9tobtQKt5_bySNA8NMSRiaL347Q1U,5891
+ultralytics/solutions/heatmap.py,sha256=JdAbk338nWsR7j6KT_K1ts3lAhhO5BRtc6UAJhSVSNQ,5474
+ultralytics/solutions/instance_segmentation.py,sha256=uP810WlECIRAbwgX4lXqV5l8vvLp7zvf0FG0RlaYjUE,3786
+ultralytics/solutions/object_blurrer.py,sha256=EZrv3oU68kEaahAxlhk9cF5ZKFtoVaW8bDB4Css9xe0,3981
+ultralytics/solutions/object_counter.py,sha256=omt2wsfj-E6G5wqODiQeNgaMBfecRaIHaTMJIxFDG1c,9359
+ultralytics/solutions/object_cropper.py,sha256=9NLr4egGJNPX_2wtf4nQtRo1f_wZlpv7fgJt2Xkp0j0,3551
+ultralytics/solutions/parking_management.py,sha256=Q0fEFKlv6dKKWuw_4jmWaeHQVXGppzuU7Vr_HqVYqHM,13770
+ultralytics/solutions/queue_management.py,sha256=NtrGJmxKSlu5gsQw2vmj5E9fQWgIvGDE56IQ_PfMZ_Q,4393
+ultralytics/solutions/region_counter.py,sha256=A6j9MBy8cguZabGP4jl06UQ5sOi2uxiEu6KyZprOD2k,6387
+ultralytics/solutions/security_alarm.py,sha256=c7odhqvxXOSiLVk1W1deAzDyJ5bQukS_shHayVbl8gc,6273
+ultralytics/solutions/similarity_search.py,sha256=ARkqa47WtSRgdcAeOvX64zLIWDcD3sFcec7O-u17CJ4,9907
+ultralytics/solutions/solutions.py,sha256=m8wJ1UXOu2LlxjRJyycif6Tm0Ix5xgsI2WN_LCbUGuc,37600
+ultralytics/solutions/speed_estimation.py,sha256=-DAhcWd8b4acfnbeUCSvqkUGRwL5ogkcphACQCkMV6o,5861
+ultralytics/solutions/streamlit_inference.py,sha256=MyT3xItA0ZygnHEircYWg28hS0QV2jnU3LKTHPvNAo0,13352
+ultralytics/solutions/templates/similarity-search.html,sha256=epX8XDLasOUx8ISPuKP9M0SRUjRcv_FE1r_EG3QpBtw,4177
+ultralytics/solutions/trackzone.py,sha256=An9tNETx_5DY6xy2ZI8mcrNMXRzEezjm3HRseoO7R2A,3910
+ultralytics/solutions/vision_eye.py,sha256=bSXmJ93DyLu4_CWgbF3GkHzh_VpiEmkK5vVJDPPGzI4,2982
+ultralytics/trackers/__init__.py,sha256=-1tfYXBxpb-y2rYB7H5oD2R0bxbwEfKXIRdz8dzW5JI,482
+ultralytics/trackers/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/trackers/__pycache__/basetrack.cpython-314.pyc,,
+ultralytics/trackers/__pycache__/bot_sort.cpython-314.pyc,,
+ultralytics/trackers/__pycache__/byte_tracker.cpython-314.pyc,,
+ultralytics/trackers/__pycache__/deep_oc_sort.cpython-314.pyc,,
+ultralytics/trackers/__pycache__/fast_tracker.cpython-314.pyc,,
+ultralytics/trackers/__pycache__/oc_sort.cpython-314.pyc,,
+ultralytics/trackers/__pycache__/track.cpython-314.pyc,,
+ultralytics/trackers/__pycache__/track_tracker.cpython-314.pyc,,
+ultralytics/trackers/basetrack.py,sha256=nvCUuaVP8vUskRi1vRovhLozGqVXJ39UGG3hFyjC9-g,3752
+ultralytics/trackers/bot_sort.py,sha256=mzLPzJ8LUtAfTLz3bOJ535Bun2yyoQvfkrPc33sr6dk,9914
+ultralytics/trackers/byte_tracker.py,sha256=AMfB_4sQdvyJNHBxUZrgsGowv84A3e2UgmYg4Gixko8,22774
+ultralytics/trackers/deep_oc_sort.py,sha256=71i4eEbr9CBvVHPOnngsVBJoLiIiN4stdgXv6xNlNoA,12131
+ultralytics/trackers/fast_tracker.py,sha256=p5WsgyQdu5YrjLHyNJ6pJmVOaK0cOMpsh0Of_T9XirY,17615
+ultralytics/trackers/oc_sort.py,sha256=1WPlyaNvtf8V01-SuuBJOaLxd0uq_z4oetFfuX0G9lI,15425
+ultralytics/trackers/track.py,sha256=G8hnMhWwXbC5TR4LiTDDT2JW15brP2MyBqtp0WL1k4M,5679
+ultralytics/trackers/track_tracker.py,sha256=-00hMzXO11r82mCONiK3FN_-vSxV73dv6MJhlWdJtb0,26992
+ultralytics/trackers/utils/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6DXppv1-QUM,70
+ultralytics/trackers/utils/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/trackers/utils/__pycache__/gmc.cpython-314.pyc,,
+ultralytics/trackers/utils/__pycache__/kalman_filter.cpython-314.pyc,,
+ultralytics/trackers/utils/__pycache__/matching.cpython-314.pyc,,
+ultralytics/trackers/utils/__pycache__/reid.cpython-314.pyc,,
+ultralytics/trackers/utils/__pycache__/stracks.cpython-314.pyc,,
+ultralytics/trackers/utils/gmc.py,sha256=nDqdj8Uy3mu-1u0_PswtAps8cigdsH6NpOIHT6U4sLA,13800
+ultralytics/trackers/utils/kalman_filter.py,sha256=qajNBNN9aOHp-2aQctXcl5lw0Jee20zW0KRARgQ3P64,22597
+ultralytics/trackers/utils/matching.py,sha256=DF3N3edc40PKliYnPj2V4uoGG89p8uCsDvUZrBqv_gc,7789
+ultralytics/trackers/utils/reid.py,sha256=8gqRJBvLzYanFcmteoI5v6uAk8aauneZLiWtHkqHDfw,7440
+ultralytics/trackers/utils/stracks.py,sha256=shlxdya-Qu7bXHEUKPfKUQUPitciKRpDzNmBlPWxzk4,7522
+ultralytics/utils/__init__.py,sha256=wxeotoLBMD3hpnvjxtb8BZ8v9M34g_EJJRdBS3ukUHQ,57905
+ultralytics/utils/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/utils/__pycache__/autobatch.cpython-314.pyc,,
+ultralytics/utils/__pycache__/autodevice.cpython-314.pyc,,
+ultralytics/utils/__pycache__/benchmarks.cpython-314.pyc,,
+ultralytics/utils/__pycache__/checks.cpython-314.pyc,,
+ultralytics/utils/__pycache__/cpu.cpython-314.pyc,,
+ultralytics/utils/__pycache__/dist.cpython-314.pyc,,
+ultralytics/utils/__pycache__/downloads.cpython-314.pyc,,
+ultralytics/utils/__pycache__/errors.cpython-314.pyc,,
+ultralytics/utils/__pycache__/events.cpython-314.pyc,,
+ultralytics/utils/__pycache__/files.cpython-314.pyc,,
+ultralytics/utils/__pycache__/git.cpython-314.pyc,,
+ultralytics/utils/__pycache__/instance.cpython-314.pyc,,
+ultralytics/utils/__pycache__/logger.cpython-314.pyc,,
+ultralytics/utils/__pycache__/loss.cpython-314.pyc,,
+ultralytics/utils/__pycache__/metrics.cpython-314.pyc,,
+ultralytics/utils/__pycache__/nms.cpython-314.pyc,,
+ultralytics/utils/__pycache__/ops.cpython-314.pyc,,
+ultralytics/utils/__pycache__/patches.cpython-314.pyc,,
+ultralytics/utils/__pycache__/plotting.cpython-314.pyc,,
+ultralytics/utils/__pycache__/tal.cpython-314.pyc,,
+ultralytics/utils/__pycache__/torch_utils.cpython-314.pyc,,
+ultralytics/utils/__pycache__/tqdm.cpython-314.pyc,,
+ultralytics/utils/__pycache__/triton.cpython-314.pyc,,
+ultralytics/utils/__pycache__/tuner.cpython-314.pyc,,
+ultralytics/utils/__pycache__/uploads.cpython-314.pyc,,
+ultralytics/utils/autobatch.py,sha256=nwixv8vPmIXHPq_A8nF1cxWobdduk_5nDjmJTeVu7_8,5675
+ultralytics/utils/autodevice.py,sha256=ZC-C_hfuHsyx3VcNrk85U4Rtyr0rWoSWhJlOuOkWHXQ,9006
+ultralytics/utils/benchmarks.py,sha256=o1cC5TnGTrcPsMEVhMLDHG5l1C9iY4OuuFIT_DPi-G4,28409
+ultralytics/utils/callbacks/__init__.py,sha256=hzL63Rce6VkZhP4Lcim9LKjadixaQG86nKqPhk7IkS0,242
+ultralytics/utils/callbacks/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/base.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/clearml.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/comet.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/dvc.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/hub.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/mlflow.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/neptune.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/platform.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/raytune.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/tensorboard.cpython-314.pyc,,
+ultralytics/utils/callbacks/__pycache__/wb.cpython-314.pyc,,
+ultralytics/utils/callbacks/base.py,sha256=pqpFn3mZsLa8sXBkxabjHd6S098Ngf3-qpoyES29GPo,7468
+ultralytics/utils/callbacks/clearml.py,sha256=AH7JwdZ8qtzlj11Q3MBzoUAzI6fYTb5drqAdpmxpSC8,5902
+ultralytics/utils/callbacks/comet.py,sha256=NNfwkYRYKF4lgml931aXOZsOOilAIm1uvH34dlAyWLA,25146
+ultralytics/utils/callbacks/dvc.py,sha256=DzT-Q314fap4g7rzXWeTfKw_5aTfnJIkqACAaFGXeg8,7494
+ultralytics/utils/callbacks/hub.py,sha256=tOFYxZLOO7o3cJcrJvz3Y-RqzonXZAy3yZZBVexRsyo,4249
+ultralytics/utils/callbacks/mlflow.py,sha256=5WaeD3Kfp7x3j7wJwb_kjPxs24IjLRhN3l9wVHc09-0,6744
+ultralytics/utils/callbacks/neptune.py,sha256=_vt3cMwDHCR-LyT3KtRikGpj6AG11oQ-skUUUUdZ74o,4391
+ultralytics/utils/callbacks/platform.py,sha256=PvGS7Ay8DU5yi3Lnq8wJ4rUY3aNaNI6HHigZufVR_7Q,20278
+ultralytics/utils/callbacks/raytune.py,sha256=Y0dFyNZVRuFovSh7nkgUIHTQL3xIXOACElgHuYbg_5I,1278
+ultralytics/utils/callbacks/tensorboard.py,sha256=K7b6KtC7rimfzqFu-NDZ_55Tbd7eC6TckqQdTNPuQ6U,5039
+ultralytics/utils/callbacks/wb.py,sha256=PUdXGIFCRpTB3l0ElBWiOBa855Np6362PRWZBUtvgxE,8172
+ultralytics/utils/checks.py,sha256=lLTAhhAzUXl5jnVyVgJ8LzmyI6HBSMF98LLocJ-2F-U,42574
+ultralytics/utils/cpu.py,sha256=OksKOlX93AsbSsFuoYvLXRXgpkOibrZSwQyW6lipt4Q,3493
+ultralytics/utils/dist.py,sha256=2kKQ5M6TGHFiTzYvkoAFk7EalpcJ7muZH980RqrMd4c,5003
+ultralytics/utils/downloads.py,sha256=p3F3iGI0-L74E4HHbuvfgcNYI5OGJpQgFq-_xtx4FDo,25277
+ultralytics/utils/errors.py,sha256=dUZcTWpbJJHqEuWHM6IbeoJJ4TzA_yHBP8E7tEEpBVs,1388
+ultralytics/utils/events.py,sha256=kfu8j-JKG7dNn8AHNkylUn1g4dc_gyTb40gy2SWk_lk,4911
+ultralytics/utils/export/__init__.py,sha256=zCgN-9-KWp18ouy5YsQ_7a81gKnosIerhc4S3o_2wxg,918
+ultralytics/utils/export/__pycache__/__init__.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/axelera.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/coreml.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/deepx.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/engine.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/executorch.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/imx.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/litert.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/mnn.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/ncnn.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/onnx.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/openvino.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/paddle.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/qnn.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/rknn.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/tensorflow.cpython-314.pyc,,
+ultralytics/utils/export/__pycache__/torchscript.cpython-314.pyc,,
+ultralytics/utils/export/axelera.py,sha256=TweXW60VBlzvcvilaWmqJzP5b54wZGwvRVn24v0jWYI,5545
+ultralytics/utils/export/coreml.py,sha256=BDKtWWz4Nm9c3Bi0nx8yoCaozjHgAdkkb96Z8KgfqdU,11523
+ultralytics/utils/export/deepx.py,sha256=gjvFL5Gm_dwKBjCsAQEqDSuUx25Vf9TLwxCvxtroa4o,2713
+ultralytics/utils/export/engine.py,sha256=PX2bqXJM90FuHcL2812Uogdzk0wRCme2Pgiu9m9G29o,17931
+ultralytics/utils/export/executorch.py,sha256=AcIAh0kLWLO2EN2DK2jw5lkRNyNBgbK68XMMDg1E-f4,2829
+ultralytics/utils/export/imx.py,sha256=ag2sBHgV588RUHH7UKkU1OueKPM1gafOg5N5OiEJjwQ,15243
+ultralytics/utils/export/litert.py,sha256=FrCiOJqvHvGfwikVocPKqd_m6Vij_ScJCLtjUGgE4Ns,8493
+ultralytics/utils/export/mnn.py,sha256=bc-OoP3mFBP1L4oD5b1vP9FST0kLkXRMd2FMnWgTfBs,1892
+ultralytics/utils/export/ncnn.py,sha256=ZbEIZpfe11H7oumoHKvR0WqOfjPJgw10EkIwZIX4Lv4,2457
+ultralytics/utils/export/onnx.py,sha256=XCVK9dicgpjY0n6qphq8Wzj4GsiBRbMXA7iCThJHDxM,2118
+ultralytics/utils/export/openvino.py,sha256=lPtPGa_PmA2znzUJLM1F-nWQTxY8cR271xuAkFn2mzo,2657
+ultralytics/utils/export/paddle.py,sha256=UsclTfcKSGDnDcFGbepAgJvdpvhDKnhmWshMYy34nQw,1812
+ultralytics/utils/export/qnn.py,sha256=xYcJ7T7hacJCMpUQD5d1Z1zzY64xdgBp3_PWzXcxiFk,8108
+ultralytics/utils/export/rknn.py,sha256=NIIzNchOdow84KuGBRLasndAfDLfRToMrUG3voLvn7c,3434
+ultralytics/utils/export/tensorflow.py,sha256=oejAd88q_qSPXHr5TvxUS_LA_YhuguUoe0yyfR3pDIo,12536
+ultralytics/utils/export/torchscript.py,sha256=fQ9R26g5dmkmoo8U3Xef7gSL6iN3Ow6ub78KlNEHPO8,1627
+ultralytics/utils/files.py,sha256=6Tb_-9a6PJ8HqzUH7GNhJSy05NOqrTjz1UyU_Virx6k,8194
+ultralytics/utils/git.py,sha256=pAQMO940AN7k84dose1YxxP5Q9XnQ5QwFB1QVz9t6mI,6961
+ultralytics/utils/instance.py,sha256=1J96OcekaHAzU6MmzhslQ4LIOsn2fjrvN4A1usf0VsE,19458
+ultralytics/utils/logger.py,sha256=wkB8-qOs4vaCF7BFwFgNAXDClXZWWE36BQgV4o7n-uA,25796
+ultralytics/utils/loss.py,sha256=8zHE_0O3PY7KcE28BSPPLi-O2Se8p4nMctKCucvApB8,64366
+ultralytics/utils/metrics.py,sha256=mLGJb9Nz-tnUv7W9mj-Bp9YSXIwEksUMveaNwi_e7xk,82605
+ultralytics/utils/nms.py,sha256=HqIpiuzBr1lFNm_kemp2TnyNUKPhav_Vwbucj4RuyNc,14376
+ultralytics/utils/ops.py,sha256=LXtA4hxoQ3MTcP1tZhWIgglXgpDhusx2i2Ww-yACKGs,31385
+ultralytics/utils/patches.py,sha256=aUAfRBneYVSzYozmF4bVV2HIik20vCEdOfL-cbVHlf4,9560
+ultralytics/utils/plotting.py,sha256=ppbf5uGvMoHcz4MXQFIWp1x3ri4pMF_6QjkGISa0d2c,52948
+ultralytics/utils/tal.py,sha256=dViDwOf6qlggWgMDDhEYcoKfpM5QdDi_RFtKejA1DD8,24671
+ultralytics/utils/torch_utils.py,sha256=_2tOtMqugg0dKAiUmpH1WR1rjLYA9mZYWVJ210YSrYQ,42511
+ultralytics/utils/tqdm.py,sha256=IFqrg15NUngaWJ6kXkcGWl47RhOmsvBNu1d5-TcM9Pg,16402
+ultralytics/utils/triton.py,sha256=qfA4VJvGVUjUj-uuQzHc0eZ989-iZkdMmuqo4WnotU0,5215
+ultralytics/utils/tuner.py,sha256=fHaIMz8gGwZEylSEb10sCHqVeoBCZ1BsxZtccPw19Hs,20840
+ultralytics/utils/uploads.py,sha256=wLIIdzQmJYk3yyV-JC3GP2hxuEZ_ypNZeuh59QZuc7o,3809

.venv/lib/python3.14/site-packages/ultralytics-8.4.83.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

.venv/lib/python3.14/site-packages/ultralytics-8.4.83.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+ultralytics = ultralytics.cfg:entrypoint
+yolo = ultralytics.cfg:entrypoint

.venv/lib/python3.14/site-packages/ultralytics-8.4.83.dist-info/licenses/LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

.venv/lib/python3.14/site-packages/ultralytics-8.4.83.dist-info/top_level.txt

@@ -0,0 +1 @@
+ultralytics

.venv/lib/python3.14/site-packages/ultralytics/utils/__pycache__/metrics.cpython-314.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40456bcab958ad592b9e08bba95131a6e23467fb19429af5a01d99e971c7a032
+size 125188

.venv/lib/python3.14/site-packages/ultralytics/utils/autobatch.py

@@ -0,0 +1,131 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+"""Functions for estimating the best YOLO batch size to use a fraction of the available CUDA memory in PyTorch."""
+
+from __future__ import annotations
+
+import os
+from copy import deepcopy
+
+import numpy as np
+import torch
+
+from ultralytics.utils import DEFAULT_CFG, LOGGER, colorstr
+from ultralytics.utils.torch_utils import autocast, profile_ops
+
+
+def check_train_batch_size(
+    model: torch.nn.Module,
+    imgsz: int = 640,
+    amp: bool = True,
+    batch: int | float = -1,
+    max_num_obj: int = 1,
+    dataset_size: int = 0,
+) -> int:
+    """Compute optimal YOLO training batch size using the autobatch() function.
+
+    Args:
+        model (torch.nn.Module): YOLO model to check batch size for.
+        imgsz (int, optional): Image size used for training.
+        amp (bool, optional): Use automatic mixed precision if True.
+        batch (int | float, optional): Fraction of GPU memory to use. If -1, use default.
+        max_num_obj (int, optional): The maximum number of objects from dataset.
+        dataset_size (int, optional): Total number of training images. If > 0, batch size will not exceed this value.
+
+    Returns:
+        (int): Optimal batch size computed using the autobatch() function.
+
+    Notes:
+        If 0.0 < batch < 1.0, it's used as the fraction of GPU memory to use.
+        Otherwise, a default fraction of 0.6 is used.
+    """
+    with autocast(enabled=amp):
+        return autobatch(
+            deepcopy(model).train(),
+            imgsz,
+            fraction=batch if 0.0 < batch < 1.0 else 0.6,
+            max_num_obj=max_num_obj,
+            dataset_size=dataset_size,
+        )
+
+
+def autobatch(
+    model: torch.nn.Module,
+    imgsz: int = 640,
+    fraction: float = 0.60,
+    batch_size: int = DEFAULT_CFG.batch,
+    max_num_obj: int = 1,
+    dataset_size: int = 0,
+) -> int:
+    """Automatically estimate the best YOLO batch size to use a fraction of the available CUDA memory.
+
+    Args:
+        model (torch.nn.Module): YOLO model to compute batch size for.
+        imgsz (int, optional): The image size used as input for the YOLO model.
+        fraction (float, optional): The fraction of available CUDA memory to use.
+        batch_size (int, optional): The default batch size to use if an error is detected.
+        max_num_obj (int, optional): The maximum number of objects from dataset.
+        dataset_size (int, optional): Total number of training images. If > 0, batch size will not exceed this value.
+
+    Returns:
+        (int): The optimal batch size.
+    """
+    # Check device
+    prefix = colorstr("AutoBatch: ")
+    LOGGER.info(f"{prefix}Computing optimal batch size for imgsz={imgsz} at {fraction * 100}% CUDA memory utilization.")
+    device = next(model.parameters()).device  # get model device
+    if device.type in {"cpu", "mps"}:
+        LOGGER.warning(f"{prefix}intended for CUDA devices, using default batch-size {batch_size}")
+        return batch_size
+    if torch.backends.cudnn.benchmark:
+        LOGGER.warning(f"{prefix}Requires torch.backends.cudnn.benchmark=False, using default batch-size {batch_size}")
+        return batch_size
+
+    # Inspect CUDA memory
+    gb = 1 << 30  # bytes to GiB (1024 ** 3)
+    d = f"CUDA:{os.getenv('CUDA_VISIBLE_DEVICES', '0').strip()[0]}"  # 'CUDA:0'
+    properties = torch.cuda.get_device_properties(device)  # device properties
+    t = properties.total_memory / gb  # GiB total
+    r = torch.cuda.memory_reserved(device) / gb  # GiB reserved
+    a = torch.cuda.memory_allocated(device) / gb  # GiB allocated
+    f = t - (r + a)  # GiB free
+    LOGGER.info(f"{prefix}{d} ({properties.name}) {t:.2f}G total, {r:.2f}G reserved, {a:.2f}G allocated, {f:.2f}G free")
+
+    # Profile batch sizes
+    batch_sizes = [1, 2, 4, 8, 16] if t < 16 else [1, 2, 4, 8, 16, 32, 64]
+    if dataset_size > 0:
+        batch_sizes = [b for b in batch_sizes if b <= dataset_size]
+    ch = model.yaml.get("channels", 3)
+    try:
+        img = [torch.empty(b, ch, imgsz, imgsz) for b in batch_sizes]
+        results = profile_ops(img, model, n=1, device=device, max_num_obj=max_num_obj)
+
+        # Fit a solution
+        xy = [
+            [x, y[2]]
+            for i, (x, y) in enumerate(zip(batch_sizes, results))
+            if y  # valid result
+            and isinstance(y[2], (int, float))  # is numeric
+            and 0 < y[2] < t  # between 0 and GPU limit
+            and (i == 0 or not results[i - 1] or y[2] > results[i - 1][2])  # first item or increasing memory
+        ]
+        fit_x, fit_y = zip(*xy) if xy else ([], [])
+        p = np.polyfit(fit_x, fit_y, deg=1)  # first-degree (linear) polynomial fit
+        b = int((round(f * fraction) - p[1]) / p[0])  # y intercept (optimal batch size)
+        if None in results:  # some sizes failed
+            i = results.index(None)  # first fail index
+            if b >= batch_sizes[i]:  # y intercept above failure point
+                b = batch_sizes[max(i - 1, 0)]  # select prior safe point
+        if b < 1 or b > 1024:  # b outside of safe range
+            LOGGER.warning(f"{prefix}batch={b} outside safe range, using default batch-size {batch_size}.")
+            b = batch_size
+        if dataset_size > 0:
+            b = min(b, dataset_size)
+
+        fraction = (np.polyval(p, b) + r + a) / t  # predicted fraction
+        LOGGER.info(f"{prefix}Using batch-size {b} for {d} {t * fraction:.2f}G/{t:.2f}G ({fraction * 100:.0f}%) ✅")
+        return b
+    except Exception as e:
+        LOGGER.warning(f"{prefix}error detected: {e},  using default batch-size {batch_size}.")
+        return batch_size
+    finally:
+        torch.cuda.empty_cache()

.venv/lib/python3.14/site-packages/ultralytics/utils/autodevice.py

@@ -0,0 +1,207 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+import random
+from typing import Any
+
+from ultralytics.utils import LOGGER
+
+
+class GPUInfo:
+    """Manages NVIDIA GPU information via pynvml with robust error handling.
+
+    Provides methods to query detailed GPU statistics (utilization, memory, temp, power) and select the most idle GPUs
+    based on configurable criteria. It safely handles the absence or initialization failure of the pynvml library by
+    logging warnings and disabling related features, preventing application crashes.
+
+    Includes fallback logic using `torch.cuda` for basic device counting if NVML is unavailable during GPU
+    selection. Manages NVML initialization and shutdown internally.
+
+    Attributes:
+        pynvml (module | None): The `pynvml` module if successfully imported and initialized, otherwise `None`.
+        nvml_available (bool): Indicates if `pynvml` is ready for use. True if `nvmlInit()` succeeded, False otherwise.
+        gpu_stats (list[dict[str, Any]]): A list of dictionaries, each holding stats for one GPU, populated on
+        initialization and by `refresh_stats()`. Keys include: 'index', 'name', 'utilization' (%), 'memory_used' (MiB),
+            'memory_total' (MiB), 'memory_free' (MiB), 'temperature' (C), 'power_draw' (W), 'power_limit' (W or 'N/A').
+            Empty if NVML is unavailable or queries fail.
+
+    Methods:
+        refresh_stats: Refresh the internal gpu_stats list by querying NVML.
+        print_status: Print GPU status in a compact table format using current stats.
+        select_idle_gpu: Select the most idle GPUs based on utilization and free memory.
+        shutdown: Shut down NVML if it was initialized.
+
+    Examples:
+        Initialize GPUInfo and print status
+        >>> gpu_info = GPUInfo()
+        >>> gpu_info.print_status()
+
+        Select idle GPUs with minimum memory requirements
+        >>> selected = gpu_info.select_idle_gpu(count=2, min_memory_fraction=0.2)
+        >>> print(f"Selected GPU indices: {selected}")
+    """
+
+    def __init__(self):
+        """Initialize GPUInfo, attempting to import and initialize pynvml."""
+        self.pynvml: Any | None = None
+        self.nvml_available: bool = False
+        self.gpu_stats: list[dict[str, Any]] = []
+
+        try:
+            import pynvml  # scoped as slow import
+
+            self.pynvml = pynvml
+            pynvml.nvmlInit()
+            self.nvml_available = True
+            self.refresh_stats()
+        except Exception as e:
+            LOGGER.warning(f"Failed to initialize pynvml, GPU stats disabled: {e}")
+
+    def __del__(self):
+        """Ensure NVML is shut down when the object is garbage collected."""
+        self.shutdown()
+
+    def shutdown(self):
+        """Shut down NVML if it was initialized."""
+        if self.nvml_available and self.pynvml:
+            try:
+                self.pynvml.nvmlShutdown()
+            except Exception:
+                pass
+            self.nvml_available = False
+
+    def refresh_stats(self):
+        """Refresh the internal gpu_stats list by querying NVML."""
+        self.gpu_stats = []
+        if not self.nvml_available or not self.pynvml:
+            return
+
+        try:
+            device_count = self.pynvml.nvmlDeviceGetCount()
+            self.gpu_stats.extend(self._get_device_stats(i) for i in range(device_count))
+        except Exception as e:
+            LOGGER.warning(f"Error during device query: {e}")
+            self.gpu_stats = []
+
+    def _get_device_stats(self, index: int) -> dict[str, Any]:
+        """Get stats for a single GPU device."""
+        handle = self.pynvml.nvmlDeviceGetHandleByIndex(index)
+        memory = self.pynvml.nvmlDeviceGetMemoryInfo(handle)
+        util = self.pynvml.nvmlDeviceGetUtilizationRates(handle)
+
+        def safe_get(func, *args, default=-1, divisor=1):
+            try:
+                val = func(*args)
+                return val // divisor if divisor != 1 and isinstance(val, (int, float)) else val
+            except Exception:
+                return default
+
+        temp_type = getattr(self.pynvml, "NVML_TEMPERATURE_GPU", -1)
+
+        return {
+            "index": index,
+            "name": self.pynvml.nvmlDeviceGetName(handle),
+            "utilization": util.gpu if util else -1,
+            "memory_used": memory.used >> 20 if memory else -1,  # Convert bytes to MiB
+            "memory_total": memory.total >> 20 if memory else -1,
+            "memory_free": memory.free >> 20 if memory else -1,
+            "temperature": safe_get(self.pynvml.nvmlDeviceGetTemperature, handle, temp_type),
+            "power_draw": safe_get(self.pynvml.nvmlDeviceGetPowerUsage, handle, divisor=1000),  # Convert mW to W
+            "power_limit": safe_get(self.pynvml.nvmlDeviceGetEnforcedPowerLimit, handle, divisor=1000),
+        }
+
+    def print_status(self):
+        """Print GPU status in a compact table format using current stats."""
+        self.refresh_stats()
+        if not self.gpu_stats:
+            LOGGER.warning("No GPU stats available.")
+            return
+
+        stats = self.gpu_stats
+        name_len = max(len(gpu.get("name", "N/A")) for gpu in stats)
+        hdr = f"{'Idx':<3} {'Name':<{name_len}} {'Util':>6} {'Mem (MiB)':>15} {'Temp':>5} {'Pwr (W)':>10}"
+        LOGGER.info(f"\n--- GPU Status ---\n{hdr}\n{'-' * len(hdr)}")
+
+        for gpu in stats:
+            u = f"{gpu['utilization']:>5}%" if gpu["utilization"] >= 0 else " N/A "
+            m = f"{gpu['memory_used']:>6}/{gpu['memory_total']:<6}" if gpu["memory_used"] >= 0 else " N/A / N/A "
+            t = f"{gpu['temperature']}C" if gpu["temperature"] >= 0 else " N/A "
+            p = f"{gpu['power_draw']:>3}/{gpu['power_limit']:<3}" if gpu["power_draw"] >= 0 else " N/A "
+
+            LOGGER.info(f"{gpu.get('index'):<3d} {gpu.get('name', 'N/A'):<{name_len}} {u:>6} {m:>15} {t:>5} {p:>10}")
+
+        LOGGER.info(f"{'-' * len(hdr)}\n")
+
+    def select_idle_gpu(
+        self, count: int = 1, min_memory_fraction: float = 0, min_util_fraction: float = 0
+    ) -> list[int]:
+        """Select the most idle GPUs based on utilization and free memory.
+
+        Args:
+            count (int): The number of idle GPUs to select.
+            min_memory_fraction (float): Minimum free memory required as a fraction of total memory.
+            min_util_fraction (float): Minimum free utilization rate required from 0.0 - 1.0.
+
+        Returns:
+            (list[int]): Indices of the selected GPUs, sorted by idleness (lowest utilization first).
+
+        Notes:
+             Returns fewer than 'count' if not enough qualify or exist.
+             Returns empty list if NVML stats are unavailable or no GPUs meet the criteria.
+        """
+        assert min_memory_fraction <= 1.0, f"min_memory_fraction must be <= 1.0, got {min_memory_fraction}"
+        assert min_util_fraction <= 1.0, f"min_util_fraction must be <= 1.0, got {min_util_fraction}"
+        criteria = (
+            f"free memory >= {min_memory_fraction * 100:.1f}% and free utilization >= {min_util_fraction * 100:.1f}%"
+        )
+        LOGGER.info(f"Searching for {count} idle GPUs with {criteria}...")
+
+        if count <= 0:
+            return []
+
+        self.refresh_stats()
+        if not self.gpu_stats:
+            LOGGER.warning("NVML stats unavailable.")
+            return []
+
+        # Filter and sort eligible GPUs
+        eligible_gpus = [
+            gpu
+            for gpu in self.gpu_stats
+            if gpu.get("memory_free", 0) / gpu.get("memory_total", 1) >= min_memory_fraction
+            and (100 - gpu.get("utilization", 100)) >= min_util_fraction * 100
+        ]
+        # Random tiebreaker prevents race conditions when multiple processes start simultaneously
+        # and all GPUs appear equally idle (same utilization and free memory)
+        eligible_gpus.sort(key=lambda x: (x.get("utilization", 101), -x.get("memory_free", 0), random.random()))
+
+        # Select top 'count' indices
+        selected = [gpu["index"] for gpu in eligible_gpus[:count]]
+
+        if selected:
+            if len(selected) < count:
+                LOGGER.warning(f"Requested {count} GPUs but only {len(selected)} met the idle criteria.")
+            LOGGER.info(f"Selected idle CUDA devices {selected}")
+        else:
+            LOGGER.warning(f"No GPUs met criteria ({criteria}).")
+
+        return selected
+
+
+if __name__ == "__main__":
+    required_free_mem_fraction = 0.2  # Require 20% free VRAM
+    required_free_util_fraction = 0.2  # Require 20% free utilization
+    num_gpus_to_select = 1
+
+    gpu_info = GPUInfo()
+    gpu_info.print_status()
+
+    if selected := gpu_info.select_idle_gpu(
+        count=num_gpus_to_select,
+        min_memory_fraction=required_free_mem_fraction,
+        min_util_fraction=required_free_util_fraction,
+    ):
+        print(f"\n==> Using selected GPU indices: {selected}")
+        devices = [f"cuda:{idx}" for idx in selected]
+        print(f"    Target devices: {devices}")

.venv/lib/python3.14/site-packages/ultralytics/utils/benchmarks.py

@@ -0,0 +1,618 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+"""
+Benchmark YOLO model formats for speed and accuracy.
+
+Usage:
+    from ultralytics.utils.benchmarks import ProfileModels, benchmark
+    ProfileModels(['yolo26n.yaml', 'yolov8s.yaml']).run()
+    benchmark(model='yolo26n.pt', imgsz=160)
+
+Format                  | `format=argument`         | Model
+---                     | ---                       | ---
+PyTorch                 | -                         | yolo26n.pt
+TorchScript             | `torchscript`             | yolo26n.torchscript
+ONNX                    | `onnx`                    | yolo26n.onnx
+OpenVINO                | `openvino`                | yolo26n_openvino_model/
+TensorRT                | `engine`                  | yolo26n.engine
+CoreML                  | `coreml`                  | yolo26n.mlpackage
+TensorFlow SavedModel   | `saved_model`             | yolo26n_saved_model/
+TensorFlow GraphDef     | `pb`                      | yolo26n.pb
+TensorFlow Edge TPU     | `edgetpu`                 | yolo26n_edgetpu.tflite
+PaddlePaddle            | `paddle`                  | yolo26n_paddle_model/
+MNN                     | `mnn`                     | yolo26n.mnn
+NCNN                    | `ncnn`                    | yolo26n_ncnn_model/
+IMX                     | `imx`                     | yolo26n_imx_model/
+RKNN                    | `rknn`                    | yolo26n_rknn_model/
+ExecuTorch              | `executorch`              | yolo26n_executorch_model/
+Axelera AI              | `axelera`                 | yolo26n_axelera_model/
+"""
+
+from __future__ import annotations
+
+import glob
+import platform
+import shutil
+import time
+from copy import deepcopy
+from pathlib import Path
+
+import numpy as np
+import torch.cuda
+
+from ultralytics import YOLO, YOLOWorld
+from ultralytics.cfg import TASK2DATA, TASK2METRIC
+from ultralytics.engine.exporter import export_formats
+from ultralytics.nn.modules import Segment26
+from ultralytics.utils import (
+    ARM64,
+    ASSETS,
+    IS_DOCKER,
+    IS_JETSON,
+    LINUX,
+    LOGGER,
+    MACOS,
+    TQDM,
+    WEIGHTS_DIR,
+    is_github_action_running,
+)
+from ultralytics.utils.checks import IS_PYTHON_MINIMUM_3_13, check_imgsz, check_requirements, check_yolo, is_rockchip
+from ultralytics.utils.files import file_size
+from ultralytics.utils.torch_utils import get_cpu_info, select_device
+
+
+def benchmark(
+    model=WEIGHTS_DIR / "yolo26n.pt",
+    data=None,
+    imgsz=160,
+    quantize=None,
+    device="cpu",
+    verbose=False,
+    eps=1e-3,
+    format="",
+    **kwargs,
+):
+    """Benchmark a YOLO model across different formats for speed and accuracy.
+
+    Args:
+        model (str | Path): Path to the model file or directory.
+        data (str | None): Dataset to evaluate on, inherited from TASK2DATA if not passed.
+        imgsz (int): Image size for the benchmark.
+        quantize (int | str | None): Precision for export and inference: 16 (FP16), 8 (INT8), or None/32 (FP32).
+        device (str): Device to run the benchmark on, either 'cpu' or 'cuda'.
+        verbose (bool | float): If True or a float, assert benchmarks pass with given metric.
+        eps (float): Epsilon value for divide by zero prevention.
+        format (str): Export format for benchmarking. If not supplied all formats are benchmarked.
+        **kwargs (Any): Additional keyword arguments for exporter.
+
+    Returns:
+        (polars.DataFrame): A Polars DataFrame with benchmark results for each format, including file size, metric, and
+            inference time.
+
+    Examples:
+        Benchmark a YOLO model with default settings:
+        >>> from ultralytics.utils.benchmarks import benchmark
+        >>> benchmark(model="yolo26n.pt", imgsz=640)
+    """
+    imgsz = check_imgsz(imgsz)
+    assert imgsz[0] == imgsz[1] if isinstance(imgsz, list) else True, "benchmark() only supports square imgsz."
+
+    import polars as pl  # scope for faster 'import ultralytics'
+
+    pl.Config.set_tbl_cols(-1)  # Show all columns
+    pl.Config.set_tbl_rows(-1)  # Show all rows
+    pl.Config.set_tbl_width_chars(-1)  # No width limit
+    pl.Config.set_tbl_hide_column_data_types(True)  # Hide data types
+    pl.Config.set_tbl_hide_dataframe_shape(True)  # Hide shape info
+    pl.Config.set_tbl_formatting("ASCII_BORDERS_ONLY_CONDENSED")
+
+    device = select_device(device, verbose=False)
+    if isinstance(model, (str, Path)):
+        model = YOLO(model)
+    data = data or TASK2DATA[model.task]  # task to dataset, i.e. coco8.yaml for task=detect
+    key = TASK2METRIC[model.task]  # task to metric, i.e. metrics/mAP50-95(B) for task=detect
+
+    y = []
+    t0 = time.time()
+
+    format_arg = format.lower()
+    if format_arg:
+        formats = frozenset(export_formats()["Argument"])
+        assert format in formats, f"Expected format to be one of {formats}, but got '{format_arg}'."
+    for name, format, suffix, cpu, gpu, valid_args, _ in zip(*export_formats().values()):
+        emoji, filename = "❌", None  # export defaults
+        try:
+            if format_arg and format_arg != format:
+                continue
+            if IS_PYTHON_MINIMUM_3_13 and not format_arg and format in {"saved_model", "pb", "edgetpu"}:
+                continue
+
+            # Checks
+            if format == "pb":
+                assert model.task != "obb", "TensorFlow GraphDef not supported for OBB task"
+            elif format == "edgetpu":
+                assert LINUX and not ARM64, "Edge TPU export only supported on non-aarch64 Linux"
+                assert shutil.which("edgetpu_compiler"), "Edge TPU benchmark requires edgetpu_compiler"
+            elif format == "coreml":
+                assert MACOS or (LINUX and not ARM64), "CoreML export only supported on macOS and non-aarch64 Linux"
+                # coremltools deadlocks after OpenVINO on macOS Python 3.13 (conflicting OpenMP runtimes); CoreML
+                # is still benchmarked on non-aarch64 Linux Python 3.13.
+                assert not (MACOS and IS_PYTHON_MINIMUM_3_13), (
+                    "CoreML not benchmarked on macOS Python>=3.13 (coremltools/OpenVINO OpenMP deadlock)"
+                )
+            if format in {"saved_model", "pb", "edgetpu"}:
+                assert not isinstance(model, YOLOWorld), "YOLOWorldv2 TensorFlow exports not supported by onnx2tf yet"
+            if format == "paddle":
+                assert not isinstance(model, YOLOWorld), "YOLOWorldv2 Paddle exports not supported yet"
+                assert model.task != "obb", "Paddle OBB bug https://github.com/PaddlePaddle/Paddle/issues/72024"
+                assert (LINUX and not IS_JETSON) or MACOS, "Windows and Jetson Paddle exports not supported yet"
+                # PaddlePaddle export works standalone on Python 3.13 but its native protobuf clashes with the
+                # protobuf>=6.31.1 that TensorFlow loads earlier in this shared benchmark process, causing a segfault.
+                assert not IS_PYTHON_MINIMUM_3_13, (
+                    "PaddlePaddle not benchmarked on Python>=3.13 (protobuf ABI conflict with TensorFlow)"
+                )
+            if format == "mnn":
+                assert not isinstance(model, YOLOWorld), "YOLOWorldv2 MNN exports not supported yet"
+                # MNN export works standalone on Python 3.13 but its ONNX-parsing protobuf clashes with the
+                # protobuf>=6.31.1 that TensorFlow loads earlier in this shared benchmark process, aborting the run.
+                assert not IS_PYTHON_MINIMUM_3_13, (
+                    "MNN not benchmarked on Python>=3.13 (protobuf ABI conflict with TensorFlow)"
+                )
+            if format == "ncnn":
+                assert not isinstance(model, YOLOWorld), "YOLOWorldv2 NCNN exports not supported yet"
+            if format == "imx":
+                assert not isinstance(model, YOLOWorld), "YOLOWorldv2 IMX exports not supported"
+                assert model.task in {"detect", "classify", "pose", "segment"}, (
+                    "IMX export is only supported for detection, classification, pose estimation and segmentation tasks"
+                )
+                assert "C2f" in model.__str__(), "IMX only supported for YOLOv8n and YOLO11n"
+            if format == "rknn":
+                assert not isinstance(model, YOLOWorld), "YOLOWorldv2 RKNN exports not supported yet"
+                assert LINUX, "RKNN only supported on Linux"
+                assert not is_rockchip(), "RKNN Inference only supported on Rockchip devices"
+            if format == "executorch":
+                assert not isinstance(model, YOLOWorld), "YOLOWorldv2 ExecuTorch exports not supported yet"
+            if format == "axelera":
+                assert not isinstance(model, YOLOWorld), "YOLOWorldv2 Axelera exports not supported"
+                assert LINUX and not (ARM64 and IS_DOCKER), (
+                    "export is only supported on Linux and is not supported on ARM64 Docker."
+                )
+                assert not (model.task == "segment" and any(isinstance(m, Segment26) for m in model.model.modules())), (
+                    "Axelera export does not currently support YOLO26 segmentation models"
+                )
+            if format == "litert":
+                assert MACOS or (LINUX and not ARM64), "LiteRT benchmark only supported on Linux x86 and macOS"
+                # benchmark() deadlocks on the ai-edge-litert/TensorFlow abseil mutex (RAW: Lock blocking) on macOS CI
+                # when litert runs after other TF-based formats in the shared process; still benchmarked locally.
+                assert not (MACOS and is_github_action_running()), (
+                    "LiteRT not benchmarked on macOS CI (ai-edge-litert/TF abseil mutex deadlock)"
+                )
+            if "cpu" in device.type:
+                assert cpu, "inference not supported on CPU"
+            if "cuda" in device.type:
+                assert gpu, "inference not supported on GPU"
+
+            # Export
+            if format == "-":
+                filename = model.pt_path or model.ckpt_path or model.model_name
+                exported_model = deepcopy(model)  # PyTorch format
+            else:
+                export_data = data if "data" in valid_args else None
+                filename = deepcopy(model).export(
+                    imgsz=imgsz,
+                    format=format,
+                    quantize=quantize,
+                    data=export_data,
+                    device=device,
+                    verbose=False,
+                    **kwargs,
+                )
+                exported_model = YOLO(filename, task=model.task)
+                assert suffix in str(filename), "export failed"
+            emoji = "❎"  # indicates export succeeded
+
+            # Predict
+            assert model.task != "pose" or format != "pb", "GraphDef Pose inference is not supported"
+            assert format != "edgetpu", "inference not supported"
+            assert format != "coreml" or platform.system() == "Darwin", "inference only supported on macOS>=10.13"
+            assert format != "axelera", "inference only supported on Axelera hardware"
+            exported_model.predict(ASSETS / "bus.jpg", imgsz=imgsz, device=device, quantize=quantize, verbose=False)
+
+            # Validate
+            results = exported_model.val(
+                data=data,
+                batch=1,
+                imgsz=imgsz,
+                plots=False,
+                device=device,
+                quantize=quantize,
+                verbose=False,
+                conf=0.001,  # all the pre-set benchmark mAP values are based on conf=0.001
+            )
+            metric, speed = results.results_dict[key], results.speed["inference"]
+            fps = round(1000 / (speed + eps), 2)  # frames per second
+            y.append([name, "✅", round(file_size(filename), 1), round(metric, 4), round(speed, 2), fps])
+        except Exception as e:
+            if verbose:
+                assert type(e) is AssertionError, f"Benchmark failure for {name}: {e}"
+            LOGGER.error(f"Benchmark failure for {name}: {e}")
+            y.append([name, emoji, round(file_size(filename), 1), None, None, None])  # mAP, t_inference
+
+    # Print results
+    check_yolo(device=device)  # print system info
+    df = pl.DataFrame(y, schema=["Format", "Status❔", "Size (MB)", key, "Inference time (ms/im)", "FPS"], orient="row")
+    df = df.with_row_index(" ", offset=1)  # add index info
+    df_display = df.with_columns(pl.all().cast(pl.String).fill_null("-"))
+
+    name = model.model_name
+    dt = time.time() - t0
+    legend = "Benchmarks legend:  - ✅ Success  - ❎ Export passed but validation failed  - ❌️ Export failed"
+    s = f"\nBenchmarks complete for {name} on {data} at imgsz={imgsz} ({dt:.2f}s)\n{legend}\n{df_display}\n"
+    LOGGER.info(s)
+    with open("benchmarks.log", "a", errors="ignore", encoding="utf-8") as f:
+        f.write(s)
+
+    if verbose and isinstance(verbose, float):
+        metrics = df[key].to_numpy()  # values to compare to floor
+        floor = verbose  # minimum metric floor to pass, i.e. = 0.29 mAP for YOLOv5n
+        assert all(x > floor for x in metrics if not np.isnan(x)), f"Benchmark failure: metric(s) < floor {floor}"
+
+    return df_display
+
+
+class ProfileModels:
+    """ProfileModels class for profiling different models on ONNX and TensorRT.
+
+    This class profiles the performance of different models, returning results such as model speed and FLOPs.
+
+    Attributes:
+        paths (list[str]): Paths of the models to profile.
+        num_timed_runs (int): Number of timed runs for the profiling.
+        num_warmup_runs (int): Number of warmup runs before profiling.
+        min_time (float): Minimum number of seconds to profile for.
+        imgsz (int): Image size used in the models.
+        quantize (int | str | None): Export precision for TensorRT profiling, e.g. 16 (FP16) or 8 (INT8).
+        trt (bool): Flag to indicate whether to profile using TensorRT.
+        device (torch.device): Device used for profiling.
+
+    Methods:
+        run: Profile YOLO models for speed and accuracy across various formats.
+        get_files: Get all relevant model files.
+        get_onnx_model_info: Extract metadata from an ONNX model.
+        iterative_sigma_clipping: Apply sigma clipping to remove outliers.
+        profile_tensorrt_model: Profile a TensorRT model.
+        profile_onnx_model: Profile an ONNX model.
+        generate_table_row: Generate a table row with model metrics.
+        generate_results_dict: Generate a dictionary of profiling results.
+        print_table: Print a formatted table of results.
+
+    Examples:
+        Profile models and print results
+        >>> from ultralytics.utils.benchmarks import ProfileModels
+        >>> profiler = ProfileModels(["yolo26n.yaml", "yolov8s.yaml"], imgsz=640)
+        >>> profiler.run()
+    """
+
+    def __init__(
+        self,
+        paths: list[str],
+        num_timed_runs: int = 100,
+        num_warmup_runs: int = 10,
+        min_time: float = 60,
+        imgsz: int = 640,
+        quantize: int | str | None = 16,
+        trt: bool = True,
+        device: torch.device | str | None = None,
+    ):
+        """Initialize the ProfileModels class for profiling models.
+
+        Args:
+            paths (list[str]): List of paths of the models to be profiled.
+            num_timed_runs (int): Number of timed runs for the profiling.
+            num_warmup_runs (int): Number of warmup runs before the actual profiling starts.
+            min_time (float): Minimum time in seconds for profiling a model.
+            imgsz (int): Size of the image used during profiling.
+            quantize (int | str | None): Export precision for TensorRT profiling, e.g. 16 (FP16, default) or 8 (INT8).
+            trt (bool): Flag to indicate whether to profile using TensorRT.
+            device (torch.device | str | None): Device used for profiling. If None, it is determined automatically.
+
+        Notes:
+            quantize applies only to the TensorRT profiling export; ONNX profiling stays FP32 (FP16 is slower on CPU).
+        """
+        self.paths = paths
+        self.num_timed_runs = num_timed_runs
+        self.num_warmup_runs = num_warmup_runs
+        self.min_time = min_time
+        self.imgsz = imgsz
+        self.quantize = quantize
+        self.trt = trt  # run TensorRT profiling
+        self.device = device if isinstance(device, torch.device) else select_device(device)
+
+    def run(self):
+        """Profile YOLO models for speed and accuracy across various formats including ONNX and TensorRT.
+
+        Returns:
+            (list[dict]): List of dictionaries containing profiling results for each model.
+
+        Examples:
+            Profile models and print results
+            >>> from ultralytics.utils.benchmarks import ProfileModels
+            >>> profiler = ProfileModels(["yolo26n.yaml", "yolo11s.yaml"])
+            >>> results = profiler.run()
+        """
+        files = self.get_files()
+
+        if not files:
+            LOGGER.warning("No matching *.pt or *.onnx files found.")
+            return []
+
+        table_rows = []
+        output = []
+        for file in files:
+            engine_file = file.with_suffix(".engine")
+            if file.suffix in {".pt", ".yaml", ".yml"}:
+                model = YOLO(str(file))
+                model.fuse()  # to report correct params and GFLOPs in model.info()
+                model_info = model.info(imgsz=self.imgsz)
+                if self.trt and self.device.type != "cpu" and not engine_file.is_file():
+                    engine_file = model.export(
+                        format="engine",
+                        quantize=self.quantize,
+                        imgsz=self.imgsz,
+                        device=self.device,
+                        verbose=False,
+                    )
+                onnx_file = model.export(
+                    format="onnx",
+                    imgsz=self.imgsz,
+                    device=self.device,
+                    verbose=False,
+                )
+            elif file.suffix == ".onnx":
+                model_info = self.get_onnx_model_info(file)
+                onnx_file = file
+            else:
+                continue
+
+            t_engine = self.profile_tensorrt_model(str(engine_file))
+            t_onnx = self.profile_onnx_model(str(onnx_file))
+            table_rows.append(self.generate_table_row(file.stem, t_onnx, t_engine, model_info))
+            output.append(self.generate_results_dict(file.stem, t_onnx, t_engine, model_info))
+
+        self.print_table(table_rows)
+        return output
+
+    def get_files(self):
+        """Return a list of paths for all relevant model files given by the user.
+
+        Returns:
+            (list[Path]): List of Path objects for the model files.
+        """
+        files = []
+        for path in self.paths:
+            path = Path(path)
+            if path.is_dir():
+                extensions = ["*.pt", "*.onnx", "*.yaml"]
+                files.extend([file for ext in extensions for file in glob.glob(str(path / ext))])
+            elif path.suffix in {".pt", ".yaml", ".yml"}:  # add non-existing
+                files.append(str(path))
+            else:
+                files.extend(glob.glob(str(path)))
+
+        LOGGER.info(f"Profiling: {sorted(files)}")
+        return [Path(file) for file in sorted(files)]
+
+    @staticmethod
+    def get_onnx_model_info(onnx_file: str):
+        """Extract metadata from an ONNX model file including layers, parameters, gradients, and FLOPs."""
+        return 0.0, 0.0, 0.0, 0.0  # return (num_layers, num_params, num_gradients, num_flops)
+
+    @staticmethod
+    def iterative_sigma_clipping(data: np.ndarray, sigma: float = 2, max_iters: int = 3):
+        """Apply iterative sigma clipping to data to remove outliers.
+
+        Args:
+            data (np.ndarray): Input data array.
+            sigma (float): Number of standard deviations to use for clipping.
+            max_iters (int): Maximum number of iterations for the clipping process.
+
+        Returns:
+            (np.ndarray): Clipped data array with outliers removed.
+        """
+        data = np.array(data)
+        for _ in range(max_iters):
+            mean, std = np.mean(data), np.std(data)
+            clipped_data = data[(data > mean - sigma * std) & (data < mean + sigma * std)]
+            if len(clipped_data) == len(data):
+                break
+            data = clipped_data
+        return data
+
+    def profile_tensorrt_model(self, engine_file: str, eps: float = 1e-3):
+        """Profile YOLO model performance with TensorRT, measuring average run time and standard deviation.
+
+        Args:
+            engine_file (str): Path to the TensorRT engine file.
+            eps (float): Small epsilon value to prevent division by zero.
+
+        Returns:
+            (tuple[float, float]): Mean and standard deviation of inference time in milliseconds.
+        """
+        if not self.trt or not Path(engine_file).is_file():
+            return 0.0, 0.0
+
+        # Model and input
+        model = YOLO(engine_file)
+        input_data = np.zeros((self.imgsz, self.imgsz, 3), dtype=np.uint8)  # use uint8 for Classify
+
+        # Warmup runs
+        elapsed = 0.0
+        for _ in range(3):
+            start_time = time.time()
+            for _ in range(self.num_warmup_runs):
+                model(input_data, imgsz=self.imgsz, verbose=False)
+            elapsed = time.time() - start_time
+
+        # Compute number of runs as higher of min_time or num_timed_runs
+        num_runs = max(round(self.min_time / (elapsed + eps) * self.num_warmup_runs), self.num_timed_runs * 50)
+
+        # Timed runs
+        run_times = []
+        for _ in TQDM(range(num_runs), desc=engine_file):
+            results = model(input_data, imgsz=self.imgsz, verbose=False)
+            run_times.append(results[0].speed["inference"])  # Convert to milliseconds
+
+        run_times = self.iterative_sigma_clipping(np.array(run_times), sigma=2, max_iters=3)  # sigma clipping
+        return np.mean(run_times), np.std(run_times)
+
+    @staticmethod
+    def check_dynamic(tensor_shape):
+        """Check whether the tensor shape in the ONNX model is dynamic."""
+        return not all(isinstance(dim, int) and dim >= 0 for dim in tensor_shape)
+
+    def profile_onnx_model(self, onnx_file: str, eps: float = 1e-3):
+        """Profile an ONNX model, measuring average inference time and standard deviation across multiple runs.
+
+        Args:
+            onnx_file (str): Path to the ONNX model file.
+            eps (float): Small epsilon value to prevent division by zero.
+
+        Returns:
+            (tuple[float, float]): Mean and standard deviation of inference time in milliseconds.
+        """
+        check_requirements([("onnxruntime", "onnxruntime-gpu")])  # either package meets requirements
+        import onnxruntime as ort
+
+        # Session with either 'TensorrtExecutionProvider', 'CUDAExecutionProvider', 'CPUExecutionProvider'
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        sess_options.intra_op_num_threads = 8  # Limit the number of threads
+        sess = ort.InferenceSession(onnx_file, sess_options, providers=["CPUExecutionProvider"])
+
+        input_data_dict = {}
+        for input_tensor in sess.get_inputs():
+            input_type = input_tensor.type
+            if self.check_dynamic(input_tensor.shape):
+                if len(input_tensor.shape) != 4 and self.check_dynamic(input_tensor.shape[1:]):
+                    raise ValueError(f"Unsupported dynamic shape {input_tensor.shape} of {input_tensor.name}")
+                input_shape = (
+                    (1, 3, self.imgsz, self.imgsz) if len(input_tensor.shape) == 4 else (1, *input_tensor.shape[1:])
+                )
+            else:
+                input_shape = input_tensor.shape
+
+            # Mapping ONNX datatype to numpy datatype
+            if "float16" in input_type:
+                input_dtype = np.float16
+            elif "float" in input_type:
+                input_dtype = np.float32
+            elif "double" in input_type:
+                input_dtype = np.float64
+            elif "int64" in input_type:
+                input_dtype = np.int64
+            elif "int32" in input_type:
+                input_dtype = np.int32
+            else:
+                raise ValueError(f"Unsupported ONNX datatype {input_type}")
+
+            input_data = np.random.rand(*input_shape).astype(input_dtype)
+            input_name = input_tensor.name
+            input_data_dict[input_name] = input_data
+
+        output_name = sess.get_outputs()[0].name
+
+        # Warmup runs
+        elapsed = 0.0
+        for _ in range(3):
+            start_time = time.time()
+            for _ in range(self.num_warmup_runs):
+                sess.run([output_name], input_data_dict)
+            elapsed = time.time() - start_time
+
+        # Compute number of runs as higher of min_time or num_timed_runs
+        num_runs = max(round(self.min_time / (elapsed + eps) * self.num_warmup_runs), self.num_timed_runs)
+
+        # Timed runs
+        run_times = []
+        for _ in TQDM(range(num_runs), desc=onnx_file):
+            start_time = time.time()
+            sess.run([output_name], input_data_dict)
+            run_times.append((time.time() - start_time) * 1000)  # Convert to milliseconds
+
+        run_times = self.iterative_sigma_clipping(np.array(run_times), sigma=2, max_iters=5)  # sigma clipping
+        return np.mean(run_times), np.std(run_times)
+
+    def generate_table_row(
+        self,
+        model_name: str,
+        t_onnx: tuple[float, float],
+        t_engine: tuple[float, float],
+        model_info: tuple[float, float, float, float],
+    ):
+        """Generate a table row string with model performance metrics.
+
+        Args:
+            model_name (str): Name of the model.
+            t_onnx (tuple): ONNX model inference time statistics (mean, std).
+            t_engine (tuple): TensorRT engine inference time statistics (mean, std).
+            model_info (tuple): Model information (layers, params, gradients, flops).
+
+        Returns:
+            (str): Formatted table row string with model metrics.
+        """
+        _layers, params, _gradients, flops = model_info
+        return (
+            f"| {model_name:18s} | {self.imgsz} | - | {t_onnx[0]:.1f}±{t_onnx[1]:.1f} ms | {t_engine[0]:.1f}±"
+            f"{t_engine[1]:.1f} ms | {params / 1e6:.1f} | {flops:.1f} |"
+        )
+
+    @staticmethod
+    def generate_results_dict(
+        model_name: str,
+        t_onnx: tuple[float, float],
+        t_engine: tuple[float, float],
+        model_info: tuple[float, float, float, float],
+    ):
+        """Generate a dictionary of profiling results.
+
+        Args:
+            model_name (str): Name of the model.
+            t_onnx (tuple): ONNX model inference time statistics (mean, std).
+            t_engine (tuple): TensorRT engine inference time statistics (mean, std).
+            model_info (tuple): Model information (layers, params, gradients, flops).
+
+        Returns:
+            (dict): Dictionary containing profiling results.
+        """
+        _layers, params, _gradients, flops = model_info
+        return {
+            "model/name": model_name,
+            "model/parameters": params,
+            "model/GFLOPs": round(flops, 3),
+            "model/speed_ONNX(ms)": round(t_onnx[0], 3),
+            "model/speed_TensorRT(ms)": round(t_engine[0], 3),
+        }
+
+    @staticmethod
+    def print_table(table_rows: list[str]):
+        """Print a formatted table of model profiling results.
+
+        Args:
+            table_rows (list[str]): List of formatted table row strings.
+        """
+        gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "GPU"
+        headers = [
+            "Model",
+            "size<br><sup>(pixels)",
+            "mAP<sup>val<br>50-95",
+            f"Speed<br><sup>CPU ({get_cpu_info()}) ONNX<br>(ms)",
+            f"Speed<br><sup>{gpu} TensorRT<br>(ms)",
+            "params<br><sup>(M)",
+            "FLOPs<br><sup>(B)",
+        ]
+        header = "|" + "|".join(f" {h} " for h in headers) + "|"
+        separator = "|" + "|".join("-" * (len(h) + 2) for h in headers) + "|"
+
+        LOGGER.info(f"\n\n{header}")
+        LOGGER.info(separator)
+        for row in table_rows:
+            LOGGER.info(row)

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/__init__.py

@@ -0,0 +1,5 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from .base import add_integration_callbacks, default_callbacks, get_default_callbacks
+
+__all__ = "add_integration_callbacks", "default_callbacks", "get_default_callbacks"

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/base.py

@@ -0,0 +1,235 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+"""Base callbacks for Ultralytics training, validation, prediction, and export processes."""
+
+from collections import defaultdict
+from copy import deepcopy
+
+# Trainer callbacks ----------------------------------------------------------------------------------------------------
+
+
+def on_pretrain_routine_start(trainer):
+    """Called at the beginning of the pre-training routine, before data loading and model setup."""
+    pass
+
+
+def on_pretrain_routine_end(trainer):
+    """Called at the end of the pre-training routine, after data loading and model setup are complete."""
+    pass
+
+
+def on_train_start(trainer):
+    """Called when the training starts, before the first epoch begins."""
+    pass
+
+
+def on_train_epoch_start(trainer):
+    """Called at the start of each training epoch, before batch iteration begins."""
+    pass
+
+
+def on_train_batch_start(trainer):
+    """Called at the start of each training batch, before the forward pass."""
+    pass
+
+
+def optimizer_step(trainer):
+    """Called during the optimizer step. Reserved for custom integrations; not called by default."""
+    pass
+
+
+def on_before_zero_grad(trainer):
+    """Called before the gradients are set to zero. Reserved for custom integrations; not called by default."""
+    pass
+
+
+def on_train_batch_end(trainer):
+    """Called at the end of each training batch, after the backward pass. Optimizer step may be deferred by
+    accumulation.
+    """
+    pass
+
+
+def on_train_epoch_end(trainer):
+    """Called at the end of each training epoch, after all batches but before validation."""
+    pass
+
+
+def on_fit_epoch_end(trainer):
+    """Called at the end of each fit epoch (train + val), after validation and any checkpoint save."""
+    pass
+
+
+def on_model_save(trainer):
+    """Called when the model checkpoint is saved, after validation."""
+    pass
+
+
+def on_train_end(trainer):
+    """Called when the training ends, after final evaluation of the best model."""
+    pass
+
+
+def on_params_update(trainer):
+    """Called when the model parameters are updated. Reserved for custom integrations; not called by default."""
+    pass
+
+
+def teardown(trainer):
+    """Called during the teardown of the training process."""
+    pass
+
+
+# Validator callbacks --------------------------------------------------------------------------------------------------
+
+
+def on_val_start(validator):
+    """Called when the validation starts."""
+    pass
+
+
+def on_val_batch_start(validator):
+    """Called at the start of each validation batch."""
+    pass
+
+
+def on_val_batch_end(validator):
+    """Called at the end of each validation batch."""
+    pass
+
+
+def on_val_end(validator):
+    """Called when the validation ends."""
+    pass
+
+
+# Predictor callbacks --------------------------------------------------------------------------------------------------
+
+
+def on_predict_start(predictor):
+    """Called when the prediction starts."""
+    pass
+
+
+def on_predict_batch_start(predictor):
+    """Called at the start of each prediction batch."""
+    pass
+
+
+def on_predict_batch_end(predictor):
+    """Called at the end of each prediction batch."""
+    pass
+
+
+def on_predict_postprocess_end(predictor):
+    """Called after the post-processing of the prediction ends."""
+    pass
+
+
+def on_predict_end(predictor):
+    """Called when the prediction ends."""
+    pass
+
+
+# Exporter callbacks ---------------------------------------------------------------------------------------------------
+
+
+def on_export_start(exporter):
+    """Called when the model export starts."""
+    pass
+
+
+def on_export_end(exporter):
+    """Called when the model export ends."""
+    pass
+
+
+default_callbacks = {
+    # Run in trainer
+    "on_pretrain_routine_start": [on_pretrain_routine_start],
+    "on_pretrain_routine_end": [on_pretrain_routine_end],
+    "on_train_start": [on_train_start],
+    "on_train_epoch_start": [on_train_epoch_start],
+    "on_train_batch_start": [on_train_batch_start],
+    "optimizer_step": [optimizer_step],
+    "on_before_zero_grad": [on_before_zero_grad],
+    "on_train_batch_end": [on_train_batch_end],
+    "on_train_epoch_end": [on_train_epoch_end],
+    "on_fit_epoch_end": [on_fit_epoch_end],  # fit = train + val
+    "on_model_save": [on_model_save],
+    "on_train_end": [on_train_end],
+    "on_params_update": [on_params_update],
+    "teardown": [teardown],
+    # Run in validator
+    "on_val_start": [on_val_start],
+    "on_val_batch_start": [on_val_batch_start],
+    "on_val_batch_end": [on_val_batch_end],
+    "on_val_end": [on_val_end],
+    # Run in predictor
+    "on_predict_start": [on_predict_start],
+    "on_predict_batch_start": [on_predict_batch_start],
+    "on_predict_postprocess_end": [on_predict_postprocess_end],
+    "on_predict_batch_end": [on_predict_batch_end],
+    "on_predict_end": [on_predict_end],
+    # Run in exporter
+    "on_export_start": [on_export_start],
+    "on_export_end": [on_export_end],
+}
+
+
+def get_default_callbacks():
+    """Get the default callbacks for Ultralytics training, validation, prediction, and export processes.
+
+    Returns:
+        (dict): Dictionary of default callbacks for various training events. Each key represents an event during the
+            training process, and the corresponding value is a list of callback functions executed when that
+            event occurs.
+
+    Examples:
+        >>> callbacks = get_default_callbacks()
+        >>> print(list(callbacks.keys()))  # show all available callback events
+        ['on_pretrain_routine_start', 'on_pretrain_routine_end', ...]
+    """
+    return defaultdict(list, deepcopy(default_callbacks))
+
+
+def add_integration_callbacks(instance):
+    """Add integration callbacks to the instance's callbacks dictionary.
+
+    This function loads and adds various integration callbacks to the provided instance. The specific callbacks added
+    depend on the type of instance provided. All instances receive HUB callbacks, while Trainer instances also receive
+    additional callbacks for various integrations like ClearML, Comet, DVC, MLflow, Neptune, Ray Tune, TensorBoard, and
+    Weights & Biases.
+
+    Args:
+        instance (Trainer | Predictor | Validator | Exporter): The object instance to which callbacks will be added. The
+            type of instance determines which callbacks are loaded.
+
+    Examples:
+        >>> from ultralytics.engine.trainer import BaseTrainer
+        >>> trainer = BaseTrainer()
+        >>> add_integration_callbacks(trainer)
+    """
+    from .hub import callbacks as hub_cb
+    from .platform import callbacks as platform_cb
+
+    # Load Ultralytics callbacks
+    callbacks_list = [hub_cb, platform_cb]
+
+    # Load training callbacks
+    if "Trainer" in instance.__class__.__name__:
+        from .clearml import callbacks as clear_cb
+        from .comet import callbacks as comet_cb
+        from .dvc import callbacks as dvc_cb
+        from .mlflow import callbacks as mlflow_cb
+        from .neptune import callbacks as neptune_cb
+        from .raytune import callbacks as tune_cb
+        from .tensorboard import callbacks as tb_cb
+        from .wb import callbacks as wb_cb
+
+        callbacks_list.extend([clear_cb, comet_cb, dvc_cb, mlflow_cb, neptune_cb, tune_cb, tb_cb, wb_cb])
+
+    # Add the callbacks to the callbacks dictionary
+    for callbacks in callbacks_list:
+        for k, v in callbacks.items():
+            if v not in instance.callbacks[k]:
+                instance.callbacks[k].append(v)

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/clearml.py

@@ -0,0 +1,146 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from ultralytics.utils import LOGGER, SETTINGS, TESTS_RUNNING
+
+try:
+    assert not TESTS_RUNNING  # do not log pytest
+    assert SETTINGS["clearml"] is True  # verify integration is enabled
+    import clearml
+    from clearml import Task
+
+    assert hasattr(clearml, "__version__")  # verify package is not directory
+
+except (ImportError, AssertionError):
+    clearml = None
+
+
+def _log_debug_samples(files, title: str = "Debug Samples") -> None:
+    """Log files (images) as debug samples in the ClearML task.
+
+    Args:
+        files (list[Path]): A list of file paths in PosixPath format.
+        title (str): A title that groups together images with the same values.
+    """
+    import re
+
+    if task := Task.current_task():
+        for f in files:
+            if f.exists():
+                it = re.search(r"_batch(\d+)", f.name)
+                iteration = int(it.groups()[0]) if it else 0
+                task.get_logger().report_image(
+                    title=title, series=f.name.replace(it.group(), ""), local_path=str(f), iteration=iteration
+                )
+
+
+def _log_plot(title: str, plot_path: str) -> None:
+    """Log an image as a plot in the plot section of ClearML.
+
+    Args:
+        title (str): The title of the plot.
+        plot_path (str | Path): The path to the saved image file.
+    """
+    import matplotlib.image as mpimg
+    import matplotlib.pyplot as plt
+
+    img = mpimg.imread(plot_path)
+    fig = plt.figure()
+    ax = fig.add_axes([0, 0, 1, 1], frameon=False, aspect="auto", xticks=[], yticks=[])  # no ticks
+    ax.imshow(img)
+
+    Task.current_task().get_logger().report_matplotlib_figure(
+        title=title, series="", figure=fig, report_interactive=False
+    )
+
+
+def on_pretrain_routine_start(trainer) -> None:
+    """Initialize and connect ClearML task at the start of pretraining routine."""
+    try:
+        if task := Task.current_task():
+            # WARNING: make sure the automatic pytorch and matplotlib bindings are disabled!
+            # We are logging these plots and model files manually in the integration
+            from clearml.binding.frameworks.pytorch_bind import PatchPyTorchModelIO
+            from clearml.binding.matplotlib_bind import PatchedMatplotlib
+
+            PatchPyTorchModelIO.update_current_task(None)
+            PatchedMatplotlib.update_current_task(None)
+        else:
+            task = Task.init(
+                project_name=str(trainer.args.project or "Ultralytics").lstrip("/") or "Ultralytics",
+                task_name=trainer.args.name,
+                tags=["Ultralytics"],
+                output_uri=True,
+                reuse_last_task_id=False,
+                auto_connect_frameworks={"pytorch": False, "matplotlib": False},
+            )
+            LOGGER.warning(
+                "ClearML Initialized a new task. If you want to run remotely, "
+                "please add clearml-init and connect your arguments before initializing YOLO."
+            )
+        task.connect(vars(trainer.args), name="General", ignore_remote_overrides=True)
+    except Exception as e:
+        LOGGER.warning(f"ClearML installed but not initialized correctly, not logging this run. {e}")
+
+
+def on_train_epoch_end(trainer) -> None:
+    """Log debug samples for the first epoch and report current training progress."""
+    if task := Task.current_task():
+        # Log debug samples for first epoch only
+        if trainer.epoch == 1:
+            _log_debug_samples(sorted(trainer.save_dir.glob("train_batch*.jpg")), "Mosaic")
+        # Report the current training progress
+        for k, v in trainer.label_loss_items(trainer.tloss, prefix="train").items():
+            task.get_logger().report_scalar("train", k, v, iteration=trainer.epoch)
+        for k, v in trainer.lr.items():
+            task.get_logger().report_scalar("lr", k, v, iteration=trainer.epoch)
+
+
+def on_fit_epoch_end(trainer) -> None:
+    """Report model information and metrics to logger at the end of an epoch."""
+    if task := Task.current_task():
+        # Report epoch time and validation metrics
+        task.get_logger().report_scalar(
+            title="Epoch Time", series="Epoch Time", value=trainer.epoch_time, iteration=trainer.epoch
+        )
+        for k, v in trainer.metrics.items():
+            title = k.split("/")[0]
+            task.get_logger().report_scalar(title, k, v, iteration=trainer.epoch)
+        if trainer.epoch == 0:
+            from ultralytics.utils.torch_utils import model_info_for_loggers
+
+            for k, v in model_info_for_loggers(trainer).items():
+                task.get_logger().report_single_value(k, v)
+
+
+def on_val_end(validator) -> None:
+    """Log validation results including labels and predictions."""
+    if Task.current_task():
+        # Log validation labels and predictions
+        _log_debug_samples(sorted(validator.save_dir.glob("val*.jpg")), "Validation")
+
+
+def on_train_end(trainer) -> None:
+    """Log final model and training results on training completion."""
+    if task := Task.current_task():
+        # Log final results, confusion matrix and PR plots
+        for f in [*trainer.plots.keys(), *trainer.validator.plots.keys()]:
+            if "batch" not in f.name:
+                _log_plot(title=f.stem, plot_path=f)
+        # Report final metrics
+        for k, v in trainer.validator.metrics.results_dict.items():
+            task.get_logger().report_single_value(k, v)
+        # Log the final model
+        task.update_output_model(model_path=str(trainer.best), model_name=trainer.args.name, auto_delete_file=False)
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_train_epoch_end": on_train_epoch_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_val_end": on_val_end,
+        "on_train_end": on_train_end,
+    }
+    if clearml
+    else {}
+)

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/comet.py

@@ -0,0 +1,622 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from types import SimpleNamespace
+from typing import Any
+
+import cv2
+import numpy as np
+
+from ultralytics.utils import LOGGER, RANK, SETTINGS, TESTS_RUNNING, ops
+from ultralytics.utils.metrics import ClassifyMetrics, DetMetrics, OBBMetrics, PoseMetrics, SegmentMetrics
+
+try:
+    assert not TESTS_RUNNING  # do not log pytest
+    assert SETTINGS["comet"] is True  # verify integration is enabled
+    import comet_ml
+
+    assert hasattr(comet_ml, "__version__")  # verify package is not directory
+
+    import os
+    from pathlib import Path
+
+    # Ensures certain logging functions only run for supported tasks
+    COMET_SUPPORTED_TASKS = ["detect", "segment"]
+
+    # Names of plots created by Ultralytics that are logged to Comet
+    CONFUSION_MATRIX_PLOT_NAMES = "confusion_matrix", "confusion_matrix_normalized"
+    EVALUATION_PLOT_NAMES = "F1_curve", "P_curve", "R_curve", "PR_curve"
+    LABEL_PLOT_NAMES = ["labels"]
+    SEGMENT_METRICS_PLOT_PREFIX = "Box", "Mask"
+    POSE_METRICS_PLOT_PREFIX = "Box", "Pose"
+    DETECTION_METRICS_PLOT_PREFIX = ["Box"]
+    RESULTS_TABLE_NAME = "results.csv"
+    ARGS_YAML_NAME = "args.yaml"
+
+    _comet_image_prediction_count = 0
+
+except (ImportError, AssertionError):
+    comet_ml = None
+
+
+def _get_comet_mode() -> str:
+    """Return the Comet mode from environment variables, defaulting to 'online'."""
+    comet_mode = os.getenv("COMET_MODE")
+    if comet_mode is not None:
+        LOGGER.warning(
+            "The COMET_MODE environment variable is deprecated. "
+            "Please use COMET_START_ONLINE to set the Comet experiment mode. "
+            "To start an offline Comet experiment, use 'export COMET_START_ONLINE=0'. "
+            "If COMET_START_ONLINE is not set or is set to '1', an online Comet experiment will be created."
+        )
+        return comet_mode
+
+    return "online"
+
+
+def _get_comet_model_name() -> str:
+    """Return the Comet model name from environment variable or default to 'Ultralytics'."""
+    return os.getenv("COMET_MODEL_NAME", "Ultralytics")
+
+
+def _get_eval_batch_logging_interval() -> int:
+    """Get the evaluation batch logging interval from environment variable or use default value 1."""
+    return int(os.getenv("COMET_EVAL_BATCH_LOGGING_INTERVAL", 1))
+
+
+def _get_max_image_predictions_to_log() -> int:
+    """Get the maximum number of image predictions to log from environment variables."""
+    return int(os.getenv("COMET_MAX_IMAGE_PREDICTIONS", 100))
+
+
+def _scale_confidence_score(score: float) -> float:
+    """Scale the confidence score by a factor specified in environment variable."""
+    scale = float(os.getenv("COMET_MAX_CONFIDENCE_SCORE", 100.0))
+    return score * scale
+
+
+def _should_log_confusion_matrix() -> bool:
+    """Determine if the confusion matrix should be logged based on environment variable settings."""
+    return os.getenv("COMET_EVAL_LOG_CONFUSION_MATRIX", "false").lower() == "true"
+
+
+def _should_log_image_predictions() -> bool:
+    """Determine whether to log image predictions based on environment variable."""
+    return os.getenv("COMET_EVAL_LOG_IMAGE_PREDICTIONS", "true").lower() == "true"
+
+
+def _resume_or_create_experiment(args: SimpleNamespace) -> None:
+    """Resume CometML experiment or create a new experiment based on args.
+
+    Ensures that the experiment object is only created in a single process during distributed training.
+
+    Args:
+        args (SimpleNamespace): Training arguments containing project configuration and other parameters.
+    """
+    if RANK not in {-1, 0}:
+        return
+
+    # Set environment variable (if not set by the user) to configure the Comet experiment's online mode under the hood.
+    # IF COMET_START_ONLINE is set by the user it will override COMET_MODE value.
+    if os.getenv("COMET_START_ONLINE") is None:
+        comet_mode = _get_comet_mode()
+        os.environ["COMET_START_ONLINE"] = "1" if comet_mode != "offline" else "0"
+
+    try:
+        _project_name = os.getenv("COMET_PROJECT_NAME", args.project)
+        experiment = comet_ml.start(project_name=_project_name)
+        experiment.log_parameters(vars(args))
+        experiment.log_others(
+            {
+                "eval_batch_logging_interval": _get_eval_batch_logging_interval(),
+                "log_confusion_matrix_on_eval": _should_log_confusion_matrix(),
+                "log_image_predictions": _should_log_image_predictions(),
+                "max_image_predictions": _get_max_image_predictions_to_log(),
+            }
+        )
+        experiment.log_other("Created from", "ultralytics")
+
+    except Exception as e:
+        LOGGER.warning(f"Comet installed but not initialized correctly, not logging this run. {e}")
+
+
+def _fetch_trainer_metadata(trainer) -> dict:
+    """Return metadata for YOLO training including epoch and asset saving status.
+
+    Args:
+        trainer (ultralytics.engine.trainer.BaseTrainer): The YOLO trainer object containing training state and config.
+
+    Returns:
+        (dict): Dictionary containing current epoch, step, save assets flag, and final epoch flag.
+    """
+    curr_epoch = trainer.epoch + 1
+
+    train_num_steps_per_epoch = len(trainer.train_loader.dataset) // trainer.batch_size
+    curr_step = curr_epoch * train_num_steps_per_epoch
+    final_epoch = curr_epoch == trainer.epochs
+
+    save = trainer.args.save
+    save_period = trainer.args.save_period
+    save_interval = curr_epoch % save_period == 0
+    save_assets = save and save_period > 0 and save_interval and not final_epoch
+
+    return dict(curr_epoch=curr_epoch, curr_step=curr_step, save_assets=save_assets, final_epoch=final_epoch)
+
+
+def _scale_bounding_box_to_original_image_shape(
+    box, resized_image_shape, original_image_shape, ratio_pad
+) -> list[float]:
+    """Scale bounding box from resized image coordinates to original image coordinates.
+
+    YOLO resizes images during training and the label values are normalized based on this resized shape. This function
+    rescales the bounding box labels to the original image shape.
+
+    Args:
+        box (torch.Tensor): Bounding box in normalized xywh format.
+        resized_image_shape (tuple): Shape of the resized image (height, width).
+        original_image_shape (tuple): Shape of the original image (height, width).
+        ratio_pad (tuple): Ratio and padding information for scaling.
+
+    Returns:
+        (list[float]): Scaled bounding box coordinates in xywh format with top-left corner adjustment.
+    """
+    resized_image_height, resized_image_width = resized_image_shape
+
+    # Convert normalized xywh format predictions to xyxy in resized scale format
+    box = ops.xywhn2xyxy(box, h=resized_image_height, w=resized_image_width)
+    # Scale box predictions from resized image scale back to original image scale
+    box = ops.scale_boxes(resized_image_shape, box, original_image_shape, ratio_pad)
+    # Convert bounding box format from xyxy to xywh for Comet logging
+    box = ops.xyxy2xywh(box)
+    # Adjust xy center to correspond top-left corner
+    box[:2] -= box[2:] / 2
+    box = box.tolist()
+
+    return box
+
+
+def _format_ground_truth_annotations_for_detection(img_idx, image_path, batch, class_name_map=None) -> dict | None:
+    """Format ground truth annotations for object detection.
+
+    This function processes ground truth annotations from a batch of images for object detection tasks. It extracts
+    bounding boxes, class labels, and other metadata for a specific image in the batch, and formats them for
+    visualization or evaluation.
+
+    Args:
+        img_idx (int): Index of the image in the batch to process.
+        image_path (str | Path): Path to the image file.
+        batch (dict): Batch dictionary containing detection data with keys:
+            - 'batch_idx': Tensor of batch indices
+            - 'bboxes': Tensor of bounding boxes in normalized xywh format
+            - 'cls': Tensor of class labels
+            - 'ori_shape': Original image shapes
+            - 'resized_shape': Resized image shapes
+            - 'ratio_pad': Ratio and padding information
+        class_name_map (dict, optional): Mapping from class indices to class names.
+
+    Returns:
+        (dict | None): Formatted ground truth annotations with keys 'name' and 'data', where 'data' is a list of
+            annotation dicts each containing 'boxes', 'label', and 'score' keys. Returns None if no bounding boxes are
+            found for the image.
+    """
+    indices = batch["batch_idx"] == img_idx
+    bboxes = batch["bboxes"][indices]
+    if len(bboxes) == 0:
+        LOGGER.debug(f"Comet Image: {image_path} has no bounding boxes labels")
+        return None
+
+    cls_labels = batch["cls"][indices].squeeze(1).tolist()
+    if class_name_map:
+        cls_labels = [str(class_name_map[label]) for label in cls_labels]
+
+    original_image_shape = batch["ori_shape"][img_idx]
+    resized_image_shape = batch["resized_shape"][img_idx]
+    ratio_pad = batch["ratio_pad"][img_idx]
+
+    data = []
+    for box, label in zip(bboxes, cls_labels):
+        box = _scale_bounding_box_to_original_image_shape(box, resized_image_shape, original_image_shape, ratio_pad)
+        data.append(
+            {
+                "boxes": [box],
+                "label": f"gt_{label}",
+                "score": _scale_confidence_score(1.0),
+            }
+        )
+
+    return {"name": "ground_truth", "data": data}
+
+
+def _format_prediction_annotations(image_path, metadata, class_label_map=None, class_map=None) -> dict | None:
+    """Format YOLO predictions for object detection visualization.
+
+    Args:
+        image_path (Path): Path to the image file.
+        metadata (dict): Prediction metadata containing bounding boxes and class information.
+        class_label_map (dict, optional): Mapping from class indices to class names.
+        class_map (dict, optional): Additional class mapping for label conversion.
+
+    Returns:
+        (dict | None): Formatted prediction annotations or None if no predictions exist.
+    """
+    stem = image_path.stem
+    image_id = int(stem) if stem.isnumeric() else stem
+
+    predictions = metadata.get(image_id)
+    if not predictions:
+        LOGGER.debug(f"Comet Image: {image_path} has no bounding boxes predictions")
+        return None
+
+    # apply the mapping that was used to map the predicted classes when the JSON was created
+    if class_label_map and class_map:
+        class_label_map = {class_map[k]: v for k, v in class_label_map.items()}
+    try:
+        # import faster_coco_eval utilities to decompress annotations for various tasks, e.g. segmentation
+        from faster_coco_eval.core.mask import decode
+    except ImportError:
+        decode = None
+
+    data = []
+    for prediction in predictions:
+        boxes = prediction["bbox"]
+        score = _scale_confidence_score(prediction["score"])
+        cls_label = prediction["category_id"]
+        if class_label_map:
+            cls_label = str(class_label_map[cls_label])
+
+        annotation_data = {"boxes": [boxes], "label": cls_label, "score": score}
+
+        if decode is not None:
+            # do segmentation processing only if we are able to decode it
+            segments = prediction.get("segmentation", None)
+            if segments is not None:
+                segments = _extract_segmentation_annotation(segments, decode)
+            if segments is not None:
+                annotation_data["points"] = segments
+
+        data.append(annotation_data)
+
+    return {"name": "prediction", "data": data}
+
+
+def _extract_segmentation_annotation(segmentation_raw: str, decode: Callable) -> list[list[Any]] | None:
+    """Extract segmentation annotation from compressed segmentations as list of polygons.
+
+    Args:
+        segmentation_raw (str): Raw segmentation data in compressed format.
+        decode (Callable): Function to decode the compressed segmentation data.
+
+    Returns:
+        (list[list[Any]] | None): List of polygon points or None if extraction fails.
+    """
+    try:
+        mask = decode(segmentation_raw)
+        contours, _ = cv2.findContours(mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+        annotations = [np.array(polygon).squeeze() for polygon in contours if len(polygon) >= 3]
+        return [annotation.ravel().tolist() for annotation in annotations]
+    except Exception as e:
+        LOGGER.warning(f"Comet Failed to extract segmentation annotation: {e}")
+    return None
+
+
+def _fetch_annotations(img_idx, image_path, batch, prediction_metadata_map, class_label_map, class_map) -> list | None:
+    """Join the ground truth and prediction annotations if they exist.
+
+    Args:
+        img_idx (int): Index of the image in the batch.
+        image_path (Path): Path to the image file.
+        batch (dict): Batch data containing ground truth annotations.
+        prediction_metadata_map (dict): Map of prediction metadata by image ID.
+        class_label_map (dict): Mapping from class indices to class names.
+        class_map (dict): Additional class mapping for label conversion.
+
+    Returns:
+        (list | None): List of annotation dictionaries or None if no annotations exist.
+    """
+    ground_truth_annotations = _format_ground_truth_annotations_for_detection(
+        img_idx, image_path, batch, class_label_map
+    )
+    prediction_annotations = _format_prediction_annotations(
+        image_path, prediction_metadata_map, class_label_map, class_map
+    )
+
+    annotations = [
+        annotation for annotation in [ground_truth_annotations, prediction_annotations] if annotation is not None
+    ]
+    return [annotations] if annotations else None
+
+
+def _create_prediction_metadata_map(model_predictions) -> dict:
+    """Create metadata map for model predictions by grouping them based on image ID."""
+    pred_metadata_map = {}
+    for prediction in model_predictions:
+        pred_metadata_map.setdefault(prediction["image_id"], [])
+        pred_metadata_map[prediction["image_id"]].append(prediction)
+
+    return pred_metadata_map
+
+
+def _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch) -> None:
+    """Log the confusion matrix to Comet experiment."""
+    conf_mat = trainer.validator.confusion_matrix.matrix
+    names = [*list(trainer.data["names"].values()), "background"]
+    experiment.log_confusion_matrix(
+        matrix=conf_mat, labels=names, max_categories=len(names), epoch=curr_epoch, step=curr_step
+    )
+
+
+def _log_images(experiment, image_paths, curr_step: int | None, annotations=None) -> None:
+    """Log images to the experiment with optional annotations.
+
+    This function logs images to a Comet ML experiment, optionally including annotation data for visualization such as
+    bounding boxes or segmentation masks.
+
+    Args:
+        experiment (comet_ml.CometExperiment): The Comet ML experiment to log images to.
+        image_paths (list[Path]): List of paths to images that will be logged.
+        curr_step (int | None): Current training step/iteration for tracking in the experiment timeline.
+        annotations (list[list[dict]], optional): Nested list of annotation dictionaries for each image. Each annotation
+            contains visualization data like bounding boxes, labels, and confidence scores.
+    """
+    if annotations:
+        for image_path, annotation in zip(image_paths, annotations):
+            experiment.log_image(image_path, name=image_path.stem, step=curr_step, annotations=annotation)
+
+    else:
+        for image_path in image_paths:
+            experiment.log_image(image_path, name=image_path.stem, step=curr_step)
+
+
+def _log_image_predictions(experiment, validator, curr_step) -> None:
+    """Log image predictions to a Comet ML experiment during model validation.
+
+    This function processes validation data and formats both ground truth and prediction annotations for visualization
+    in the Comet dashboard. The function respects configured limits on the number of images to log.
+
+    Args:
+        experiment (comet_ml.CometExperiment): The Comet ML experiment to log to.
+        validator (BaseValidator): The validator instance containing validation data and predictions.
+        curr_step (int): The current training step for logging timeline.
+
+    Notes:
+        This function uses global state to track the number of logged predictions across calls.
+        It only logs predictions for supported tasks defined in COMET_SUPPORTED_TASKS.
+        The number of logged images is limited by the COMET_MAX_IMAGE_PREDICTIONS environment variable.
+    """
+    global _comet_image_prediction_count
+
+    task = validator.args.task
+    if task not in COMET_SUPPORTED_TASKS:
+        return
+
+    jdict = validator.jdict
+    if not jdict:
+        return
+
+    predictions_metadata_map = _create_prediction_metadata_map(jdict)
+    dataloader = validator.dataloader
+    class_label_map = validator.names
+    class_map = getattr(validator, "class_map", None)
+
+    batch_logging_interval = _get_eval_batch_logging_interval()
+    max_image_predictions = _get_max_image_predictions_to_log()
+
+    for batch_idx, batch in enumerate(dataloader):
+        if (batch_idx + 1) % batch_logging_interval != 0:
+            continue
+
+        image_paths = batch["im_file"]
+        for img_idx, image_path in enumerate(image_paths):
+            if _comet_image_prediction_count >= max_image_predictions:
+                return
+
+            image_path = Path(image_path)
+            annotations = _fetch_annotations(
+                img_idx,
+                image_path,
+                batch,
+                predictions_metadata_map,
+                class_label_map,
+                class_map=class_map,
+            )
+            _log_images(
+                experiment,
+                [image_path],
+                curr_step,
+                annotations=annotations,
+            )
+            _comet_image_prediction_count += 1
+
+
+def _log_plots(experiment, trainer) -> None:
+    """Log evaluation plots and label plots for the experiment.
+
+    This function logs various evaluation plots and confusion matrices to the experiment tracking system. It handles
+    different types of metrics (SegmentMetrics, PoseMetrics, DetMetrics, OBBMetrics) and logs the appropriate plots for
+    each type.
+
+    Args:
+        experiment (comet_ml.CometExperiment): The Comet ML experiment to log plots to.
+        trainer (ultralytics.engine.trainer.BaseTrainer): The trainer object containing validation metrics and save
+            directory information.
+
+    Examples:
+        >>> from ultralytics.utils.callbacks.comet import _log_plots
+        >>> _log_plots(experiment, trainer)
+    """
+    plot_filenames = None
+    if isinstance(trainer.validator.metrics, SegmentMetrics):
+        plot_filenames = [
+            trainer.save_dir / f"{prefix}{plots}.png"
+            for plots in EVALUATION_PLOT_NAMES
+            for prefix in SEGMENT_METRICS_PLOT_PREFIX
+        ]
+    elif isinstance(trainer.validator.metrics, PoseMetrics):
+        plot_filenames = [
+            trainer.save_dir / f"{prefix}{plots}.png"
+            for plots in EVALUATION_PLOT_NAMES
+            for prefix in POSE_METRICS_PLOT_PREFIX
+        ]
+    elif isinstance(trainer.validator.metrics, (DetMetrics, OBBMetrics)):
+        plot_filenames = [
+            trainer.save_dir / f"{prefix}{plots}.png"
+            for plots in EVALUATION_PLOT_NAMES
+            for prefix in DETECTION_METRICS_PLOT_PREFIX
+        ]
+
+    if plot_filenames is not None:
+        _log_images(experiment, plot_filenames, None)
+
+    confusion_matrix_filenames = [trainer.save_dir / f"{plots}.png" for plots in CONFUSION_MATRIX_PLOT_NAMES]
+    _log_images(experiment, confusion_matrix_filenames, None)
+
+    if not isinstance(trainer.validator.metrics, ClassifyMetrics):
+        label_plot_filenames = [trainer.save_dir / f"{labels}.jpg" for labels in LABEL_PLOT_NAMES]
+        _log_images(experiment, label_plot_filenames, None)
+
+
+def _log_model(experiment, trainer) -> None:
+    """Log the best-trained model to Comet.ml."""
+    model_name = _get_comet_model_name()
+    experiment.log_model(model_name, file_or_folder=str(trainer.best), file_name="best.pt", overwrite=True)
+
+
+def _log_image_batches(experiment, trainer, curr_step: int) -> None:
+    """Log samples of image batches for train and validation."""
+    _log_images(experiment, trainer.save_dir.glob("train_batch*.jpg"), curr_step)
+    _log_images(experiment, trainer.save_dir.glob("val_batch*.jpg"), curr_step)
+
+
+def _log_asset(experiment, asset_path) -> None:
+    """Logs a specific asset file to the given experiment.
+
+    This function facilitates logging an asset, such as a file, to the provided
+    experiment. It enables integration with experiment tracking platforms.
+
+    Args:
+        experiment (comet_ml.CometExperiment): The experiment instance to which the asset will be logged.
+        asset_path (Path): The file path of the asset to log.
+    """
+    experiment.log_asset(asset_path)
+
+
+def _log_table(experiment, table_path) -> None:
+    """Logs a table to the provided experiment.
+
+    This function is used to log a table file to the given experiment. The table is identified by its file path.
+
+    Args:
+        experiment (comet_ml.CometExperiment): The experiment object where the table file will be logged.
+        table_path (Path): The file path of the table to be logged.
+    """
+    experiment.log_table(str(table_path))
+
+
+def on_pretrain_routine_start(trainer) -> None:
+    """Create or resume a CometML experiment at the start of a YOLO pre-training routine."""
+    _resume_or_create_experiment(trainer.args)
+
+
+def on_train_epoch_end(trainer) -> None:
+    """Log metrics and save batch images at the end of training epochs."""
+    experiment = comet_ml.get_running_experiment()
+    if not experiment:
+        return
+
+    metadata = _fetch_trainer_metadata(trainer)
+    curr_epoch = metadata["curr_epoch"]
+    curr_step = metadata["curr_step"]
+
+    experiment.log_metrics(trainer.label_loss_items(trainer.tloss, prefix="train"), step=curr_step, epoch=curr_epoch)
+
+
+def on_fit_epoch_end(trainer) -> None:
+    """Log model assets at the end of each epoch during training.
+
+    This function is called at the end of each training epoch to log metrics, learning rates, and model information to a
+    Comet ML experiment. It also logs model assets, confusion matrices, and image predictions based on configuration
+    settings.
+
+    The function retrieves the current Comet ML experiment and logs various training metrics. If it's the first epoch,
+    it also logs model information. On specified save intervals, it logs the model, confusion matrix (if enabled), and
+    image predictions (if enabled).
+
+    Args:
+        trainer (BaseTrainer): The YOLO trainer object containing training state, metrics, and configuration.
+
+    Examples:
+        >>> # Inside a training loop
+        >>> on_fit_epoch_end(trainer)  # Log metrics and assets to Comet ML
+    """
+    experiment = comet_ml.get_running_experiment()
+    if not experiment:
+        return
+
+    metadata = _fetch_trainer_metadata(trainer)
+    curr_epoch = metadata["curr_epoch"]
+    curr_step = metadata["curr_step"]
+    save_assets = metadata["save_assets"]
+
+    experiment.log_metrics(trainer.metrics, step=curr_step, epoch=curr_epoch)
+    experiment.log_metrics(trainer.lr, step=curr_step, epoch=curr_epoch)
+    if curr_epoch == 1:
+        from ultralytics.utils.torch_utils import model_info_for_loggers
+
+        experiment.log_metrics(model_info_for_loggers(trainer), step=curr_step, epoch=curr_epoch)
+
+    if not save_assets:
+        return
+
+    _log_model(experiment, trainer)
+    if _should_log_confusion_matrix():
+        _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch)
+    if _should_log_image_predictions():
+        _log_image_predictions(experiment, trainer.validator, curr_step)
+
+
+def on_train_end(trainer) -> None:
+    """Perform operations at the end of training."""
+    experiment = comet_ml.get_running_experiment()
+    if not experiment:
+        return
+
+    metadata = _fetch_trainer_metadata(trainer)
+    curr_epoch = metadata["curr_epoch"]
+    curr_step = metadata["curr_step"]
+    plots = trainer.args.plots
+
+    _log_model(experiment, trainer)
+    if plots:
+        _log_plots(experiment, trainer)
+
+    _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch)
+    _log_image_predictions(experiment, trainer.validator, curr_step)
+    _log_image_batches(experiment, trainer, curr_step)
+    # log results table
+    table_path = trainer.save_dir / RESULTS_TABLE_NAME
+    if table_path.exists():
+        _log_table(experiment, table_path)
+
+    # log arguments YAML
+    args_path = trainer.save_dir / ARGS_YAML_NAME
+    if args_path.exists():
+        _log_asset(experiment, args_path)
+
+    experiment.end()
+
+    global _comet_image_prediction_count
+    _comet_image_prediction_count = 0
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_train_epoch_end": on_train_epoch_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_train_end": on_train_end,
+    }
+    if comet_ml
+    else {}
+)

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/dvc.py

@@ -0,0 +1,197 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from pathlib import Path
+
+from ultralytics.utils import LOGGER, SETTINGS, TESTS_RUNNING, checks
+
+try:
+    assert not TESTS_RUNNING  # do not log pytest
+    assert SETTINGS["dvc"] is True  # verify integration is enabled
+    import dvclive
+
+    assert checks.check_version("dvclive", "2.11.0", verbose=True)
+
+    import os
+    import re
+
+    # DVCLive logger instance
+    live = None
+    _processed_plots = {}
+
+    # `on_fit_epoch_end` is called on final validation (probably need to be fixed) for now this is the way we
+    # distinguish final evaluation of the best model vs last epoch validation
+    _training_epoch = False
+
+except (ImportError, AssertionError, TypeError):
+    dvclive = None
+
+
+def _log_images(path: Path, prefix: str = "") -> None:
+    """Log images at specified path with an optional prefix using DVCLive.
+
+    This function logs images found at the given path to DVCLive, organizing them by batch to enable slider
+    functionality in the UI. It processes image filenames to extract batch information and restructures the path
+    accordingly.
+
+    Args:
+        path (Path): Path to the image file to be logged.
+        prefix (str, optional): Optional prefix to add to the image name when logging.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> _log_images(Path("runs/train/exp/val_batch0_pred.jpg"), prefix="validation")
+    """
+    if live:
+        name = path.name
+
+        # Group images by batch to enable sliders in UI
+        if m := re.search(r"_batch(\d+)", name):
+            ni = m[1]
+            new_stem = re.sub(r"_batch(\d+)", "_batch", path.stem)
+            name = (Path(new_stem) / ni).with_suffix(path.suffix)
+
+        live.log_image(os.path.join(prefix, name), path)
+
+
+def _log_plots(plots: dict, prefix: str = "") -> None:
+    """Log plot images for training progress if they have not been previously processed.
+
+    Args:
+        plots (dict): Dictionary containing plot information with timestamps.
+        prefix (str, optional): Optional prefix to add to the logged image paths.
+    """
+    for name, params in plots.items():
+        timestamp = params["timestamp"]
+        if _processed_plots.get(name) != timestamp:
+            _log_images(name, prefix)
+            _processed_plots[name] = timestamp
+
+
+def _log_confusion_matrix(validator) -> None:
+    """Log confusion matrix for a validator using DVCLive.
+
+    This function processes the confusion matrix from a validator object and logs it to DVCLive by converting the matrix
+    into lists of target and prediction labels.
+
+    Args:
+        validator (BaseValidator): The validator object containing the confusion matrix and class names. Must have
+            attributes confusion_matrix.matrix, confusion_matrix.task, and names.
+    """
+    targets = []
+    preds = []
+    matrix = validator.confusion_matrix.matrix
+    names = list(validator.names.values())
+    if validator.confusion_matrix.task in {"detect", "obb"}:
+        names += ["background"]
+
+    for ti, pred in enumerate(matrix.T.astype(int)):
+        for pi, num in enumerate(pred):
+            targets.extend([names[ti]] * num)
+            preds.extend([names[pi]] * num)
+
+    live.log_sklearn_plot("confusion_matrix", targets, preds, name="cf.json", normalized=True)
+
+
+def on_pretrain_routine_start(trainer) -> None:
+    """Initialize DVCLive logger for training metadata during pre-training routine."""
+    try:
+        global live
+        live = dvclive.Live(save_dvc_exp=True, cache_images=True)
+        LOGGER.info("DVCLive is detected and auto logging is enabled (run 'yolo settings dvc=False' to disable).")
+    except Exception as e:
+        LOGGER.warning(f"DVCLive installed but not initialized correctly, not logging this run. {e}")
+
+
+def on_pretrain_routine_end(trainer) -> None:
+    """Log plots related to the training process at the end of the pretraining routine."""
+    _log_plots(trainer.plots, "train")
+
+
+def on_train_start(trainer) -> None:
+    """Log the training parameters if DVCLive logging is active."""
+    if live:
+        live.log_params(trainer.args)
+
+
+def on_train_epoch_start(trainer) -> None:
+    """Set the global variable _training_epoch value to True at the start of each training epoch."""
+    global _training_epoch
+    _training_epoch = True
+
+
+def on_fit_epoch_end(trainer) -> None:
+    """Log training metrics, model info, and advance to next step at the end of each fit epoch.
+
+    This function is called at the end of each fit epoch during training. It logs various metrics including training
+    loss items, validation metrics, and learning rates. On the first epoch, it also logs model
+    information. Additionally, it logs training and validation plots and advances the DVCLive step counter.
+
+    Args:
+        trainer (BaseTrainer): The trainer object containing training state, metrics, and plots.
+
+    Notes:
+        This function only performs logging operations when DVCLive logging is active and during a training epoch.
+        The global variable _training_epoch is used to track whether the current epoch is a training epoch.
+    """
+    global _training_epoch
+    if live and _training_epoch:
+        all_metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics, **trainer.lr}
+        for metric, value in all_metrics.items():
+            live.log_metric(metric, value)
+
+        if trainer.epoch == 0:
+            from ultralytics.utils.torch_utils import model_info_for_loggers
+
+            for metric, value in model_info_for_loggers(trainer).items():
+                live.log_metric(metric, value, plot=False)
+
+        _log_plots(trainer.plots, "train")
+        _log_plots(trainer.validator.plots, "val")
+
+        live.next_step()
+        _training_epoch = False
+
+
+def on_train_end(trainer) -> None:
+    """Log best metrics, plots, and confusion matrix at the end of training.
+
+    This function is called at the conclusion of the training process to log final metrics, visualizations, and model
+    artifacts if DVCLive logging is active. It captures the best model performance metrics, training plots, validation
+    plots, and confusion matrix for later analysis.
+
+    Args:
+        trainer (BaseTrainer): The trainer object containing training state, metrics, and validation results.
+
+    Examples:
+        >>> # Inside a custom training loop
+        >>> from ultralytics.utils.callbacks.dvc import on_train_end
+        >>> on_train_end(trainer)  # Log final metrics and artifacts
+    """
+    if live:
+        # At the end log the best metrics. It runs validator on the best model internally.
+        all_metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics, **trainer.lr}
+        for metric, value in all_metrics.items():
+            live.log_metric(metric, value, plot=False)
+
+        _log_plots(trainer.plots, "val")
+        _log_plots(trainer.validator.plots, "val")
+        _log_confusion_matrix(trainer.validator)
+
+        if trainer.best.exists():
+            live.log_artifact(trainer.best, copy=True, type="model")
+
+        live.end()
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_pretrain_routine_end": on_pretrain_routine_end,
+        "on_train_start": on_train_start,
+        "on_train_epoch_start": on_train_epoch_start,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_train_end": on_train_end,
+    }
+    if dvclive
+    else {}
+)

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/hub.py

@@ -0,0 +1,111 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import json
+from time import time
+
+from ultralytics.hub import HUB_WEB_ROOT, PREFIX, HUBTrainingSession
+from ultralytics.utils import LOGGER, RANK, SETTINGS
+from ultralytics.utils.events import events
+
+
+def on_pretrain_routine_start(trainer):
+    """Create a remote Ultralytics HUB session to log local model training."""
+    if RANK in {-1, 0} and SETTINGS["hub"] is True and SETTINGS["api_key"] and trainer.hub_session is None:
+        trainer.hub_session = HUBTrainingSession.create_session(trainer.args.model, trainer.args)
+
+
+def on_pretrain_routine_end(trainer):
+    """Initialize timers for upload rate limiting before training begins."""
+    if session := getattr(trainer, "hub_session", None):
+        # Start timer for upload rate limit
+        session.timers = {"metrics": time(), "ckpt": time()}  # start timer for session rate limiting
+
+
+def on_fit_epoch_end(trainer):
+    """Upload training progress metrics to Ultralytics HUB at the end of each epoch."""
+    if session := getattr(trainer, "hub_session", None):
+        # Upload metrics after validation ends
+        all_plots = {
+            **trainer.label_loss_items(trainer.tloss, prefix="train"),
+            **trainer.metrics,
+        }
+        if trainer.epoch == 0:
+            from ultralytics.utils.torch_utils import model_info_for_loggers
+
+            all_plots = {**all_plots, **model_info_for_loggers(trainer)}
+
+        session.metrics_queue[trainer.epoch] = json.dumps(all_plots)
+
+        # If any metrics failed to upload previously, add them to the queue to attempt uploading again
+        if session.metrics_upload_failed_queue:
+            session.metrics_queue.update(session.metrics_upload_failed_queue)
+
+        if time() - session.timers["metrics"] > session.rate_limits["metrics"]:
+            session.upload_metrics()
+            session.timers["metrics"] = time()  # reset timer
+            session.metrics_queue = {}  # reset queue
+
+
+def on_model_save(trainer):
+    """Upload model checkpoints to Ultralytics HUB with rate limiting."""
+    if session := getattr(trainer, "hub_session", None):
+        # Upload checkpoints with rate limiting
+        is_best = trainer.best_fitness == trainer.fitness
+        if time() - session.timers["ckpt"] > session.rate_limits["ckpt"]:
+            LOGGER.info(f"{PREFIX}Uploading checkpoint {HUB_WEB_ROOT}/models/{session.model.id}")
+            session.upload_model(trainer.epoch, trainer.last, is_best)
+            session.timers["ckpt"] = time()  # reset timer
+
+
+def on_train_end(trainer):
+    """Upload final model and metrics to Ultralytics HUB at the end of training."""
+    if session := getattr(trainer, "hub_session", None):
+        # Upload final model and metrics with exponential backoff
+        LOGGER.info(f"{PREFIX}Syncing final model...")
+        session.upload_model(
+            trainer.epoch,
+            trainer.best,
+            map=trainer.metrics.get("metrics/mAP50-95(B)", 0),
+            final=True,
+        )
+        session.alive = False  # stop heartbeats
+        LOGGER.info(f"{PREFIX}Done ✅\n{PREFIX}View model at {session.model_url} 🚀")
+
+
+def on_train_start(trainer):
+    """Run events on train start."""
+    events(trainer.args, trainer.device)
+
+
+def on_val_start(validator):
+    """Run events on validation start."""
+    if not validator.training:
+        events(validator.args, validator.device)
+
+
+def on_predict_start(predictor):
+    """Run events on predict start."""
+    backend = getattr(getattr(predictor, "model", None), "backend", None)
+    events(predictor.args, predictor.device, backend=backend)
+
+
+def on_export_start(exporter):
+    """Run events on export start."""
+    events(exporter.args, exporter.device)
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_pretrain_routine_end": on_pretrain_routine_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_model_save": on_model_save,
+        "on_train_end": on_train_end,
+        "on_train_start": on_train_start,
+        "on_val_start": on_val_start,
+        "on_predict_start": on_predict_start,
+        "on_export_start": on_export_start,
+    }
+    if SETTINGS["hub"] is True
+    else {}
+)

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/mlflow.py

@@ -0,0 +1,162 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+"""
+MLflow Logging for Ultralytics YOLO.
+
+This module enables MLflow logging for Ultralytics YOLO. It logs metrics, parameters, and model artifacts.
+For setting up, a tracking URI should be specified. The logging can be customized using environment variables.
+
+Commands:
+    1. To set a project name:
+        `export MLFLOW_EXPERIMENT_NAME=<your_experiment_name>` or use the project=<project> argument
+
+    2. To set a run name:
+        `export MLFLOW_RUN=<your_run_name>` or use the name=<name> argument
+
+    3. To start a local MLflow server:
+        mlflow server --backend-store-uri runs/mlflow
+       It will by default start a local server at http://127.0.0.1:5000.
+       To specify a different URI, set the MLFLOW_TRACKING_URI environment variable.
+
+    4. To kill all running MLflow server instances:
+        ps aux | grep 'mlflow' | grep -v 'grep' | awk '{print $2}' | xargs kill -9
+"""
+
+import os
+from pathlib import Path
+
+from ultralytics.utils import LOGGER, RUNS_DIR, SETTINGS, TESTS_RUNNING, colorstr
+
+PREFIX = colorstr("MLflow: ")
+
+try:
+    import mlflow
+
+    assert hasattr(mlflow, "__version__")  # verify package is not a local directory
+except (ImportError, AssertionError):
+    mlflow = None
+
+
+def sanitize_dict(x: dict) -> dict:
+    """Sanitize dictionary keys by removing parentheses and converting values to floats."""
+    return {k.replace("(", "").replace(")", ""): float(v) for k, v in x.items()}
+
+
+def on_pretrain_routine_end(trainer):
+    """Log training parameters to MLflow at the end of the pretraining routine.
+
+    This function sets up MLflow logging based on environment variables and trainer arguments. It sets the tracking URI,
+    experiment name, and run name, then starts the MLflow run if not already active. It finally logs the parameters from
+    the trainer.
+
+    Args:
+        trainer (ultralytics.engine.trainer.BaseTrainer): The training object with arguments and parameters to log.
+
+    Notes:
+        MLFLOW_TRACKING_URI: The URI for MLflow tracking. If not set, defaults to 'runs/mlflow'.
+        MLFLOW_EXPERIMENT_NAME: The name of the MLflow experiment. If not set, defaults to trainer.args.project.
+        MLFLOW_RUN: The name of the MLflow run. If not set, defaults to trainer.args.name.
+        MLFLOW_KEEP_RUN_ACTIVE: Boolean indicating whether to keep the MLflow run active after training ends.
+    """
+    # Resolve enablement at call time (not import time) so test/training order can never permanently disable MLflow:
+    # `add_integration_callbacks` imports this module on the first training, which may run with mlflow off.
+    if not mlflow or SETTINGS["mlflow"] is not True:
+        return
+    if TESTS_RUNNING and "test_mlflow" not in os.environ.get("PYTEST_CURRENT_TEST", ""):
+        return  # do not log during unrelated pytest tests
+
+    uri = os.environ.get("MLFLOW_TRACKING_URI") or str(RUNS_DIR / "mlflow")
+    LOGGER.debug(f"{PREFIX} tracking uri: {uri}")
+
+    # Set experiment and run names
+    experiment_name = os.environ.get("MLFLOW_EXPERIMENT_NAME") or trainer.args.project or "/Shared/Ultralytics"
+    run_name = os.environ.get("MLFLOW_RUN") or trainer.args.name
+
+    trainer._mlflow_active = False
+    trainer._mlflow_started_run = False
+    try:
+        mlflow.set_tracking_uri(uri)
+        mlflow.set_experiment(experiment_name)
+        mlflow.autolog()
+        active_run = mlflow.active_run()
+        if active_run is None:
+            active_run = mlflow.start_run(run_name=run_name)
+            trainer._mlflow_started_run = True
+        LOGGER.info(f"{PREFIX}logging run_id({active_run.info.run_id}) to {uri}")
+        if Path(uri).is_dir():
+            LOGGER.info(f"{PREFIX}view at http://127.0.0.1:5000 with 'mlflow server --backend-store-uri {uri}'")
+        LOGGER.info(f"{PREFIX}disable with 'yolo settings mlflow=False'")
+        mlflow.log_params(dict(trainer.args))
+        trainer._mlflow_active = True
+    except Exception as e:
+        LOGGER.warning(f"{PREFIX}Failed to initialize: {e}")
+        LOGGER.warning(f"{PREFIX}Not tracking this run")
+        if trainer._mlflow_started_run:
+            try:
+                mlflow.end_run()
+            except Exception:
+                pass
+
+
+def _log_metrics(trainer, metrics):
+    """Log metrics to MLflow, disabling tracking for this run on failure so it never crashes training."""
+    try:
+        mlflow.log_metrics(metrics=metrics, step=trainer.epoch)
+    except Exception as e:
+        LOGGER.warning(f"{PREFIX}metric logging failed, disabling tracking for this run: {e}")
+        trainer._mlflow_active = False
+
+
+def on_train_epoch_end(trainer):
+    """Log training metrics at the end of each train epoch to MLflow."""
+    if mlflow and getattr(trainer, "_mlflow_active", False):
+        _log_metrics(
+            trainer,
+            {
+                **sanitize_dict(trainer.lr),
+                **sanitize_dict(trainer.label_loss_items(trainer.tloss, prefix="train")),
+            },
+        )
+
+
+def on_fit_epoch_end(trainer):
+    """Log training metrics at the end of each fit epoch to MLflow."""
+    if mlflow and getattr(trainer, "_mlflow_active", False):
+        _log_metrics(trainer, sanitize_dict(trainer.metrics))
+
+
+def on_train_end(trainer):
+    """Log model artifacts at the end of training and close any run this callback opened."""
+    if not mlflow:
+        return
+    if getattr(trainer, "_mlflow_active", False):
+        try:
+            mlflow.log_artifact(str(trainer.best.parent))  # log save_dir/weights directory with best.pt and last.pt
+            for f in trainer.save_dir.glob("*"):  # log all other files in save_dir
+                if f.suffix in {".png", ".jpg", ".csv", ".pt", ".yaml"}:
+                    mlflow.log_artifact(str(f))
+            LOGGER.info(
+                f"{PREFIX}results logged to {mlflow.get_tracking_uri()}\n{PREFIX}disable with 'yolo settings mlflow=False'"
+            )
+        except Exception as e:
+            LOGGER.warning(f"{PREFIX}failed to log artifacts: {e}")
+    if getattr(trainer, "_mlflow_started_run", False):  # only close a run we created
+        if os.environ.get("MLFLOW_KEEP_RUN_ACTIVE", "False").lower() == "true":
+            LOGGER.info(f"{PREFIX}mlflow run still alive, remember to close it using mlflow.end_run()")
+        else:
+            try:
+                mlflow.end_run()
+                LOGGER.debug(f"{PREFIX}mlflow run ended")
+            except Exception:
+                pass
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_end": on_pretrain_routine_end,
+        "on_train_epoch_end": on_train_epoch_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_train_end": on_train_end,
+    }
+    if mlflow
+    else {}
+)

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/neptune.py

@@ -0,0 +1,126 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from ultralytics.utils import LOGGER, SETTINGS, TESTS_RUNNING
+
+try:
+    assert not TESTS_RUNNING  # do not log pytest
+    assert SETTINGS["neptune"] is True  # verify integration is enabled
+
+    import neptune
+    from neptune.types import File
+
+    assert hasattr(neptune, "__version__")
+
+    run = None  # NeptuneAI experiment logger instance
+
+except (ImportError, AssertionError):
+    neptune = None
+
+
+def _log_scalars(scalars: dict, step: int = 0) -> None:
+    """Log scalars to the NeptuneAI experiment logger.
+
+    Args:
+        scalars (dict): Dictionary of scalar values to log to NeptuneAI.
+        step (int, optional): The current step or iteration number for logging.
+
+    Examples:
+        >>> metrics = {"mAP": 0.85, "loss": 0.32}
+        >>> _log_scalars(metrics, step=100)
+    """
+    if run:
+        for k, v in scalars.items():
+            run[k].append(value=v, step=step)
+
+
+def _log_images(imgs_dict: dict, group: str = "") -> None:
+    """Log images to the NeptuneAI experiment logger.
+
+    This function logs image data to Neptune.ai when a valid Neptune run is active. Images are organized under the
+    specified group name.
+
+    Args:
+        imgs_dict (dict): Dictionary of images to log, with keys as image names and values as image data.
+        group (str, optional): Group name to organize images under in the Neptune UI.
+
+    Examples:
+        >>> # Log validation images
+        >>> _log_images({"val_batch": img_tensor}, group="validation")
+    """
+    if run:
+        for k, v in imgs_dict.items():
+            run[f"{group}/{k}"].upload(File(v))
+
+
+def _log_plot(title: str, plot_path: str) -> None:
+    """Log plots to the NeptuneAI experiment logger."""
+    import matplotlib.image as mpimg
+    import matplotlib.pyplot as plt
+
+    img = mpimg.imread(plot_path)
+    fig = plt.figure()
+    ax = fig.add_axes([0, 0, 1, 1], frameon=False, aspect="auto", xticks=[], yticks=[])  # no ticks
+    ax.imshow(img)
+    run[f"Plots/{title}"].upload(fig)
+
+
+def on_pretrain_routine_start(trainer) -> None:
+    """Initialize NeptuneAI run and log hyperparameters before training starts."""
+    try:
+        global run
+        run = neptune.init_run(
+            project=trainer.args.project or "Ultralytics",
+            name=trainer.args.name,
+            tags=["Ultralytics"],
+        )
+        run["Configuration/Hyperparameters"] = {k: "" if v is None else v for k, v in vars(trainer.args).items()}
+    except Exception as e:
+        LOGGER.warning(f"NeptuneAI installed but not initialized correctly, not logging this run. {e}")
+
+
+def on_train_epoch_end(trainer) -> None:
+    """Log training metrics and learning rate at the end of each training epoch."""
+    _log_scalars(trainer.label_loss_items(trainer.tloss, prefix="train"), trainer.epoch + 1)
+    _log_scalars(trainer.lr, trainer.epoch + 1)
+    if trainer.epoch == 1:
+        _log_images({f.stem: str(f) for f in trainer.save_dir.glob("train_batch*.jpg")}, "Mosaic")
+
+
+def on_fit_epoch_end(trainer) -> None:
+    """Log model info and validation metrics at the end of each fit epoch."""
+    if run and trainer.epoch == 0:
+        from ultralytics.utils.torch_utils import model_info_for_loggers
+
+        run["Configuration/Model"] = model_info_for_loggers(trainer)
+    _log_scalars(trainer.metrics, trainer.epoch + 1)
+
+
+def on_val_end(validator) -> None:
+    """Log validation images at the end of validation."""
+    if run:
+        # Log val_labels and val_pred
+        _log_images({f.stem: str(f) for f in validator.save_dir.glob("val*.jpg")}, "Validation")
+
+
+def on_train_end(trainer) -> None:
+    """Log final results, plots, and model weights at the end of training."""
+    if run:
+        # Log final results, CM matrix + PR plots
+        for f in [*trainer.plots.keys(), *trainer.validator.plots.keys()]:
+            if "batch" not in f.name:
+                _log_plot(title=f.stem, plot_path=f)
+        # Log the final model
+        run[f"weights/{trainer.args.name or trainer.args.task}/{trainer.best.name}"].upload(File(str(trainer.best)))
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_train_epoch_end": on_train_epoch_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_val_end": on_val_end,
+        "on_train_end": on_train_end,
+    }
+    if neptune
+    else {}
+)

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/platform.py

@@ -0,0 +1,553 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import os
+import platform
+import re
+import socket
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from math import isfinite
+from pathlib import Path
+from time import sleep, time
+
+from ultralytics.utils import (
+    ENVIRONMENT,
+    GIT,
+    LOGGER,
+    PLATFORM_URL,
+    PYTHON_VERSION,
+    RANK,
+    SETTINGS,
+    TESTS_RUNNING,
+    Retry,
+    colorstr,
+)
+
+PREFIX = colorstr("Platform: ")
+PLATFORM_API_URL = f"{PLATFORM_URL}/api/webhooks"
+
+
+def slugify(text):
+    """Convert text to URL-safe slug (e.g., 'My Project 1' -> 'my-project-1')."""
+    if not text:
+        return text
+    return re.sub(r"-+", "-", re.sub(r"[^a-z0-9\s-]", "", str(text).lower()).replace(" ", "-")).strip("-")[:128]
+
+
+try:
+    assert not TESTS_RUNNING  # do not log pytest
+    assert SETTINGS.get("platform", False) is True or os.getenv("ULTRALYTICS_API_KEY") or SETTINGS.get("api_key")
+    _api_key = os.getenv("ULTRALYTICS_API_KEY") or SETTINGS.get("api_key")
+    assert _api_key  # verify API key is present
+
+    import requests
+
+    from ultralytics.utils.logger import ConsoleLogger, SystemLogger
+    from ultralytics.utils.torch_utils import model_info_for_loggers
+
+    _executor = ThreadPoolExecutor(max_workers=10)  # Bounded thread pool for async operations
+
+except (AssertionError, ImportError):
+    _api_key = None
+
+
+def resolve_platform_uri(uri, hard=True):
+    """Resolve ul:// URIs to signed URLs by authenticating with Ultralytics Platform.
+
+    Formats:
+        ul://username/datasets/slug  -> Returns signed URL to NDJSON file
+        ul://username/project/model  -> Returns signed URL to .pt file
+
+    Args:
+        uri (str): Platform URI starting with "ul://".
+        hard (bool): Whether to raise an error if resolution fails.
+
+    Returns:
+        (str | None): Signed URL on success, None if not found and hard=False.
+
+    Raises:
+        ValueError: If API key is missing/invalid or URI format is wrong.
+        PermissionError: If access is denied.
+        RuntimeError: If resource is not ready (e.g., dataset still processing).
+        FileNotFoundError: If resource not found and hard=True.
+        ConnectionError: If network request fails and hard=True.
+    """
+    import requests
+
+    path = uri[5:]  # Remove "ul://"
+    parts = path.split("/")
+
+    api_key = os.getenv("ULTRALYTICS_API_KEY") or SETTINGS.get("api_key")
+    if not api_key:
+        raise ValueError(f"ULTRALYTICS_API_KEY required for '{uri}'. Get key at {PLATFORM_URL}/settings")
+
+    base = PLATFORM_API_URL
+    headers = {"Authorization": f"Bearer {api_key}"}
+
+    # ul://username/datasets/slug
+    if len(parts) == 3 and parts[1] == "datasets":
+        username, _, slug = parts
+        url = f"{base}/datasets/{username}/{slug}/export"
+
+    # ul://username/project/model
+    elif len(parts) == 3:
+        username, project, model = parts
+        url = f"{base}/models/{username}/{project}/{model}/download"
+
+    else:
+        raise ValueError(f"Invalid platform URI: {uri}. Use ul://user/datasets/name or ul://user/project/model")
+
+    # (connect_timeout, read_timeout) — short connect so retries are fast, long read for server-side generation
+    timeout = (10, 3600) if "/datasets/" in url else (10, 90)
+
+    try:
+        for attempt in range(5):
+            try:
+                r = requests.head(url, headers=headers, allow_redirects=False, timeout=timeout)
+                if r.status_code in {408, 429} or r.status_code >= 500:
+                    raise requests.exceptions.HTTPError(f"HTTP {r.status_code}", response=r)
+                break
+            except (
+                requests.exceptions.ConnectionError,
+                requests.exceptions.ReadTimeout,
+                requests.exceptions.HTTPError,
+            ) as e:
+                if attempt >= 4:
+                    raise
+                delay = 2 * (2**attempt)  # 2s, 4s, 8s, 16s backoff
+                LOGGER.warning(f"Retry {attempt + 1}/5 for {uri} in {delay}s: {e}")
+                sleep(delay)
+    except Exception as e:
+        if hard:
+            raise ConnectionError(f"Failed to resolve {uri}: {e}") from e
+        LOGGER.warning(f"Failed to resolve {uri}: {e}")
+        return None
+
+    # Handle redirect responses (301, 302, 303, 307, 308)
+    if 300 <= r.status_code < 400 and "location" in r.headers:
+        return r.headers["location"]  # Return signed URL
+
+    # Handle error responses
+    if r.status_code == 401:
+        raise ValueError(f"Invalid ULTRALYTICS_API_KEY for '{uri}'")
+    if r.status_code == 403:
+        raise PermissionError(f"Access denied for '{uri}'. Check dataset/model visibility settings.")
+    if r.status_code == 404:
+        if hard:
+            raise FileNotFoundError(f"Not found on platform: {uri}")
+        LOGGER.warning(f"Not found on platform: {uri}")
+        return None
+    if r.status_code == 409:
+        raise RuntimeError(f"Resource not ready: {uri}. Dataset may still be processing.")
+
+    # Unexpected response
+    r.raise_for_status()
+    raise RuntimeError(f"Unexpected response from platform for '{uri}': {r.status_code}")
+
+
+def _interp_plot(plot, n=101):
+    """Interpolate plot curve data to n points to reduce storage size."""
+    import numpy as np
+
+    if not plot.get("x") or not plot.get("y"):
+        return plot  # No interpolation needed (e.g., confusion_matrix)
+
+    x, y = np.array(plot["x"]), np.array(plot["y"])
+    if len(x) <= n:
+        return plot  # Already small enough
+
+    # New x values (101 points gives clean 0.01 increments: 0, 0.01, 0.02, ..., 1.0)
+    x_new = np.linspace(x[0], x[-1], n)
+
+    # Interpolate y values (handle both 1D and 2D arrays)
+    if y.ndim == 1:
+        y_new = np.interp(x_new, x, y)
+    else:
+        y_new = np.array([np.interp(x_new, x, yi) for yi in y])
+
+    # Also interpolate ap if present (for PR curves)
+    result = {**plot, "x": x_new.tolist(), "y": y_new.tolist()}
+    if "ap" in plot:
+        result["ap"] = plot["ap"]  # Keep AP values as-is (per-class scalars)
+
+    return result
+
+
+def _sanitize_json_value(value):
+    """Replace non-finite floats in payloads with None so requests JSON encoding succeeds."""
+    if isinstance(value, dict):
+        return {k: _sanitize_json_value(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_sanitize_json_value(v) for v in value]
+    if isinstance(value, float):
+        return value if isfinite(value) else None  # avoid "Out of range float values are not JSON compliant" warnings
+    return value
+
+
+def _send(event, data, project, name, model_id=None, retry=2):
+    """Send event to Platform endpoint with retry logic."""
+    payload = {"event": event, "project": project, "name": name, "data": _sanitize_json_value(data)}
+    if model_id:
+        payload["modelId"] = model_id
+
+    @Retry(times=retry, delay=1)
+    def post():
+        r = requests.post(
+            f"{PLATFORM_API_URL}/training/metrics",
+            json=payload,
+            headers={"Authorization": f"Bearer {_api_key}"},
+            timeout=30,
+        )
+        if 400 <= r.status_code < 500 and r.status_code not in {408, 429}:
+            try:
+                msg = r.json().get("error", r.reason)
+            except Exception:
+                msg = r.reason
+            LOGGER.warning(f"{PREFIX}{msg}")
+            return None  # Don't retry client errors (except 408 timeout, 429 rate limit)
+        r.raise_for_status()
+        return r.json()
+
+    try:
+        return post()
+    except Exception as e:
+        LOGGER.debug(f"{PREFIX}Failed to send {event}: {e}")
+        return None
+
+
+def _send_async(event, data, project, name, model_id=None):
+    """Send event asynchronously using bounded thread pool."""
+    _executor.submit(_send, event, data, project, name, model_id)
+
+
+def _handle_control_response(trainer, ctx, response):
+    """Apply centralized stop signals returned by Platform webhook responses.
+
+    Notes:
+        ``ctx["cancelled"]`` is the durable cancellation signal. During startup, trainer setup later resets
+        ``trainer.stop``, so early stop requests still rely on ``on_pretrain_routine_end()`` to reapply the flag after
+        setup completes.
+    """
+    if response and response.get("cancelled"):
+        ctx["cancelled"] = True
+        trainer.stop = True
+        LOGGER.info(f"{PREFIX}Training cancelled from Platform ⚠️")
+
+
+def _upload_model(model_path, project, name, progress=False, retry=1, model_id=None):
+    """Upload model checkpoint to Platform via signed URL."""
+    from ultralytics.utils.uploads import safe_upload
+
+    model_path = Path(model_path)
+    if not model_path.exists():
+        LOGGER.warning(f"{PREFIX}Model file not found: {model_path}")
+        return None
+
+    # Get signed upload URL from Platform (server sanitizes filename for storage safety)
+    @Retry(times=3, delay=2)
+    def get_signed_url():
+        payload = {"project": project, "name": name, "filename": model_path.name}
+        if model_id:
+            payload["modelId"] = model_id  # Direct lookup avoids slug mismatch from auto-increment
+        r = requests.post(
+            f"{PLATFORM_API_URL}/models/upload",
+            json=payload,
+            headers={"Authorization": f"Bearer {_api_key}"},
+            timeout=30,
+        )
+        r.raise_for_status()
+        return r.json()
+
+    try:
+        data = get_signed_url()
+    except Exception as e:
+        LOGGER.warning(f"{PREFIX}Failed to get upload URL: {e}")
+        return None
+
+    # Upload to GCS using safe_upload with retry logic and optional progress bar
+    if safe_upload(file=model_path, url=data["uploadUrl"], retry=retry, progress=progress):
+        return data.get("gcsPath")
+    return None
+
+
+def _upload_model_async(model_path, project, name, model_id=None):
+    """Upload model asynchronously using bounded thread pool."""
+    _executor.submit(_upload_model, model_path, project, name, model_id=model_id)
+
+
+def _get_environment_info():
+    """Collect comprehensive environment info using existing ultralytics utilities."""
+    import shutil
+
+    import psutil
+    import torch
+
+    from ultralytics import __version__
+    from ultralytics.utils.torch_utils import get_cpu_info, get_gpu_info
+
+    # Get RAM and disk totals
+    memory = psutil.virtual_memory()
+    disk_usage = shutil.disk_usage("/")
+
+    env = {
+        "ultralyticsVersion": __version__,
+        "hostname": socket.gethostname(),
+        "os": platform.platform(),
+        "environment": ENVIRONMENT,
+        "pythonVersion": PYTHON_VERSION,
+        "pythonExecutable": sys.executable,
+        "cpuCount": os.cpu_count() or 0,
+        "cpu": get_cpu_info(),
+        "command": " ".join(sys.argv),
+        "totalRamGb": round(memory.total / (1 << 30), 1),  # Total RAM in GB
+        "totalDiskGb": round(disk_usage.total / (1 << 30), 1),  # Total disk in GB
+    }
+
+    # Git info using cached GIT singleton (no subprocess calls)
+    try:
+        if GIT.is_repo:
+            if GIT.origin:
+                env["gitRepository"] = GIT.origin
+            if GIT.branch:
+                env["gitBranch"] = GIT.branch
+            if GIT.commit:
+                env["gitCommit"] = GIT.commit[:12]  # Short hash
+            if GIT.message:
+                env["gitCommitMessage"] = GIT.message
+    except Exception:
+        pass
+
+    # GPU info
+    try:
+        if torch.cuda.is_available():
+            env["gpuCount"] = torch.cuda.device_count()
+            env["gpuType"] = get_gpu_info(0) if torch.cuda.device_count() > 0 else None
+    except Exception:
+        pass
+
+    return env
+
+
+def _get_project_name(trainer):
+    """Get slugified project and name from trainer args."""
+    raw = str(trainer.args.project)
+    parts = raw.split("/", 1)
+    project = f"{parts[0]}/{slugify(parts[1])}" if len(parts) == 2 else slugify(raw)
+    return project, slugify(str(trainer.args.name or "train"))
+
+
+def on_pretrain_routine_start(trainer):
+    """Initialize Platform logging at training start."""
+    if RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    project, name = _get_project_name(trainer)
+    LOGGER.info(f"{PREFIX}Streaming training metrics to Platform")
+
+    # Single dict for all platform callback state (like trainer.hub_session for HUB callbacks)
+    ctx = {"model_id": None, "last_upload": time(), "cancelled": False, "console_logger": None, "system_logger": None}
+    trainer.platform = ctx
+
+    # Create callback to send console output to Platform
+    def send_console_output(content, line_count, chunk_id):
+        """Send batched console output to Platform webhook."""
+        _send_async(
+            "console_output",
+            {"chunkId": chunk_id, "content": content, "lineCount": line_count},
+            project,
+            name,
+            ctx["model_id"],
+        )
+
+    # Start console capture with batching (5 lines or 5 seconds)
+    ctx["console_logger"] = ConsoleLogger(batch_size=5, flush_interval=5.0, on_flush=send_console_output)
+    ctx["console_logger"].start_capture()
+
+    # Collect environment info (W&B-style metadata)
+    environment = _get_environment_info()
+
+    # Build trainArgs - callback runs before get_dataset() so args.data is still original (e.g., ul:// URIs)
+    # Note: model_info is sent later in on_fit_epoch_end (epoch 0) when the model is actually loaded
+    train_args = {k: str(v) for k, v in vars(trainer.args).items()}
+
+    # Send synchronously to get modelId for subsequent webhooks (critical, more retries)
+    response = _send(
+        "training_started",
+        {
+            "trainArgs": train_args,
+            "epochs": trainer.epochs,
+            "device": str(trainer.device),
+            "environment": environment,
+        },
+        project,
+        name,
+        retry=4,
+    )
+    if response and response.get("modelId"):
+        ctx["model_id"] = response["modelId"]
+        # Server returns actual slug (may differ from requested name due to auto-increment, e.g. "train" → "train-2")
+        if response.get("modelSlug"):
+            ctx["model_slug"] = response["modelSlug"]
+            url = f"{PLATFORM_URL}/{project}/{ctx['model_slug']}"
+            LOGGER.info(f"{PREFIX}View model at {url}")
+        # Note: trainer.stop is set in on_pretrain_routine_end (after _setup_train resets it)
+        _handle_control_response(trainer, ctx, response)
+    else:
+        LOGGER.warning(f"{PREFIX}Training will not be tracked on Platform")
+        trainer.platform = None  # Disable further callbacks
+
+
+def on_pretrain_routine_end(trainer):
+    """Apply pre-start cancellation after _setup_train resets trainer.stop."""
+    ctx = getattr(trainer, "platform", None)
+    if ctx and ctx["cancelled"]:
+        LOGGER.info(f"{PREFIX}Training cancelled from Platform before starting ✅")
+        trainer.stop = True
+
+
+def on_fit_epoch_end(trainer):
+    """Log training and system metrics at epoch end."""
+    ctx = getattr(trainer, "platform", None)
+    if not ctx or RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    project, name = _get_project_name(trainer)
+    metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics}
+
+    if trainer.optimizer and trainer.optimizer.param_groups:
+        metrics["lr"] = trainer.optimizer.param_groups[0]["lr"]
+
+    # Extract model info at epoch 0 (sent as separate field, not in metrics)
+    model_info = None
+    if trainer.epoch == 0:
+        try:
+            info = model_info_for_loggers(trainer)
+            model_info = {
+                "parameters": info.get("model/parameters", 0),
+                "gflops": info.get("model/GFLOPs", 0),
+                "speedMs": info.get("model/speed_PyTorch(ms)", 0),
+            }
+        except Exception:
+            pass
+
+    # Get system metrics (cache SystemLogger in platform context for efficiency)
+    system = {}
+    try:
+        if not ctx["system_logger"]:
+            ctx["system_logger"] = SystemLogger(all_drives=True)
+        system = ctx["system_logger"].get_metrics(rates=True)
+    except Exception:
+        pass
+
+    payload = {
+        "epoch": trainer.epoch,
+        "metrics": metrics,
+        "system": system,
+        "fitness": trainer.fitness,
+        "best_fitness": trainer.best_fitness,
+    }
+    if model_info:
+        payload["modelInfo"] = model_info
+
+    def _send_and_check_cancel():
+        """Send epoch_end and check response for cancellation (runs in background thread)."""
+        response = _send("epoch_end", payload, project, name, ctx["model_id"], retry=1)
+        _handle_control_response(trainer, ctx, response)
+
+    _executor.submit(_send_and_check_cancel)
+
+
+def on_model_save(trainer):
+    """Upload model checkpoint (rate limited to every 15 min)."""
+    ctx = getattr(trainer, "platform", None)
+    if not ctx or RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    # Rate limit to every 15 minutes (900 seconds)
+    if time() - ctx["last_upload"] < 900:
+        return
+
+    model_path = trainer.best if trainer.best and Path(trainer.best).exists() else trainer.last
+    if not model_path:
+        return
+
+    project, name = _get_project_name(trainer)
+    _upload_model_async(model_path, project, name, model_id=ctx["model_id"])
+    ctx["last_upload"] = time()
+
+
+def on_train_end(trainer):
+    """Log final results, upload best model, and send validation plot data."""
+    ctx = getattr(trainer, "platform", None)
+    if not ctx or RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    project, name = _get_project_name(trainer)
+
+    if ctx["cancelled"]:
+        LOGGER.info(f"{PREFIX}Uploading partial results for cancelled training")
+
+    # Stop console capture
+    if ctx["console_logger"]:
+        ctx["console_logger"].stop_capture()
+        ctx["console_logger"] = None
+
+    # Upload best model (blocking with progress bar to ensure it completes)
+    gcs_path = None
+    model_size = None
+    if trainer.best and Path(trainer.best).exists():
+        model_size = Path(trainer.best).stat().st_size
+        gcs_path = _upload_model(trainer.best, project, name, progress=True, retry=3, model_id=ctx["model_id"])
+        if not gcs_path:
+            LOGGER.warning(f"{PREFIX}Model will not be available for download on Platform (upload failed)")
+
+    # Collect plots from trainer and validator, deduplicating by type
+    plots_by_type = {}
+    for info in getattr(trainer, "plots", {}).values():
+        if info.get("data") and info["data"].get("type"):
+            plots_by_type[info["data"]["type"]] = info["data"]
+    for info in getattr(getattr(trainer, "validator", None), "plots", {}).values():
+        if info.get("data") and info["data"].get("type"):
+            plots_by_type.setdefault(info["data"]["type"], info["data"])  # Don't overwrite trainer plots
+    plots = [_interp_plot(p) for p in plots_by_type.values()]  # Interpolate curves to reduce size
+
+    # Get class names
+    names = getattr(getattr(trainer, "validator", None), "names", None) or (trainer.data or {}).get("names")
+    class_names = list(names.values()) if isinstance(names, dict) else list(names) if names else None
+
+    # stopper.best_epoch is 1-indexed; -1 aligns with the 0-indexed `epoch` field
+    best_epoch = max(0, getattr(getattr(trainer, "stopper", None), "best_epoch", trainer.epoch + 1) - 1)
+
+    _send(
+        "training_complete",
+        {
+            "results": {
+                "metrics": {**trainer.metrics, "fitness": trainer.fitness},
+                "bestEpoch": best_epoch,
+                "bestFitness": trainer.best_fitness,
+                "modelPath": gcs_path,  # Only send GCS path, not local path
+                "modelSize": model_size,
+            },
+            "classNames": class_names,
+            "plots": plots,
+        },
+        project,
+        name,
+        ctx["model_id"],
+        retry=4,  # Critical, more retries
+    )
+    url = f"{PLATFORM_URL}/{project}/{ctx.get('model_slug', name)}"
+    LOGGER.info(f"{PREFIX}View results at {url}")
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_pretrain_routine_end": on_pretrain_routine_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_model_save": on_model_save,
+        "on_train_end": on_train_end,
+    }
+    if _api_key
+    else {}
+)

.venv/lib/python3.14/site-packages/ultralytics/utils/callbacks/raytune.py

@@ -0,0 +1,42 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from ultralytics.utils import SETTINGS
+
+try:
+    assert SETTINGS["raytune"] is True  # verify integration is enabled
+    import ray
+    from ray import tune
+    from ray.air import session
+
+except (ImportError, AssertionError):
+    tune = None
+
+
+def on_fit_epoch_end(trainer):
+    """Report training metrics to Ray Tune at epoch end when a Ray session is active.
+
+    Captures metrics from the trainer object and sends them to Ray Tune with the current epoch number, enabling
+    hyperparameter tuning optimization. Only executes when within an active Ray Tune session.
+
+    Args:
+        trainer (ultralytics.engine.trainer.BaseTrainer): The Ultralytics trainer object containing metrics and epochs.
+
+    Examples:
+        >>> # Called automatically by the Ultralytics training loop
+        >>> on_fit_epoch_end(trainer)
+
+    References:
+        Ray Tune docs: https://docs.ray.io/en/latest/tune/index.html
+    """
+    if ray.train._internal.session.get_session():  # check if Ray Tune session is active
+        metrics = trainer.metrics
+        session.report({**metrics, **{"epoch": trainer.epoch + 1}})
+
+
+callbacks = (
+    {
+        "on_fit_epoch_end": on_fit_epoch_end,
+    }
+    if tune
+    else {}
+)