RefDiffNet: standalone A11_CA prebackbone Gradio Space

Ship standalone a11_ca + prebackbone_infer (no ultralytics vendor),
Gradio 5.16.1 with gradio-client 1.7.0 patch, pre-aligned image pairs,
and prebackbone_a11_ca.pt weights.

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitignore

@@ -3,6 +3,7 @@ __pycache__/
 .gradio/
 *.log
 .DS_Store
+# Legacy vendored ultralytics (no longer used)
+vendor/
 # Full YOLO checkpoint optional locally; Space ships prebackbone_a11_ca.pt only
 weights/best.pt
-examples/

README.md

@@ -4,7 +4,7 @@ emoji: 🔬
 colorFrom: blue
 colorTo: green
 sdk: gradio
-sdk_version: "4.44.1"
+sdk_version: "5.16.1"
 python_version: "3.10"
 app_file: app.py
 pinned: false
@@ -15,12 +15,12 @@ license: agpl-3.0
 
 **Space:** [vinayedula/RefDiffNet](https://huggingface.co/spaces/vinayedula/RefDiffNet)
 
-Gradio demo for the **A11_CA** prebackbone trained with YOLO12n on HR-IPCB.
+Standalone Gradio demo for the **A11_CA** prebackbone (no Ultralytics at runtime).
 
 - **Inputs:** defect PCB image + golden reference image  
 - **Output:** enriched image (`enriched = defect + α · gate · delta`)
 
-Weights: `weights/prebackbone_a11_ca.pt` (~few MB, prebackbone only — not full `best.pt`)
+Weights: `weights/prebackbone_a11_ca.pt` (~few MB)
 
 ## Deploy to Hugging Face Spaces
 
@@ -35,45 +35,28 @@ bash hf_prebackbone_demo/prepare_space.sh
 
 This will:
 
-- Copy the custom **Ultralytics** fork into `hf_prebackbone_demo/vendor/`
-- Extract `prebackbone_a11_ca.pt` from `best.pt` (small file for the Space)
-- Copy example image pairs into `hf_prebackbone_demo/examples/`
+- Extract `prebackbone_a11_ca.pt` from `best.pt` (uses the VYOLO ultralytics fork **once** on your machine)
+- Copy example image pairs into `examples/`
+- Remove legacy `vendor/` if present
 
-### 2. Create a new Space on Hugging Face
-
-1. Go to [huggingface.co/new-space](https://huggingface.co/new-space)
-2. Choose **Gradio** SDK
-3. Clone the empty Space repo locally
-
-### 3. Push to [vinayedula/RefDiffNet](https://huggingface.co/spaces/vinayedula/RefDiffNet)
+### 2. Push to [vinayedula/RefDiffNet](https://huggingface.co/spaces/vinayedula/RefDiffNet)
 
 ```bash
 cd hf_prebackbone_demo
 bash deploy_to_refdiffnet.sh
 ```
 
-Or manually:
+> **Note:** The Space ships only `a11_ca.py`, `prebackbone_infer.py`, and `prebackbone_a11_ca.pt` — not the full ultralytics tree.
 
-```bash
-git clone https://huggingface.co/spaces/vinayedula/RefDiffNet
-cd RefDiffNet
-# copy app.py, vendor/, weights/prebackbone_a11_ca.pt, examples/, etc.
-git add . && git commit -m "RefDiffNet demo" && git push
-```
-
-> **Note:** `prebackbone_a11_ca.pt` is only a few MB (no LFS needed). Full `best.pt` is optional.
-
-### 4. Space settings (recommended)
+### 3. Space settings (recommended)
 
 | Setting | Value |
 |---------|--------|
-| Hardware | CPU Basic (works) or **GPU** for faster loads |
+| Hardware | CPU Basic (works) or **GPU** for faster inference |
 | Secrets | Optional: `HF_TOKEN` if weights are in a private model repo |
 
 ### Alternative: host weights on the Hub
 
-Upload `prebackbone_a11_ca.pt` to a model repo, then set:
-
 ```
 HF_MODEL_REPO=YOUR_USER/YOUR_MODEL
 ```
@@ -84,22 +67,40 @@ The app downloads `prebackbone_a11_ca.pt` from that repo.
 
 ```bash
 cd hf_prebackbone_demo
+# Clean broken Gradio 4.x + starlette 1.x mix if you hit jinja2 / localhost errors:
+pip uninstall -y gradio gradio-client starlette fastapi uvicorn 2>/dev/null || true
 pip install -r requirements.txt
-pip install -e ../ultralytics   # custom fork with A11_CA
-python extract_prebackbone_weights.py --ckpt /path/to/best.pt
+pip install --force-reinstall "numpy>=1.23.0,<2"
 export PREBACKBONE_ONLY_WEIGHTS=weights/prebackbone_a11_ca.pt
 python app.py
 ```
 
-Open http://localhost:7860
+Open **http://127.0.0.1:7860** (default bind). Remote server: `GRADIO_SERVER_NAME=0.0.0.0 python app.py` or SSH port-forward.
+
+### One-time weight extraction (from full `best.pt`)
+
+Only needed if you do not already have `prebackbone_a11_ca.pt`:
+
+```bash
+ULTRALYTICS_ROOT=../ultralytics python extract_prebackbone_weights.py \
+  --ckpt ../ultralytics/Proposed/yolo12_training/HRIPCB_Results/yolo12n_hripcb_200epochs_batch16/weights/best.pt
+```
+
+## Layout
+
+| File | Role |
+|------|------|
+| `a11_ca.py` | Standalone A11_CA module definition |
+| `prebackbone_infer.py` | Load weights, run enrichment (same H×W inputs) |
+| `gradio_patch.py` | Gradio 5.16 / client 1.7 compatibility patch |
+| `app.py` | Gradio UI |
+| `weights/prebackbone_a11_ca.pt` | Prebackbone weights only |
 
 ## Environment variables
 
 | Variable | Description |
 |----------|-------------|
 | `PREBACKBONE_ONLY_WEIGHTS` | Path to `prebackbone_a11_ca.pt` |
-| `PREBACKBONE_FULL_CKPT` | Full `best.pt` (only for one-time extraction) |
 | `HF_MODEL_REPO` | Hub repo with `prebackbone_a11_ca.pt` |
-| `PREBACKBONE_IMGSZ` | Letterbox size (default `640`) |
-| `ULTRALYTICS_ROOT` | Path to ultralytics repo if not vendored |
+| `PREBACKBONE_DEVICE` | `cpu` or `cuda` (default: auto) |
 | `PORT` | Gradio port (default `7860`) |

a11_ca.py

@@ -0,0 +1,213 @@
+"""Standalone A11_CA prebackbone (defect + golden reference -> enriched image)."""
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+__all__ = [
+    "ConvBNAct",
+    "LocalContrastNorm",
+    "FixedHaarBands",
+    "EncoderAttentionCoordStem2d",
+    "A11CoordinateEncoderAttentionPreBackbone",
+    "build_prebackbone",
+]
+
+
+class ConvBNAct(nn.Module):
+    def __init__(
+        self,
+        c1: int,
+        c2: int,
+        k: int = 3,
+        s: int = 1,
+        p: int | None = None,
+        groups: int = 1,
+        act: bool = True,
+    ):
+        super().__init__()
+        if p is None:
+            p = k // 2
+        self.conv = nn.Conv2d(c1, c2, k, s, p, groups=groups, bias=False)
+        self.bn = nn.BatchNorm2d(c2)
+        self.act = nn.SiLU(inplace=True) if act else nn.Identity()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.act(self.bn(self.conv(x)))
+
+
+class LocalContrastNorm(nn.Module):
+    """Lightweight no-parameter local contrast normalization."""
+
+    def __init__(self, kernel_size: int = 7, eps: float = 1e-4):
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.eps = eps
+        self.pad = kernel_size // 2
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        mean = F.avg_pool2d(x, self.kernel_size, stride=1, padding=self.pad)
+        var = F.avg_pool2d((x - mean) ** 2, self.kernel_size, stride=1, padding=self.pad)
+        return (x - mean) / torch.sqrt(var + self.eps)
+
+
+class FixedHaarBands(nn.Module):
+    """Fixed Haar wavelet decomposition at 1/2 resolution (LL, LH, HL, HH per channel)."""
+
+    def __init__(self, channels: int = 3):
+        super().__init__()
+        self.channels = channels
+
+        ll = torch.tensor([[1, 1], [1, 1]], dtype=torch.float32) / 2.0
+        lh = torch.tensor([[-1, -1], [1, 1]], dtype=torch.float32) / 2.0
+        hl = torch.tensor([[-1, 1], [-1, 1]], dtype=torch.float32) / 2.0
+        hh = torch.tensor([[1, -1], [-1, 1]], dtype=torch.float32) / 2.0
+
+        weight = torch.stack([ll, lh, hl, hh], dim=0).view(4, 1, 2, 2)
+        weight = weight.repeat(channels, 1, 1, 1)
+        self.register_buffer("weight", weight)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return F.conv2d(x, self.weight, stride=2, padding=0, groups=self.channels)
+
+
+class EncoderAttentionCoordStem2d(nn.Module):
+    """H/W pooled coordinate modulation; returns feat * attn_h * attn_w."""
+
+    def __init__(self, hidden: int) -> None:
+        super().__init__()
+        ch = max(hidden // 8, 8)
+        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
+        self.pool_w = nn.AdaptiveAvgPool2d((1, None))
+        self.conv1 = nn.Conv2d(hidden, ch, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(ch)
+        self.act = nn.SiLU(inplace=True)
+        self.conv_h = nn.Conv2d(ch, hidden, kernel_size=1, bias=True)
+        self.conv_w = nn.Conv2d(ch, hidden, kernel_size=1, bias=True)
+
+    def forward(self, feat: torch.Tensor) -> torch.Tensor:
+        _, _, h, w = feat.shape
+        xh = self.pool_h(feat)
+        xw = self.pool_w(feat).permute(0, 1, 3, 2)
+        coord = torch.cat([xh, xw], dim=2)
+        coord = self.act(self.bn1(self.conv1(coord)))
+        ah, aw = torch.split(coord, [h, w], dim=2)
+        aw = aw.permute(0, 1, 3, 2)
+        mh = torch.sigmoid(self.conv_h(ah))
+        mw = torch.sigmoid(self.conv_w(aw))
+        return feat * mh * mw
+
+
+class A11CoordinateEncoderAttentionPreBackbone(nn.Module):
+    """
+    A11_CA: defect + golden -> enriched = defect + alpha * gate * delta.
+
+    Cues: Haar bands, signed low-res residual, morphology; encoder + channel/spatial gates.
+    """
+
+    def __init__(
+        self,
+        channels: int = 3,
+        hidden: int = 24,
+        use_lcn: bool = True,
+        alpha_init: float = 0.08,
+    ):
+        super().__init__()
+        self.channels = channels
+        self.hidden = hidden
+
+        self.lcn = LocalContrastNorm(kernel_size=7) if use_lcn else nn.Identity()
+        self.haar = FixedHaarBands(channels=channels)
+
+        in_ch = channels * 12
+        self.encoder = nn.Sequential(
+            ConvBNAct(in_ch, hidden, k=1, s=1),
+            ConvBNAct(hidden, hidden, k=3, s=1, groups=hidden),
+            ConvBNAct(hidden, hidden, k=1, s=1),
+            ConvBNAct(hidden, hidden, k=3, s=1, groups=hidden),
+            ConvBNAct(hidden, hidden, k=1, s=1),
+        )
+
+        gate_hidden = max(hidden // 8, 4)
+        self.channel_gate = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),
+            nn.Conv2d(hidden, gate_hidden, kernel_size=1, bias=True),
+            nn.SiLU(inplace=True),
+            nn.Conv2d(gate_hidden, hidden, kernel_size=1, bias=True),
+            nn.Sigmoid(),
+        )
+
+        self.rgb_delta = nn.Sequential(
+            ConvBNAct(hidden, hidden, k=1, s=1),
+            nn.Conv2d(hidden, channels, kernel_size=1, bias=True),
+            nn.Tanh(),
+        )
+
+        self.spatial_gate_replacement = nn.Sequential(
+            EncoderAttentionCoordStem2d(hidden),
+            nn.Conv2d(hidden, 1, kernel_size=1, bias=True),
+            nn.Sigmoid(),
+        )
+
+        self.alpha = nn.Parameter(torch.tensor(float(alpha_init)))
+
+    def forward(self, defect: torch.Tensor, golden: torch.Tensor) -> torch.Tensor:
+        if defect.shape != golden.shape:
+            raise ValueError(
+                f"A11_CA expects same shape for defect and golden tensors, "
+                f"got {tuple(defect.shape)} vs {tuple(golden.shape)}"
+            )
+
+        defect_n = self.lcn(defect)
+        golden_n = self.lcn(golden)
+
+        bd = self.haar(defect_n)
+        bg = self.haar(golden_n)
+
+        defect_lr = F.avg_pool2d(defect_n, kernel_size=2, stride=2)
+        golden_lr = F.avg_pool2d(golden_n, kernel_size=2, stride=2)
+        signed_lr = defect_lr - golden_lr
+        pos_lr = F.relu(signed_lr)
+        neg_lr = F.relu(-signed_lr)
+        morph_pos = F.max_pool2d(pos_lr, kernel_size=3, stride=1, padding=1)
+        morph_neg = F.max_pool2d(neg_lr, kernel_size=3, stride=1, padding=1)
+
+        x = torch.cat([bd, bg, pos_lr, neg_lr, morph_pos, morph_neg], dim=1)
+
+        feat = self.encoder(x)
+        feat = feat * self.channel_gate(feat)
+
+        delta_lr = self.rgb_delta(feat)
+        gate_lr = self.spatial_gate_replacement(feat)
+
+        gate = F.interpolate(gate_lr, size=defect.shape[2:], mode="bilinear", align_corners=False)
+        delta = F.interpolate(delta_lr, size=defect.shape[2:], mode="bilinear", align_corners=False)
+        enriched = defect + self.alpha * gate * delta
+
+        self._debug = {
+            "defect": defect.detach(),
+            "golden": golden.detach(),
+            "gate": gate.detach(),
+            "delta": delta.detach(),
+            "alpha": float(self.alpha.detach().item()),
+            "enriched": enriched.detach(),
+        }
+
+        return enriched
+
+
+_REGISTRY: dict[str, type[nn.Module]] = {
+    "A11_CA": A11CoordinateEncoderAttentionPreBackbone,
+}
+
+
+def build_prebackbone(name: str | None, channels: int = 3, **kwargs) -> nn.Module | None:
+    if not name:
+        return None
+    key = str(name).upper()
+    if key not in _REGISTRY:
+        supported = ", ".join(sorted(_REGISTRY))
+        raise ValueError(f"Unsupported prebackbone '{name}'. Supported: {supported}")
+    return _REGISTRY[key](channels=channels, **kwargs)

app.py

@@ -3,10 +3,32 @@
 from __future__ import annotations
 
 import os
+import socket
+from pathlib import Path
 
-# Hugging Face Spaces: required before importing gradio
-os.environ.setdefault("GRADIO_SERVER_NAME", "0.0.0.0")
-os.environ.setdefault("GRADIO_SERVER_PORT", os.environ.get("PORT", "7860"))
+_ROOT = Path(__file__).resolve().parent
+
+
+def _is_hf_space() -> bool:
+    return bool(os.environ.get("SPACE_ID") or os.environ.get("SYSTEM") == "spaces")
+
+
+def _configure_runtime() -> None:
+    os.environ.setdefault("GRADIO_SERVER_PORT", os.environ.get("PORT", "7860"))
+    os.environ.setdefault(
+        "PREBACKBONE_ONLY_WEIGHTS",
+        str(_ROOT / "weights" / "prebackbone_a11_ca.pt"),
+    )
+    if _is_hf_space():
+        os.environ.setdefault("PRELOAD_MODEL", "1")
+        os.environ.setdefault("GRADIO_SERVER_NAME", "0.0.0.0")
+
+
+_configure_runtime()
+
+import gradio_patch
+
+gradio_patch.apply()
 
 import gradio as gr
 import numpy as np
@@ -16,7 +38,7 @@ from prebackbone_infer import enrich_pair, get_enricher
 
 TITLE = "RefDiffNet — PCB Reference–Defect Enrichment"
 DESCRIPTION = """
-Upload a **defect PCB image** and its **golden reference** (same board, no defect).
+Upload a **defect PCB image** and its **golden reference** (same H×W, pre-aligned — e.g. `*_input.jpg` / `*_reference.jpg` from training).
 The A11_CA prebackbone outputs an **enriched** image: `enriched = defect + α · gate · delta`
 """
 
@@ -26,6 +48,9 @@ def run_demo(defect_path: str | None, reference_path: str | None):
         raise gr.Error("Please upload both defect and reference images.")
 
     defect_rgb, ref_rgb, enriched_rgb = enrich_pair(defect_path, reference_path)
+    defect_rgb = np.array(defect_rgb, dtype=np.uint8, copy=True)
+    ref_rgb = np.array(ref_rgb, dtype=np.uint8, copy=True)
+    enriched_rgb = np.array(enriched_rgb, dtype=np.uint8, copy=True)
 
     h = max(defect_rgb.shape[0], ref_rgb.shape[0], enriched_rgb.shape[0])
 
@@ -39,7 +64,19 @@ def run_demo(defect_path: str | None, reference_path: str | None):
     return Image.fromarray(enriched_rgb), Image.fromarray(row)
 
 
-def _preload_model():
+def _example_pairs() -> list[list[str]]:
+    pairs: list[list[str]] = []
+    ex_dir = _ROOT / "examples"
+    if not ex_dir.is_dir():
+        return pairs
+    for inp in sorted(ex_dir.glob("*_input.jpg")):
+        ref = inp.with_name(inp.name.replace("_input.", "_reference."))
+        if ref.is_file():
+            pairs.append([str(inp), str(ref)])
+    return pairs
+
+
+def _preload_model() -> None:
     try:
         get_enricher()
         print("[RefDiffNet] Prebackbone loaded.")
@@ -47,27 +84,69 @@ def _preload_model():
         print(f"[RefDiffNet] WARN: {e}")
 
 
+def build_demo() -> gr.Blocks:
+    with gr.Blocks(title=TITLE) as demo:
+        gr.Markdown(DESCRIPTION.strip())
+        with gr.Row():
+            defect_in = gr.Image(type="filepath", label="Defect image (input)")
+            ref_in = gr.Image(type="filepath", label="Golden reference")
+        run_btn = gr.Button("Run enrichment", variant="primary")
+        with gr.Row():
+            out_enriched = gr.Image(type="pil", label="Enriched output")
+            out_row = gr.Image(type="pil", label="Defect | Reference | Enriched")
+        run_btn.click(run_demo, inputs=[defect_in, ref_in], outputs=[out_enriched, out_row])
+
+        examples = _example_pairs()
+        if examples:
+            gr.Examples(
+                examples=examples,
+                inputs=[defect_in, ref_in],
+                examples_per_page=3,
+                label="Example pairs (pre-aligned HR-IPCB samples)",
+            )
+    return demo
+
+
+demo = build_demo()
+
+
+def _launch_kwargs() -> dict:
+    if _is_hf_space():
+        return {
+            "server_name": "0.0.0.0",
+            "server_port": int(os.environ.get("PORT", "7860")),
+            "share": False,
+        }
+    server_name = os.environ.get("GRADIO_SERVER_NAME", "127.0.0.1")
+    preferred_port = int(os.environ.get("PORT", os.environ.get("GRADIO_SERVER_PORT", "7860")))
+    bind_host = "127.0.0.1" if server_name in ("127.0.0.1", "localhost") else server_name
+    server_port = preferred_port
+    if server_name in ("127.0.0.1", "localhost"):
+        for port in range(preferred_port, preferred_port + 20):
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                try:
+                    sock.bind((bind_host, port))
+                    server_port = port
+                    break
+                except OSError:
+                    continue
+    share = os.environ.get("GRADIO_SHARE", "").lower() in ("1", "true", "yes")
+    return {
+        "server_name": server_name,
+        "server_port": server_port,
+        "share": share,
+    }
+
+
 if __name__ == "__main__":
-    _preload_model()
-
-    demo = gr.Interface(
-        fn=run_demo,
-        inputs=[
-            gr.Image(type="filepath", label="Defect image (input)"),
-            gr.Image(type="filepath", label="Golden reference"),
-        ],
-        outputs=[
-            gr.Image(type="pil", label="Enriched output"),
-            gr.Image(type="pil", label="Defect | Reference | Enriched"),
-        ],
-        title=TITLE,
-        description=DESCRIPTION,
-        allow_flagging="never",
-    )
+    print(f"[RefDiffNet] gradio {getattr(gr, '__version__', 'unknown')}")
+    if os.environ.get("PRELOAD_MODEL", "0").lower() in ("1", "true", "yes"):
+        _preload_model()
 
     demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(os.environ.get("PORT", "7860")),
-        share=False,
+        **(_launch_kwargs()),
         show_error=True,
+        inbrowser=False,
+        prevent_thread_lock=False,
     )

deploy_to_refdiffnet.sh

@@ -6,7 +6,7 @@ cd "$(dirname "$0")"
 SPACE_REMOTE="${SPACE_REMOTE:-https://huggingface.co/spaces/vinayedula/RefDiffNet}"
 
 if [[ ! -f weights/prebackbone_a11_ca.pt ]]; then
-  echo "Run: python extract_prebackbone_weights.py --ckpt /path/to/best.pt"
+  echo "Run: bash prepare_space.sh   (or extract_prebackbone_weights.py)"
   exit 1
 fi
 
@@ -15,7 +15,9 @@ git lfs install 2>/dev/null || true
 
 git add \
   app.py \
+  a11_ca.py \
   prebackbone_infer.py \
+  gradio_patch.py \
   extract_prebackbone_weights.py \
   deploy_to_refdiffnet.sh \
   prepare_space.sh \
@@ -24,13 +26,11 @@ git add \
   README.md \
   .gitattributes \
   .gitignore \
-  vendor/ \
   examples/ \
   weights/prebackbone_a11_ca.pt
 
-# Commit only if there are staged changes
 if ! git diff --cached --quiet; then
-  git commit -m "RefDiffNet: A11_CA prebackbone enrichment demo"
+  git commit -m "RefDiffNet: standalone A11_CA prebackbone demo"
 elif ! git rev-parse HEAD >/dev/null 2>&1; then
   echo "ERROR: No commit to push. Check git add / files."
   exit 1
@@ -38,7 +38,6 @@ else
   echo "No new changes; pushing existing commit."
 fi
 
-# HF Spaces use 'main' (git init often creates 'master')
 git branch -M main
 
 if git remote get-url origin &>/dev/null; then

extract_prebackbone_weights.py

@@ -1,20 +1,18 @@
 #!/usr/bin/env python3
-"""One-time: extract prebackbone weights from a full YOLO best.pt checkpoint."""
+"""Extract prebackbone-only weights from a full YOLO best.pt checkpoint."""
 
 from __future__ import annotations
 
 import argparse
+import os
 import sys
 from pathlib import Path
 
 import torch
 
-# Allow running before vendor is installed
+from a11_ca import build_prebackbone
+
 _HERE = Path(__file__).resolve().parent
-for base in (_HERE / "vendor", _HERE.parent / "ultralytics"):
-    if (base / "ultralytics" / "__init__.py").exists():
-        sys.path.insert(0, str(base))
-        break
 
 
 def _clean_state_dict(state: dict) -> dict:
@@ -23,26 +21,73 @@ def _clean_state_dict(state: dict) -> dict:
     return {k: v for k, v in state.items() if not any(k == s or k.endswith(f".{s}") for s in skip)}
 
 
+def _resolve_ultralytics_root() -> Path | None:
+    env = os.environ.get("ULTRALYTICS_ROOT", "").strip()
+    candidates = []
+    if env:
+        candidates.append(Path(env).expanduser())
+    candidates.extend((_HERE.parent / "ultralytics", _HERE / "vendor"))
+    for base in candidates:
+        if (base / "ultralytics" / "__init__.py").exists():
+            return base
+        if base.name == "ultralytics" and (base / "__init__.py").exists():
+            return base.parent
+    return None
+
+
+def _load_full_checkpoint(full_ckpt: Path) -> tuple[dict, object]:
+    """Load best.pt; uses VYOLO ultralytics fork when present (pickled EMA model)."""
+    root = _resolve_ultralytics_root()
+    if root is not None:
+        root_str = str(root.resolve())
+        if root_str not in sys.path:
+            sys.path.insert(0, root_str)
+        from ultralytics.nn.tasks import torch_safe_load
+
+        ckpt, _ = torch_safe_load(str(full_ckpt))
+        return ckpt, ckpt.get("ema") or ckpt.get("model")
+
+    raise SystemExit(
+        f"Cannot unpickle {full_ckpt} without the VYOLO ultralytics fork.\n"
+        "One-time extraction from the training repo:\n"
+        "  cd /path/to/VYOLO/hf_prebackbone_demo\n"
+        "  ULTRALYTICS_ROOT=../ultralytics python extract_prebackbone_weights.py --ckpt ../ultralytics/.../best.pt\n"
+        "Inference only needs weights/prebackbone_a11_ca.pt (no ultralytics)."
+    )
+
+
 def extract(
     full_ckpt: Path,
     out_path: Path,
     prebackbone_name: str | None = None,
 ) -> Path:
-    from ultralytics.nn.tasks import torch_safe_load
+    ckpt, model = _load_full_checkpoint(full_ckpt)
+    if model is None:
+        raise RuntimeError(f"No model/ema in {full_ckpt}")
 
-    ckpt, _ = torch_safe_load(str(full_ckpt))
     train_args = ckpt.get("train_args") or {}
     name = (prebackbone_name or train_args.get("prebackbone") or "A11_CA").upper()
     channels = int(train_args.get("channels", 3) or 3)
 
-    model = (ckpt.get("ema") or ckpt.get("model")).float()
     pb = getattr(model, "prebackbone", None)
     if pb is None:
-        raise RuntimeError(f"No prebackbone in {full_ckpt}")
+        raise RuntimeError(f"No prebackbone submodule in {full_ckpt}")
 
     state = _clean_state_dict(pb.state_dict())
 
-    # Save only tensors + metadata (no YOLO backbone/head)
+    # Verify keys match standalone architecture before saving
+    standalone = build_prebackbone(name, channels=channels)
+    if standalone is None:
+        raise RuntimeError(f"Unsupported prebackbone type: {name}")
+    expected = set(standalone.state_dict().keys())
+    got = set(state.keys())
+    if expected != got:
+        missing = expected - got
+        extra = got - expected
+        raise RuntimeError(
+            f"State dict mismatch for {name}: missing={sorted(missing)[:5]}, extra={sorted(extra)[:5]}"
+        )
+
     payload = {
         "prebackbone": name,
         "channels": channels,
@@ -52,7 +97,7 @@ def extract(
     out_path.parent.mkdir(parents=True, exist_ok=True)
     torch.save(payload, out_path)
 
-    n_params = sum(t.numel() for t in payload["state_dict"].values())
+    n_params = sum(t.numel() for t in state.values())
     size_mb = out_path.stat().st_size / (1024 * 1024)
     print(f"Saved {out_path} ({size_mb:.2f} MB, {n_params:,} parameters, type={name})")
     return out_path

gradio_patch.py

@@ -0,0 +1,32 @@
+"""Patch gradio_client JSON-schema helpers (bool additionalProperties with pydantic v2)."""
+
+from __future__ import annotations
+
+
+def apply() -> None:
+    try:
+        import gradio_client.utils as gc_utils
+    except ImportError:
+        return
+
+    if getattr(gc_utils, "_refdiffnet_patched", False):
+        return
+
+    _orig_get_type = gc_utils.get_type
+
+    def get_type(schema):  # type: ignore[no-untyped-def]
+        if not isinstance(schema, dict):
+            return "Any"
+        return _orig_get_type(schema)
+
+    gc_utils.get_type = get_type  # type: ignore[assignment]
+
+    _orig_json = gc_utils._json_schema_to_python_type
+
+    def _json_schema_to_python_type(schema, defs):  # type: ignore[no-untyped-def]
+        if not isinstance(schema, dict):
+            return "Any"
+        return _orig_json(schema, defs)
+
+    gc_utils._json_schema_to_python_type = _json_schema_to_python_type  # type: ignore[assignment]
+    gc_utils._refdiffnet_patched = True  # type: ignore[attr-defined]

prebackbone_infer.py

@@ -1,4 +1,4 @@
-"""Prebackbone enrichment inference (A11_CA) — loads prebackbone weights only."""
+"""Prebackbone enrichment inference (A11_CA) — standalone, no ultralytics."""
 
 from __future__ import annotations
 
@@ -6,39 +6,27 @@ import os
 from pathlib import Path
 from typing import Any
 
-import cv2
 import numpy as np
 import torch
 from PIL import Image
 
-IMGSZ = int(os.environ.get("PREBACKBONE_IMGSZ", "640"))
-PREBACKBONE_ONLY_NAME = "prebackbone_a11_ca.pt"
-
-
-def _resolve_ultralytics_root() -> Path | None:
-    here = Path(__file__).resolve().parent
-    for base in (
-        here / "vendor",
-        here.parent / "ultralytics",
-        Path(os.environ.get("ULTRALYTICS_ROOT", "")).expanduser(),
-    ):
-        if not base:
-            continue
-        if (base / "ultralytics" / "__init__.py").exists():
-            return base
-        if base.name == "ultralytics" and (base / "__init__.py").exists():
-            return base.parent
-    return None
+from a11_ca import build_prebackbone
 
+PREBACKBONE_ONLY_NAME = "prebackbone_a11_ca.pt"
 
-def _ensure_ultralytics_import() -> None:
-    import sys
 
-    root = _resolve_ultralytics_root()
-    if root is not None:
-        root_str = str(root.resolve())
-        if root_str not in sys.path:
-            sys.path.insert(0, root_str)
+def _to_numpy_u8(arr) -> np.ndarray:
+    """Canonical uint8 HWC in conda numpy (avoids ~/.local numpy vs torch/opencv)."""
+    if isinstance(arr, Image.Image):
+        arr = arr.convert("RGB")
+        w, h = arr.size
+        return np.frombuffer(arr.tobytes(), dtype=np.uint8).reshape((h, w, 3)).copy()
+    raw = np.asarray(arr)
+    if raw.ndim == 2:
+        raw = np.stack([raw, raw, raw], axis=-1)
+    elif raw.shape[-1] > 3:
+        raw = raw[..., :3]
+    return np.array(raw.tolist(), dtype=np.uint8, order="C")
 
 
 def _here() -> Path:
@@ -53,7 +41,6 @@ def _prebackbone_only_path() -> Path:
 
 
 def _full_checkpoint_path() -> Path | None:
-    """Fallback full YOLO ckpt — only used to auto-extract prebackbone weights."""
     env = os.environ.get("PREBACKBONE_FULL_CKPT", "").strip()
     if env:
         p = Path(env).expanduser()
@@ -83,7 +70,6 @@ def _download_hf_file(repo_id: str, filename: str) -> Path:
 
 
 def _resolve_weights_path() -> Path:
-    """Prefer small prebackbone-only file; optional HF hub download."""
     pb_only = _prebackbone_only_path()
     if pb_only.exists():
         return pb_only
@@ -93,7 +79,7 @@ def _resolve_weights_path() -> Path:
         try:
             return _download_hf_file(hf_repo, PREBACKBONE_ONLY_NAME)
         except Exception:
-            pass  # try full ckpt filename below
+            pass
         env_weights = os.environ.get("PREBACKBONE_WEIGHTS", PREBACKBONE_ONLY_NAME)
         return _download_hf_file(hf_repo, env_weights)
 
@@ -105,7 +91,6 @@ def _resolve_weights_path() -> Path:
 
 
 def _maybe_extract_from_full_ckpt(pb_only_path: Path) -> Path:
-    """If only best.pt exists, extract prebackbone tensors once."""
     if pb_only_path.exists():
         return pb_only_path
     full = _full_checkpoint_path()
@@ -118,7 +103,6 @@ def _maybe_extract_from_full_ckpt(pb_only_path: Path) -> Path:
 
 
 def _filter_state_dict(state: dict, module: torch.nn.Module) -> dict:
-    """Keep only keys that belong to the module (drops thop total_ops/total_params)."""
     expected = set(module.state_dict().keys())
     filtered = {k: v for k, v in state.items() if k in expected}
     if len(filtered) < len(expected):
@@ -128,9 +112,6 @@ def _filter_state_dict(state: dict, module: torch.nn.Module) -> dict:
 
 
 def _load_prebackbone_module(weights_path: Path, device: torch.device) -> torch.nn.Module:
-    _ensure_ultralytics_import()
-    from ultralytics.nn.prebackbone import build_prebackbone
-
     if not weights_path.exists():
         weights_path = _maybe_extract_from_full_ckpt(weights_path)
 
@@ -163,79 +144,46 @@ def _load_prebackbone_module(weights_path: Path, device: torch.device) -> torch.
     return module.to(device).eval()
 
 
-def _bgr_to_rgb(im_bgr: np.ndarray) -> np.ndarray:
-    return cv2.cvtColor(im_bgr, cv2.COLOR_BGR2RGB)
-
-
-def _rgb_to_bgr(im_rgb: np.ndarray) -> np.ndarray:
-    return cv2.cvtColor(im_rgb, cv2.COLOR_RGB2BGR)
-
-
-def _letterbox_pair_bgr(
-    defect_bgr: np.ndarray,
-    golden_bgr: np.ndarray,
-    new_shape: tuple[int, int] = (IMGSZ, IMGSZ),
-) -> tuple[np.ndarray, np.ndarray]:
-    shape = defect_bgr.shape[:2]
-    if golden_bgr.shape[:2] != shape:
-        golden_bgr = cv2.resize(golden_bgr, (shape[1], shape[0]), interpolation=cv2.INTER_LINEAR)
-
-    new_h, new_w = new_shape
-    r = min(new_h / shape[0], new_w / shape[1])
-    new_unpad = (round(shape[1] * r), round(shape[0] * r))
-    dw, dh = (new_w - new_unpad[0]) / 2, (new_h - new_unpad[1]) / 2
-
-    if shape[::-1] != new_unpad:
-        defect_bgr = cv2.resize(defect_bgr, new_unpad, interpolation=cv2.INTER_LINEAR)
-        golden_bgr = cv2.resize(golden_bgr, new_unpad, interpolation=cv2.INTER_LINEAR)
-
-    top, bottom = round(dh - 0.1), round(dh + 0.1)
-    left, right = round(dw - 0.1), round(dw + 0.1)
-    pad = (114, 114, 114)
-    defect_bgr = cv2.copyMakeBorder(defect_bgr, top, bottom, left, right, cv2.BORDER_CONSTANT, value=pad)
-    golden_bgr = cv2.copyMakeBorder(golden_bgr, top, bottom, left, right, cv2.BORDER_CONSTANT, value=pad)
-    return defect_bgr, golden_bgr
-
-
-def _img_to_tensor_rgb(im_rgb: np.ndarray, device: torch.device) -> torch.Tensor:
-    x = torch.from_numpy(im_rgb).to(device=device)
-    return x.permute(2, 0, 1).contiguous().float().unsqueeze(0) / 255.0
-
-
-def _tensor_to_rgb_u8(x: torch.Tensor) -> np.ndarray:
-    if x.ndim == 4:
-        x = x[0]
-    x = x.detach().float().clamp(0.0, 1.0).cpu()
-    return (x.permute(1, 2, 0).numpy() * 255.0).round().astype(np.uint8)
-
-
 def _load_image_rgb(image: str | Path | Image.Image | np.ndarray) -> np.ndarray:
     if isinstance(image, Image.Image):
-        return np.array(image.convert("RGB"))
+        return _to_numpy_u8(image.convert("RGB"))
     if isinstance(image, np.ndarray):
         arr = image
         if arr.ndim == 2:
-            return np.stack([arr, arr, arr], axis=-1)
+            return _to_numpy_u8(np.stack([arr, arr, arr], axis=-1))
         if arr.shape[2] == 4:
-            return arr[..., :3]
-        return arr[..., :3] if arr.shape[2] >= 3 else arr
+            return _to_numpy_u8(arr[..., :3])
+        return _to_numpy_u8(arr[..., :3] if arr.shape[2] >= 3 else arr)
     path = Path(image)
-    bgr = cv2.imread(str(path))
-    if bgr is None:
+    if not path.exists():
         raise FileNotFoundError(f"Unable to read image: {path}")
-    return _bgr_to_rgb(bgr)
+    return _to_numpy_u8(Image.open(path).convert("RGB"))
+
+
+def _img_to_tensor_rgb(im_rgb: np.ndarray, device: torch.device) -> torch.Tensor:
+    arr = np.ascontiguousarray(_to_numpy_u8(im_rgb), dtype=np.uint8)
+    x = torch.tensor(arr, device=device, dtype=torch.float32)
+    return x.permute(2, 0, 1).contiguous().unsqueeze(0) / 255.0
+
+
+def _tensor_to_rgb_u8(x: torch.Tensor) -> np.ndarray:
+    if x.ndim == 4:
+        x = x[0]
+    hwc = x.detach().float().clamp(0.0, 1.0).mul(255.0).round().byte().permute(1, 2, 0).cpu()
+    return np.array(hwc.tolist(), dtype=np.uint8)
 
 
 class PreBackboneEnricher:
-    """Runs A11_CA prebackbone only (no YOLO backbone/head loaded)."""
+    """Runs A11_CA prebackbone only (defect + golden -> enriched, same spatial size)."""
 
     def __init__(self, weights: str | Path | None = None, device: str | None = None):
         if device is None:
-            device = "cuda" if torch.cuda.is_available() else "cpu"
+            device = os.environ.get("PREBACKBONE_DEVICE") or (
+                "cuda" if torch.cuda.is_available() else "cpu"
+            )
         self.device = torch.device(device)
         self.weights = Path(weights) if weights else _resolve_weights_path()
         self.prebackbone = _load_prebackbone_module(self.weights, self.device)
-        self.imgsz = IMGSZ
 
     @torch.inference_mode()
     def enrich(
@@ -243,26 +191,17 @@ class PreBackboneEnricher:
         defect: str | Path | Image.Image | np.ndarray,
         reference: str | Path | Image.Image | np.ndarray,
         *,
-        letterbox: bool = True,
         return_reference: bool = False,
     ) -> np.ndarray | tuple[np.ndarray, np.ndarray, np.ndarray]:
-        defect_rgb0 = _load_image_rgb(defect)
-        golden_rgb0 = _load_image_rgb(reference)
-
-        defect_bgr0 = _rgb_to_bgr(defect_rgb0)
-        golden_bgr0 = _rgb_to_bgr(golden_rgb0)
-
-        if letterbox:
-            defect_bgr, golden_bgr = _letterbox_pair_bgr(defect_bgr0, golden_bgr0, (self.imgsz, self.imgsz))
-        else:
-            if defect_bgr0.shape != golden_bgr0.shape:
-                golden_bgr0 = cv2.resize(
-                    golden_bgr0, (defect_bgr0.shape[1], defect_bgr0.shape[0]), interpolation=cv2.INTER_LINEAR
-                )
-            defect_bgr, golden_bgr = defect_bgr0, golden_bgr0
-
-        defect_rgb = _bgr_to_rgb(defect_bgr)
-        golden_rgb = _bgr_to_rgb(golden_bgr)
+        defect_rgb = _load_image_rgb(defect)
+        golden_rgb = _load_image_rgb(reference)
+
+        if defect_rgb.shape != golden_rgb.shape:
+            raise ValueError(
+                f"Defect and reference must have the same shape (HxWxC), "
+                f"got {defect_rgb.shape} vs {golden_rgb.shape}. "
+                "Use pre-aligned pairs (e.g. training prebackbone_samples) with no extra resizing."
+            )
 
         defect_t = _img_to_tensor_rgb(defect_rgb, self.device)
         golden_t = _img_to_tensor_rgb(golden_rgb, self.device)

prepare_space.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+# Bundle weights + examples for Hugging Face Space upload (standalone, no vendor/).
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+VYOLO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+ULTRA_SRC="${VYOLO_ROOT}/ultralytics"
+SPACE_DIR="${SCRIPT_DIR}"
+WEIGHTS_SRC="${ULTRA_SRC}/Proposed/yolo12_training/HRIPCB_Results/yolo12n_hripcb_200epochs_batch16/weights/best.pt"
+SAMPLES_SRC="${ULTRA_SRC}/Proposed/yolo12_training/HRIPCB_Results/yolo12n_hripcb_200epochs_batch16/prebackbone_samples"
+
+echo "==> Preparing Hugging Face Space in ${SPACE_DIR}"
+
+# 1) Weights — extract prebackbone-only (~few MB) from best.pt
+mkdir -p "${SPACE_DIR}/weights"
+PB_ONLY="${SPACE_DIR}/weights/prebackbone_a11_ca.pt"
+if [[ -f "${WEIGHTS_SRC}" ]]; then
+  PYTHON="${PYTHON:-python3}"
+  if "${PYTHON}" -c "import torch" 2>/dev/null; then
+    export ULTRALYTICS_ROOT="${ULTRA_SRC}"
+    (cd "${SPACE_DIR}" && "${PYTHON}" extract_prebackbone_weights.py --ckpt "${WEIGHTS_SRC}" --out "${PB_ONLY}")
+    echo "    Prebackbone-only weights: $(du -h "${PB_ONLY}" | cut -f1)"
+    if [[ "${INCLUDE_FULL_CKPT:-0}" == "1" ]]; then
+      cp -f "${WEIGHTS_SRC}" "${SPACE_DIR}/weights/best.pt"
+      echo "    Also copied full best.pt (optional fallback)"
+    fi
+  else
+    echo "    WARN: torch not available — place prebackbone_a11_ca.pt in weights/ manually"
+  fi
+else
+  echo "    WARN: ${WEIGHTS_SRC} not found — place prebackbone_a11_ca.pt in weights/"
+fi
+
+# 2) Example pairs for Gradio Examples
+EX_DIR="${SPACE_DIR}/examples"
+rm -rf "${EX_DIR}"
+mkdir -p "${EX_DIR}"
+EPOCH070="${SAMPLES_SRC}/epoch_070"
+if [[ -d "${EPOCH070}" ]]; then
+  for inp in "${EPOCH070}"/*_input.jpg; do
+    [[ -f "${inp}" ]] || continue
+    base="$(basename "${inp}")"
+    ref="${inp/_input./_reference.}"
+    if [[ -f "${ref}" ]]; then
+      cp -f "${inp}" "${EX_DIR}/${base}"
+      cp -f "${ref}" "${EX_DIR}/${base/_input./_reference.}"
+    fi
+  done
+fi
+if [[ -d "${SAMPLES_SRC}" ]]; then
+  mapfile -t _inputs < <(find "${SAMPLES_SRC}" -name '*_input.jpg' | head -6)
+  for inp in "${_inputs[@]}"; do
+    base="$(basename "${inp}")"
+    [[ -f "${EX_DIR}/${base}" ]] && continue
+    ref="${inp/_input./_reference.}"
+    if [[ -f "${ref}" ]]; then
+      cp -f "${inp}" "${EX_DIR}/${base}"
+      cp -f "${ref}" "${EX_DIR}/${base/_input./_reference.}"
+    fi
+  done
+  unset _inputs
+fi
+if compgen -G "${EX_DIR}/*_input.jpg" >/dev/null; then
+  echo "    Examples: $(ls -1 "${EX_DIR}"/*_input.jpg | wc -l) pairs"
+else
+  echo "    WARN: no prebackbone_samples found for examples"
+fi
+
+# 3) Drop legacy vendored ultralytics if present
+if [[ -d "${SPACE_DIR}/vendor" ]]; then
+  rm -rf "${SPACE_DIR}/vendor"
+  echo "    Removed legacy vendor/ (standalone demo)"
+fi
+
+TOTAL="$(du -sh "${SPACE_DIR}" | cut -f1)"
+echo "==> Done (total ${TOTAL}). Next:"
+echo "    cd ${SPACE_DIR}"
+echo "    git init && git lfs install && git lfs track '*.pt'"
+echo "    git add . && git commit -m 'RefDiffNet standalone demo'"
+echo "    git remote add origin https://huggingface.co/spaces/USER/SPACE"
+echo "    git push"

requirements.txt

@@ -1,16 +1,11 @@
-# Gradio version is set by README sdk_version on Hugging Face Spaces (4.44.0)
+# Gradio version matches README sdk_version (Hugging Face Spaces)
 # Python 3.13+ removed stdlib audioop; pydub (gradio dep) needs this backport
 audioop-lts>=0.2.1; python_version >= "3.13"
 torch>=2.0.0
 torchvision>=0.15.0
-opencv-python-headless>=4.8.0
-pillow>=10.0.0
-numpy>=1.23.0
-pyyaml>=6.0
-# Gradio 4.44 needs HfFolder (removed in huggingface_hub 1.x)
+pillow>=10.0.0,<11
+# torch 2.2.x wheels are built against NumPy 1.x
+numpy>=1.23.0,<2
+gradio==5.16.1
+gradio-client==1.7.0
 huggingface_hub>=0.23.0,<1.0
-matplotlib>=3.7.0
-scipy>=1.10.0
-psutil>=5.9.0
-polars>=0.20.0
-ultralytics-thop>=2.0.18

setup.sh

@@ -1,18 +1,12 @@
 #!/usr/bin/env bash
-# Hugging Face Spaces: install vendored custom Ultralytics before app starts.
+# Hugging Face Spaces: install deps before app starts (no ultralytics).
 set -euo pipefail
 cd "$(dirname "$0")"
-# HF base image may install huggingface_hub 1.x; Gradio 4.x needs <1.0 (HfFolder)
-pip install -q "huggingface_hub>=0.23.0,<1.0"
-# Fix Gradio 4.44.0 + pydantic schema bug (TypeError: bool is not iterable)
-pip install -q "gradio-client>=1.4.0,<2.0.0"
-export YOLO_CONFIG_DIR="${YOLO_CONFIG_DIR:-/tmp/Ultralytics}"
+pip install -q -r requirements.txt
+pip install -q "numpy>=1.23.0,<2" "gradio-client==1.7.0"
+python -c "import gradio_patch; gradio_patch.apply(); print('gradio_patch OK')"
 export GRADIO_SERVER_NAME="${GRADIO_SERVER_NAME:-0.0.0.0}"
-mkdir -p "${YOLO_CONFIG_DIR}"
-
-if [[ -d vendor ]]; then
-  pip install -q -e ./vendor
-  echo "Installed custom ultralytics from ./vendor"
-else
-  echo "WARN: vendor/ missing — run prepare_space.sh before deploying"
-fi
+export GRADIO_SERVER_PORT="${GRADIO_SERVER_PORT:-${PORT:-7860}}"
+export PRELOAD_MODEL="${PRELOAD_MODEL:-1}"
+export PREBACKBONE_ONLY_WEIGHTS="${PREBACKBONE_ONLY_WEIGHTS:-$(pwd)/weights/prebackbone_a11_ca.pt}"
+echo "RefDiffNet: standalone A11_CA (GRADIO_SERVER_NAME=${GRADIO_SERVER_NAME})"

vendor/pyproject.toml

@@ -1,194 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# Overview:
-# This pyproject.toml file manages the build, packaging, and distribution of the Ultralytics library.
-# It defines essential project metadata, dependencies, and settings used to develop and deploy the library.
-
-# Key Sections:
-# - [build-system]: Specifies the build requirements and backend (e.g., setuptools, wheel).
-# - [project]: Includes details like name, version, description, authors, dependencies and more.
-# - [project.optional-dependencies]: Provides additional, optional packages for extended features.
-# - [tool.*]: Configures settings for various tools (pytest, yapf, etc.) used in the project.
-
-# Installation:
-# The Ultralytics library can be installed using the command: 'pip install ultralytics'
-# For development purposes, you can install the package in editable mode with: 'pip install -e .'
-# This approach allows for real-time code modifications without the need for re-installation.
-
-# Documentation:
-# For comprehensive documentation and usage instructions, visit: https://docs.ultralytics.com
-
-[build-system]
-requires = ["setuptools>=70.0.0,<=82.0.1", "wheel"]
-build-backend = "setuptools.build_meta"
-
-# Project settings -----------------------------------------------------------------------------------------------------
-[project]
-name = "ultralytics"
-dynamic = ["version"]
-description = "Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification."
-readme = "README.md"
-requires-python = ">=3.8"
-license = { "text" = "AGPL-3.0" }
-keywords = ["machine-learning", "deep-learning", "computer-vision", "ML", "DL", "AI", "YOLO", "YOLOv3", "YOLOv5", "YOLOv8", "YOLOv9", "YOLOv10", "YOLO11", "HUB", "Ultralytics"]
-authors = [
-    { name = "Glenn Jocher", email = "glenn.jocher@ultralytics.com" },
-    { name = "Jing Qiu", email = "jing.qiu@ultralytics.com" },
-]
-maintainers = [
-    { name = "Ultralytics", email = "hello@ultralytics.com" },
-]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "Intended Audience :: Education",
-    "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Topic :: Software Development",
-    "Topic :: Scientific/Engineering",
-    "Topic :: Scientific/Engineering :: Artificial Intelligence",
-    "Topic :: Scientific/Engineering :: Image Recognition",
-    "Operating System :: POSIX :: Linux",
-    "Operating System :: MacOS",
-    "Operating System :: Microsoft :: Windows",
-]
-
-# Required dependencies ------------------------------------------------------------------------------------------------
-dependencies = [
-    "numpy>=1.23.0",
-    "matplotlib>=3.3.0",
-    "opencv-python>=4.6.0",
-    "pillow>=7.1.2",
-    "pyyaml>=5.3.1",
-    "requests>=2.23.0",
-    "scipy>=1.4.1",
-    "torch>=1.8.0",
-    "torch>=1.8.0,!=2.4.0; sys_platform == 'win32'", # Windows CPU errors w/ 2.4.0 https://github.com/ultralytics/ultralytics/issues/15049
-    "torchvision>=0.9.0",
-    "psutil>=5.8.0", # system utilization
-    "polars>=0.20.0",
-    "ultralytics-thop>=2.0.18", # FLOPs computation https://github.com/ultralytics/thop
-]
-
-# Optional dependencies ------------------------------------------------------------------------------------------------
-[project.optional-dependencies]
-dev = [
-    "ipython",
-    "pytest",
-    "pytest-cov",
-    "coverage[toml]",
-    "zensical>=0.0.15; python_version >= '3.10'",
-    "mkdocs-ultralytics-plugin>=0.2.4", # for meta descriptions and images, dates and authors
-    "minijinja>=2.0.0", # render docs macros without mkdocs-macros-plugin
-]
-export = [
-    "numpy<2.0.0", # TF 2.20 compatibility
-    "onnx>=1.12.0; platform_system != 'Darwin'", # ONNX export
-    "onnx>=1.12.0,<1.18.0; platform_system == 'Darwin'",  # TF inference hanging on MacOS (tested up to onnx==1.20.0)
-    "onnxslim>=0.1.82",
-    "coremltools>=9.0; platform_system != 'Windows' and python_version <= '3.13'", # CoreML supported on macOS and Linux
-    "scikit-learn>=1.3.2; platform_system != 'Windows' and python_version <= '3.13'", # CoreML k-means quantization
-    "openvino>=2024.0.0",  # OpenVINO export
-    "tensorflow>=2.0.0,<=2.19.0", # TF bug https://github.com/ultralytics/ultralytics/issues/5161
-    "tensorflowjs>=2.0.0", # TF.js export, automatically installs tensorflow
-    "tensorstore>=0.1.63; platform_machine == 'aarch64' and python_version >= '3.9'", # for TF Raspberry Pi exports
-    "h5py!=3.11.0; platform_machine == 'aarch64'", # fix h5py build issues due to missing aarch64 wheels in 3.11 release
-    "setuptools<=81.0.0",  # pin due to >=82.0.0 breaking tensorflow.js package
-    "packaging>=26.0; platform_machine == 'aarch64' and platform_system == 'Linux' and python_version >= '3.9'", # IMX export bug
-]
-solutions = [
-    "shapely>=2.0.0",    # shapely for point and polygon data matching
-    "streamlit>=1.51.0; python_version >= '3.10'",    # for live inference on web browser, i.e `yolo streamlit-predict`
-    "streamlit>=1.29.0,<1.51.0; python_version < '3.10' and (python_version < '3.9' or platform_machine != 'aarch64' or platform_system != 'Linux')",
-    "flask>=3.0.1",  # for similarity search solution
-]
-logging = [
-    "wandb", # https://docs.ultralytics.com/integrations/weights-biases/
-    "tensorboard",  # https://docs.ultralytics.com/integrations/tensorboard/
-    "mlflow",  # https://docs.ultralytics.com/integrations/mlflow/
-]
-extra = [
-    "ipython", # interactive notebook
-    "albumentations>=1.4.6", # training augmentations
-    "faster-coco-eval>=1.6.7", # COCO mAP
-]
-typing = [
-    "scipy-stubs>=1.14.1.4; python_version >= '3.10'",
-    "types-pillow",
-    "types-psutil",
-    "types-pyyaml",
-    "types-requests",
-    "types-shapely",
-]
-
-[project.urls]
-"Homepage" = "https://ultralytics.com"
-"Source" = "https://github.com/ultralytics/ultralytics"
-"Documentation" = "https://docs.ultralytics.com"
-"Bug Reports" = "https://github.com/ultralytics/ultralytics/issues"
-"Changelog" = "https://github.com/ultralytics/ultralytics/releases"
-
-[project.scripts]
-yolo = "ultralytics.cfg:entrypoint"
-ultralytics = "ultralytics.cfg:entrypoint"
-
-# Tools settings -------------------------------------------------------------------------------------------------------
-[tool.setuptools]  # configuration specific to the `setuptools` build backend.
-packages = { find = { where = ["."], include = ["ultralytics", "ultralytics.*"] } }
-# Tests included below for checking Conda builds in https://github.com/conda-forge/ultralytics-feedstock
-package-data = { "ultralytics" = ["**/*.yaml", "**/*.sh", "../tests/*.py"], "ultralytics.assets" = ["*.jpg"], "ultralytics.solutions.templates" = ["*.html"]}
-
-[tool.setuptools.dynamic]
-version = { attr = "ultralytics.__version__" }
-
-[tool.pytest.ini_options]
-addopts = "--doctest-modules --durations=30 --color=yes"
-markers = [
-    "slow: skip slow tests unless --slow is set",
-]
-norecursedirs = [".git", "dist", "build"]
-
-[tool.coverage.run]
-source = ["ultralytics/"]
-data_file = "tests/.coverage"
-omit = ["ultralytics/utils/callbacks/*"]
-
-[tool.isort]
-line_length = 120
-multi_line_output = 0
-
-[tool.yapf]
-based_on_style = "pep8"
-spaces_before_comment = 2
-column_limit = 120
-coalesce_brackets = true
-spaces_around_power_operator = true
-space_between_ending_comma_and_closing_bracket = true
-split_before_closing_bracket = false
-split_before_first_argument = false
-
-[tool.ruff]
-line-length = 120
-
-[tool.ruff.format]
-docstring-code-format = true
-
-[tool.ruff.lint.pydocstyle]
-convention = "google"
-
-[tool.docformatter]
-wrap-summaries = 120
-wrap-descriptions = 120
-pre-summary-newline = true
-close-quotes-on-newline = true
-in-place = true
-
-[tool.codespell]
-ignore-words-list = "grey,writeable,finalY,RepResNet,Idenfy,WIT,Smoot,EHR,ROUGE,ALS,iTerm,Carmel,FPR,Hach,Calle,ore,COO,MOT,crate,nd,ned,strack,dota,ane,segway,fo,gool,winn,commend,bloc,nam,afterall,skelton,goin"
-skip = "*.pt,*.pth,*.torchscript,*.onnx,*.tflite,*.pb,*.bin,*.param,*.mlmodel,*.engine,*.npy,*.data*,*.csv,*pnnx*,*venv*,*translat*,*lock*,__pycache__*,*.ico,*.jpg,*.png,*.webp,*.avif,*.mp4,*.mov,/runs,/.git,./docs/??/*.md,./docs/mkdocs_??.yml"

vendor/ultralytics.egg-info/PKG-INFO

@@ -1,88 +0,0 @@
-Metadata-Version: 2.4
-Name: ultralytics
-Version: 8.4.21
-Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
-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,YOLO,YOLOv3,YOLOv5,YOLOv8,YOLOv9,YOLOv10,YOLO11,HUB,Ultralytics
-Classifier: Development Status :: 4 - Beta
-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: 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
-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: scipy>=1.4.1
-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: 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: 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
-Requires-Dist: numpy<2.0.0; extra == "export"
-Requires-Dist: onnx>=1.12.0; platform_system != "Darwin" and extra == "export"
-Requires-Dist: onnx<1.18.0,>=1.12.0; platform_system == "Darwin" and extra == "export"
-Requires-Dist: onnxslim>=0.1.82; extra == "export"
-Requires-Dist: coremltools>=9.0; (platform_system != "Windows" and python_version <= "3.13") and extra == "export"
-Requires-Dist: scikit-learn>=1.3.2; (platform_system != "Windows" and python_version <= "3.13") and extra == "export"
-Requires-Dist: openvino>=2024.0.0; extra == "export"
-Requires-Dist: tensorflow<=2.19.0,>=2.0.0; extra == "export"
-Requires-Dist: tensorflowjs>=2.0.0; extra == "export"
-Requires-Dist: tensorstore>=0.1.63; (platform_machine == "aarch64" and python_version >= "3.9") and extra == "export"
-Requires-Dist: h5py!=3.11.0; platform_machine == "aarch64" and extra == "export"
-Requires-Dist: setuptools<=81.0.0; extra == "export"
-Requires-Dist: packaging>=26.0; (platform_machine == "aarch64" and platform_system == "Linux" and python_version >= "3.9") and extra == "export"
-Provides-Extra: solutions
-Requires-Dist: shapely>=2.0.0; 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 (python_version < "3.9" or 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: scipy-stubs>=1.14.1.4; python_version >= "3.10" and 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"

vendor/ultralytics.egg-info/SOURCES.txt

@@ -1,308 +0,0 @@
-pyproject.toml
-ultralytics/__init__.py
-ultralytics/py.typed
-ultralytics.egg-info/PKG-INFO
-ultralytics.egg-info/SOURCES.txt
-ultralytics.egg-info/dependency_links.txt
-ultralytics.egg-info/entry_points.txt
-ultralytics.egg-info/requires.txt
-ultralytics.egg-info/top_level.txt
-ultralytics/assets/bus.jpg
-ultralytics/assets/zidane.jpg
-ultralytics/cfg/__init__.py
-ultralytics/cfg/default.yaml
-ultralytics/cfg/datasets/Argoverse.yaml
-ultralytics/cfg/datasets/DOTAv1.5.yaml
-ultralytics/cfg/datasets/DOTAv1.yaml
-ultralytics/cfg/datasets/GlobalWheat2020.yaml
-ultralytics/cfg/datasets/HomeObjects-3K.yaml
-ultralytics/cfg/datasets/ImageNet.yaml
-ultralytics/cfg/datasets/Objects365.yaml
-ultralytics/cfg/datasets/SKU-110K.yaml
-ultralytics/cfg/datasets/TT100K.yaml
-ultralytics/cfg/datasets/VOC.yaml
-ultralytics/cfg/datasets/VisDrone.yaml
-ultralytics/cfg/datasets/african-wildlife.yaml
-ultralytics/cfg/datasets/brain-tumor.yaml
-ultralytics/cfg/datasets/carparts-seg.yaml
-ultralytics/cfg/datasets/coco-pose.yaml
-ultralytics/cfg/datasets/coco.yaml
-ultralytics/cfg/datasets/coco12-formats.yaml
-ultralytics/cfg/datasets/coco128-seg.yaml
-ultralytics/cfg/datasets/coco128.yaml
-ultralytics/cfg/datasets/coco8-grayscale.yaml
-ultralytics/cfg/datasets/coco8-multispectral.yaml
-ultralytics/cfg/datasets/coco8-pose.yaml
-ultralytics/cfg/datasets/coco8-seg.yaml
-ultralytics/cfg/datasets/coco8.yaml
-ultralytics/cfg/datasets/construction-ppe.yaml
-ultralytics/cfg/datasets/crack-seg.yaml
-ultralytics/cfg/datasets/dog-pose.yaml
-ultralytics/cfg/datasets/dota8-multispectral.yaml
-ultralytics/cfg/datasets/dota8.yaml
-ultralytics/cfg/datasets/hand-keypoints.yaml
-ultralytics/cfg/datasets/kitti.yaml
-ultralytics/cfg/datasets/lvis.yaml
-ultralytics/cfg/datasets/medical-pills.yaml
-ultralytics/cfg/datasets/open-images-v7.yaml
-ultralytics/cfg/datasets/package-seg.yaml
-ultralytics/cfg/datasets/signature.yaml
-ultralytics/cfg/datasets/tiger-pose.yaml
-ultralytics/cfg/datasets/xView.yaml
-ultralytics/cfg/models/11/yolo11-cls-resnet18.yaml
-ultralytics/cfg/models/11/yolo11-cls.yaml
-ultralytics/cfg/models/11/yolo11-obb.yaml
-ultralytics/cfg/models/11/yolo11-pose.yaml
-ultralytics/cfg/models/11/yolo11-seg.yaml
-ultralytics/cfg/models/11/yolo11.yaml
-ultralytics/cfg/models/11/yoloe-11-seg.yaml
-ultralytics/cfg/models/11/yoloe-11.yaml
-ultralytics/cfg/models/12/yolo12-cls.yaml
-ultralytics/cfg/models/12/yolo12-obb.yaml
-ultralytics/cfg/models/12/yolo12-pose.yaml
-ultralytics/cfg/models/12/yolo12-seg.yaml
-ultralytics/cfg/models/12/yolo12.yaml
-ultralytics/cfg/models/26/yolo26-cls.yaml
-ultralytics/cfg/models/26/yolo26-obb.yaml
-ultralytics/cfg/models/26/yolo26-p2.yaml
-ultralytics/cfg/models/26/yolo26-p6.yaml
-ultralytics/cfg/models/26/yolo26-pose.yaml
-ultralytics/cfg/models/26/yolo26-seg.yaml
-ultralytics/cfg/models/26/yolo26.yaml
-ultralytics/cfg/models/26/yoloe-26-seg.yaml
-ultralytics/cfg/models/26/yoloe-26.yaml
-ultralytics/cfg/models/rt-detr/rtdetr-l.yaml
-ultralytics/cfg/models/rt-detr/rtdetr-resnet101.yaml
-ultralytics/cfg/models/rt-detr/rtdetr-resnet50.yaml
-ultralytics/cfg/models/rt-detr/rtdetr-x.yaml
-ultralytics/cfg/models/v10/yolov10b.yaml
-ultralytics/cfg/models/v10/yolov10l.yaml
-ultralytics/cfg/models/v10/yolov10m.yaml
-ultralytics/cfg/models/v10/yolov10n.yaml
-ultralytics/cfg/models/v10/yolov10s.yaml
-ultralytics/cfg/models/v10/yolov10x.yaml
-ultralytics/cfg/models/v3/yolov3-spp.yaml
-ultralytics/cfg/models/v3/yolov3-tiny.yaml
-ultralytics/cfg/models/v3/yolov3.yaml
-ultralytics/cfg/models/v5/yolov5-p6.yaml
-ultralytics/cfg/models/v5/yolov5.yaml
-ultralytics/cfg/models/v6/yolov6.yaml
-ultralytics/cfg/models/v8/yoloe-v8-seg.yaml
-ultralytics/cfg/models/v8/yoloe-v8.yaml
-ultralytics/cfg/models/v8/yolov8-cls-resnet101.yaml
-ultralytics/cfg/models/v8/yolov8-cls-resnet50.yaml
-ultralytics/cfg/models/v8/yolov8-cls.yaml
-ultralytics/cfg/models/v8/yolov8-ghost-p2.yaml
-ultralytics/cfg/models/v8/yolov8-ghost-p6.yaml
-ultralytics/cfg/models/v8/yolov8-ghost.yaml
-ultralytics/cfg/models/v8/yolov8-obb.yaml
-ultralytics/cfg/models/v8/yolov8-p2.yaml
-ultralytics/cfg/models/v8/yolov8-p6.yaml
-ultralytics/cfg/models/v8/yolov8-pose-p6.yaml
-ultralytics/cfg/models/v8/yolov8-pose.yaml
-ultralytics/cfg/models/v8/yolov8-rtdetr.yaml
-ultralytics/cfg/models/v8/yolov8-seg-p6.yaml
-ultralytics/cfg/models/v8/yolov8-seg.yaml
-ultralytics/cfg/models/v8/yolov8-world.yaml
-ultralytics/cfg/models/v8/yolov8-worldv2.yaml
-ultralytics/cfg/models/v8/yolov8.yaml
-ultralytics/cfg/models/v9/yolov9c-seg.yaml
-ultralytics/cfg/models/v9/yolov9c.yaml
-ultralytics/cfg/models/v9/yolov9e-seg.yaml
-ultralytics/cfg/models/v9/yolov9e.yaml
-ultralytics/cfg/models/v9/yolov9m.yaml
-ultralytics/cfg/models/v9/yolov9s.yaml
-ultralytics/cfg/models/v9/yolov9t.yaml
-ultralytics/cfg/trackers/botsort.yaml
-ultralytics/cfg/trackers/bytetrack.yaml
-ultralytics/data/__init__.py
-ultralytics/data/annotator.py
-ultralytics/data/augment.py
-ultralytics/data/base.py
-ultralytics/data/build.py
-ultralytics/data/converter.py
-ultralytics/data/dataset.py
-ultralytics/data/loaders.py
-ultralytics/data/split.py
-ultralytics/data/split_dota.py
-ultralytics/data/utils.py
-ultralytics/data/scripts/download_weights.sh
-ultralytics/data/scripts/get_coco.sh
-ultralytics/data/scripts/get_coco128.sh
-ultralytics/data/scripts/get_imagenet.sh
-ultralytics/engine/__init__.py
-ultralytics/engine/exporter.py
-ultralytics/engine/model.py
-ultralytics/engine/predictor.py
-ultralytics/engine/results.py
-ultralytics/engine/trainer.py
-ultralytics/engine/tuner.py
-ultralytics/engine/validator.py
-ultralytics/hub/__init__.py
-ultralytics/hub/auth.py
-ultralytics/hub/session.py
-ultralytics/hub/utils.py
-ultralytics/hub/google/__init__.py
-ultralytics/models/__init__.py
-ultralytics/models/fastsam/__init__.py
-ultralytics/models/fastsam/model.py
-ultralytics/models/fastsam/predict.py
-ultralytics/models/fastsam/utils.py
-ultralytics/models/fastsam/val.py
-ultralytics/models/nas/__init__.py
-ultralytics/models/nas/model.py
-ultralytics/models/nas/predict.py
-ultralytics/models/nas/val.py
-ultralytics/models/rtdetr/__init__.py
-ultralytics/models/rtdetr/model.py
-ultralytics/models/rtdetr/predict.py
-ultralytics/models/rtdetr/train.py
-ultralytics/models/rtdetr/val.py
-ultralytics/models/sam/__init__.py
-ultralytics/models/sam/amg.py
-ultralytics/models/sam/build.py
-ultralytics/models/sam/build_sam3.py
-ultralytics/models/sam/model.py
-ultralytics/models/sam/predict.py
-ultralytics/models/sam/modules/__init__.py
-ultralytics/models/sam/modules/blocks.py
-ultralytics/models/sam/modules/decoders.py
-ultralytics/models/sam/modules/encoders.py
-ultralytics/models/sam/modules/memory_attention.py
-ultralytics/models/sam/modules/sam.py
-ultralytics/models/sam/modules/tiny_encoder.py
-ultralytics/models/sam/modules/transformer.py
-ultralytics/models/sam/modules/utils.py
-ultralytics/models/sam/sam3/__init__.py
-ultralytics/models/sam/sam3/decoder.py
-ultralytics/models/sam/sam3/encoder.py
-ultralytics/models/sam/sam3/geometry_encoders.py
-ultralytics/models/sam/sam3/maskformer_segmentation.py
-ultralytics/models/sam/sam3/model_misc.py
-ultralytics/models/sam/sam3/necks.py
-ultralytics/models/sam/sam3/sam3_image.py
-ultralytics/models/sam/sam3/text_encoder_ve.py
-ultralytics/models/sam/sam3/vitdet.py
-ultralytics/models/sam/sam3/vl_combiner.py
-ultralytics/models/utils/__init__.py
-ultralytics/models/utils/loss.py
-ultralytics/models/utils/ops.py
-ultralytics/models/yolo/__init__.py
-ultralytics/models/yolo/model.py
-ultralytics/models/yolo/classify/__init__.py
-ultralytics/models/yolo/classify/predict.py
-ultralytics/models/yolo/classify/train.py
-ultralytics/models/yolo/classify/val.py
-ultralytics/models/yolo/detect/__init__.py
-ultralytics/models/yolo/detect/predict.py
-ultralytics/models/yolo/detect/train.py
-ultralytics/models/yolo/detect/val.py
-ultralytics/models/yolo/obb/__init__.py
-ultralytics/models/yolo/obb/predict.py
-ultralytics/models/yolo/obb/train.py
-ultralytics/models/yolo/obb/val.py
-ultralytics/models/yolo/pose/__init__.py
-ultralytics/models/yolo/pose/predict.py
-ultralytics/models/yolo/pose/train.py
-ultralytics/models/yolo/pose/val.py
-ultralytics/models/yolo/segment/__init__.py
-ultralytics/models/yolo/segment/predict.py
-ultralytics/models/yolo/segment/train.py
-ultralytics/models/yolo/segment/val.py
-ultralytics/models/yolo/world/__init__.py
-ultralytics/models/yolo/world/train.py
-ultralytics/models/yolo/world/train_world.py
-ultralytics/models/yolo/yoloe/__init__.py
-ultralytics/models/yolo/yoloe/predict.py
-ultralytics/models/yolo/yoloe/train.py
-ultralytics/models/yolo/yoloe/train_seg.py
-ultralytics/models/yolo/yoloe/val.py
-ultralytics/nn/__init__.py
-ultralytics/nn/ablation.py
-ultralytics/nn/autobackend.py
-ultralytics/nn/prebackbone.py
-ultralytics/nn/prebackboneB.py
-ultralytics/nn/tasks.py
-ultralytics/nn/text_model.py
-ultralytics/nn/modules/__init__.py
-ultralytics/nn/modules/activation.py
-ultralytics/nn/modules/block.py
-ultralytics/nn/modules/conv.py
-ultralytics/nn/modules/head.py
-ultralytics/nn/modules/transformer.py
-ultralytics/nn/modules/utils.py
-ultralytics/optim/__init__.py
-ultralytics/optim/muon.py
-ultralytics/solutions/__init__.py
-ultralytics/solutions/ai_gym.py
-ultralytics/solutions/analytics.py
-ultralytics/solutions/config.py
-ultralytics/solutions/distance_calculation.py
-ultralytics/solutions/heatmap.py
-ultralytics/solutions/instance_segmentation.py
-ultralytics/solutions/object_blurrer.py
-ultralytics/solutions/object_counter.py
-ultralytics/solutions/object_cropper.py
-ultralytics/solutions/parking_management.py
-ultralytics/solutions/queue_management.py
-ultralytics/solutions/region_counter.py
-ultralytics/solutions/security_alarm.py
-ultralytics/solutions/similarity_search.py
-ultralytics/solutions/solutions.py
-ultralytics/solutions/speed_estimation.py
-ultralytics/solutions/streamlit_inference.py
-ultralytics/solutions/trackzone.py
-ultralytics/solutions/vision_eye.py
-ultralytics/solutions/templates/similarity-search.html
-ultralytics/trackers/__init__.py
-ultralytics/trackers/basetrack.py
-ultralytics/trackers/bot_sort.py
-ultralytics/trackers/byte_tracker.py
-ultralytics/trackers/track.py
-ultralytics/trackers/utils/__init__.py
-ultralytics/trackers/utils/gmc.py
-ultralytics/trackers/utils/kalman_filter.py
-ultralytics/trackers/utils/matching.py
-ultralytics/utils/__init__.py
-ultralytics/utils/autobatch.py
-ultralytics/utils/autodevice.py
-ultralytics/utils/benchmarks.py
-ultralytics/utils/checks.py
-ultralytics/utils/cpu.py
-ultralytics/utils/dist.py
-ultralytics/utils/downloads.py
-ultralytics/utils/errors.py
-ultralytics/utils/events.py
-ultralytics/utils/files.py
-ultralytics/utils/git.py
-ultralytics/utils/instance.py
-ultralytics/utils/logger.py
-ultralytics/utils/loss.py
-ultralytics/utils/metrics.py
-ultralytics/utils/nms.py
-ultralytics/utils/ops.py
-ultralytics/utils/patches.py
-ultralytics/utils/plotting.py
-ultralytics/utils/tal.py
-ultralytics/utils/torch_utils.py
-ultralytics/utils/tqdm.py
-ultralytics/utils/triton.py
-ultralytics/utils/tuner.py
-ultralytics/utils/uploads.py
-ultralytics/utils/callbacks/__init__.py
-ultralytics/utils/callbacks/base.py
-ultralytics/utils/callbacks/clearml.py
-ultralytics/utils/callbacks/comet.py
-ultralytics/utils/callbacks/dvc.py
-ultralytics/utils/callbacks/hub.py
-ultralytics/utils/callbacks/mlflow.py
-ultralytics/utils/callbacks/neptune.py
-ultralytics/utils/callbacks/platform.py
-ultralytics/utils/callbacks/raytune.py
-ultralytics/utils/callbacks/tensorboard.py
-ultralytics/utils/callbacks/wb.py
-ultralytics/utils/export/__init__.py
-ultralytics/utils/export/engine.py
-ultralytics/utils/export/executorch.py
-ultralytics/utils/export/imx.py
-ultralytics/utils/export/tensorflow.py

vendor/ultralytics.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

vendor/ultralytics.egg-info/entry_points.txt

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

vendor/ultralytics.egg-info/requires.txt

@@ -1,83 +0,0 @@
-numpy>=1.23.0
-matplotlib>=3.3.0
-opencv-python>=4.6.0
-pillow>=7.1.2
-pyyaml>=5.3.1
-requests>=2.23.0
-scipy>=1.4.1
-torch>=1.8.0
-torchvision>=0.9.0
-psutil>=5.8.0
-polars>=0.20.0
-ultralytics-thop>=2.0.18
-
-[:sys_platform == "win32"]
-torch!=2.4.0,>=1.8.0
-
-[dev]
-ipython
-pytest
-pytest-cov
-coverage[toml]
-mkdocs-ultralytics-plugin>=0.2.4
-minijinja>=2.0.0
-
-[dev:python_version >= "3.10"]
-zensical>=0.0.15
-
-[export]
-numpy<2.0.0
-onnxslim>=0.1.82
-openvino>=2024.0.0
-tensorflow<=2.19.0,>=2.0.0
-tensorflowjs>=2.0.0
-setuptools<=81.0.0
-
-[export:platform_machine == "aarch64"]
-h5py!=3.11.0
-
-[export:platform_machine == "aarch64" and platform_system == "Linux" and python_version >= "3.9"]
-packaging>=26.0
-
-[export:platform_machine == "aarch64" and python_version >= "3.9"]
-tensorstore>=0.1.63
-
-[export:platform_system != "Darwin"]
-onnx>=1.12.0
-
-[export:platform_system != "Windows" and python_version <= "3.13"]
-coremltools>=9.0
-scikit-learn>=1.3.2
-
-[export:platform_system == "Darwin"]
-onnx<1.18.0,>=1.12.0
-
-[extra]
-ipython
-albumentations>=1.4.6
-faster-coco-eval>=1.6.7
-
-[logging]
-wandb
-tensorboard
-mlflow
-
-[solutions]
-shapely>=2.0.0
-flask>=3.0.1
-
-[solutions:python_version < "3.10" and (python_version < "3.9" or platform_machine != "aarch64" or platform_system != "Linux")]
-streamlit<1.51.0,>=1.29.0
-
-[solutions:python_version >= "3.10"]
-streamlit>=1.51.0
-
-[typing]
-types-pillow
-types-psutil
-types-pyyaml
-types-requests
-types-shapely
-
-[typing:python_version >= "3.10"]
-scipy-stubs>=1.14.1.4

vendor/ultralytics.egg-info/top_level.txt

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

vendor/ultralytics/__init__.py

@@ -1,48 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-__version__ = "8.4.21"
-
-import importlib
-import os
-from typing import TYPE_CHECKING
-
-# Set ENV variables (place before imports)
-if not os.environ.get("OMP_NUM_THREADS"):
-    os.environ["OMP_NUM_THREADS"] = "1"  # default for reduced CPU utilization during training
-
-from ultralytics.utils import ASSETS, SETTINGS
-from ultralytics.utils.checks import check_yolo as checks
-from ultralytics.utils.downloads import download
-
-settings = SETTINGS
-
-MODELS = ("YOLO", "YOLOWorld", "YOLOE", "NAS", "SAM", "FastSAM", "RTDETR")
-
-__all__ = (
-    "__version__",
-    "ASSETS",
-    *MODELS,
-    "checks",
-    "download",
-    "settings",
-)
-
-if TYPE_CHECKING:
-    # Enable hints for type checkers
-    from ultralytics.models import YOLO, YOLOWorld, YOLOE, NAS, SAM, FastSAM, RTDETR  # noqa
-
-
-def __getattr__(name: str):
-    """Lazy-import model classes on first access."""
-    if name in MODELS:
-        return getattr(importlib.import_module("ultralytics.models"), name)
-    raise AttributeError(f"module {__name__} has no attribute {name}")
-
-
-def __dir__():
-    """Extend dir() to include lazily available model names for IDE autocompletion."""
-    return sorted(set(globals()) | set(MODELS))
-
-
-if __name__ == "__main__":
-    print(__version__)

vendor/ultralytics/cfg/__init__.py

@@ -1,1039 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-from __future__ import annotations
-
-import ast
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-from types import SimpleNamespace
-from typing import Any
-
-from ultralytics import __version__
-from ultralytics.utils import (
-    ASSETS,
-    DEFAULT_CFG,
-    DEFAULT_CFG_DICT,
-    DEFAULT_CFG_PATH,
-    FLOAT_OR_INT,
-    IS_VSCODE,
-    LOGGER,
-    RANK,
-    ROOT,
-    RUNS_DIR,
-    SETTINGS,
-    SETTINGS_FILE,
-    STR_OR_PATH,
-    TESTS_RUNNING,
-    YAML,
-    IterableSimpleNamespace,
-    checks,
-    colorstr,
-    deprecation_warn,
-    vscode_msg,
-)
-
-# Define valid solutions
-SOLUTION_MAP = {
-    "count": "ObjectCounter",
-    "crop": "ObjectCropper",
-    "blur": "ObjectBlurrer",
-    "workout": "AIGym",
-    "heatmap": "Heatmap",
-    "isegment": "InstanceSegmentation",
-    "visioneye": "VisionEye",
-    "speed": "SpeedEstimator",
-    "queue": "QueueManager",
-    "analytics": "Analytics",
-    "inference": "Inference",
-    "trackzone": "TrackZone",
-    "help": None,
-}
-
-# Define valid tasks and modes
-MODES = frozenset({"train", "val", "predict", "export", "track", "benchmark"})
-TASKS = frozenset({"detect", "segment", "classify", "pose", "obb"})
-TASK2DATA = {
-    "detect": "coco8.yaml",
-    "segment": "coco8-seg.yaml",
-    "classify": "imagenet10",
-    "pose": "coco8-pose.yaml",
-    "obb": "dota8.yaml",
-}
-TASK2MODEL = {
-    "detect": "yolo26n.pt",
-    "segment": "yolo26n-seg.pt",
-    "classify": "yolo26n-cls.pt",
-    "pose": "yolo26n-pose.pt",
-    "obb": "yolo26n-obb.pt",
-}
-TASK2METRIC = {
-    "detect": "metrics/mAP50-95(B)",
-    "segment": "metrics/mAP50-95(M)",
-    "classify": "metrics/accuracy_top1",
-    "pose": "metrics/mAP50-95(P)",
-    "obb": "metrics/mAP50-95(B)",
-}
-
-ARGV = sys.argv or ["", ""]  # sometimes sys.argv = []
-SOLUTIONS_HELP_MSG = f"""
-    Arguments received: {["yolo", *ARGV[1:]]!s}. Ultralytics 'yolo solutions' usage overview:
-
-        yolo solutions SOLUTION ARGS
-
-        Where SOLUTION (optional) is one of {list(SOLUTION_MAP.keys())[:-1]}
-              ARGS (optional) are any number of custom 'arg=value' pairs like 'show_in=True' that override defaults
-                  at https://docs.ultralytics.com/usage/cfg
-
-    1. Call object counting solution
-        yolo solutions count source="path/to/video.mp4" region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]"
-
-    2. Call heatmap solution
-        yolo solutions heatmap colormap=cv2.COLORMAP_PARULA model=yolo26n.pt
-
-    3. Call queue management solution
-        yolo solutions queue region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]" model=yolo26n.pt
-
-    4. Call workout monitoring solution for push-ups
-        yolo solutions workout model=yolo26n-pose.pt kpts=[6, 8, 10]
-
-    5. Generate analytical graphs
-        yolo solutions analytics analytics_type="pie"
-
-    6. Track objects within specific zones
-        yolo solutions trackzone source="path/to/video.mp4" region="[(150, 150), (1130, 150), (1130, 570), (150, 570)]"
-
-    7. Streamlit real-time webcam inference GUI
-        yolo streamlit-predict
-    """
-CLI_HELP_MSG = f"""
-    Arguments received: {["yolo", *ARGV[1:]]!s}. Ultralytics 'yolo' commands use the following syntax:
-
-        yolo TASK MODE ARGS
-
-        Where   TASK (optional) is one of {list(TASKS)}
-                MODE (required) is one of {list(MODES)}
-                ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults.
-                    See all ARGS at https://docs.ultralytics.com/usage/cfg or with 'yolo cfg'
-
-    1. Train a detection model for 10 epochs with an initial learning_rate of 0.01
-        yolo train data=coco8.yaml model=yolo26n.pt epochs=10 lr0=0.01
-
-    2. Predict a YouTube video using a pretrained segmentation model at image size 320:
-        yolo predict model=yolo26n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
-
-    3. Validate a pretrained detection model at batch-size 1 and image size 640:
-        yolo val model=yolo26n.pt data=coco8.yaml batch=1 imgsz=640
-
-    4. Export a YOLO26n classification model to ONNX format at image size 224 by 128 (no TASK required)
-        yolo export model=yolo26n-cls.pt format=onnx imgsz=224,128
-
-    5. Ultralytics solutions usage
-        yolo solutions count or any of {list(SOLUTION_MAP.keys())[1:-1]} source="path/to/video.mp4"
-
-    6. Run special commands:
-        yolo help
-        yolo checks
-        yolo version
-        yolo settings
-        yolo copy-cfg
-        yolo cfg
-        yolo solutions help
-
-    Docs: https://docs.ultralytics.com
-    Solutions: https://docs.ultralytics.com/solutions/
-    Community: https://community.ultralytics.com
-    GitHub: https://github.com/ultralytics/ultralytics
-    """
-
-# Define keys for arg type checks
-CFG_FLOAT_KEYS = frozenset(
-    {  # integer or float arguments, i.e. x=2 and x=2.0
-        "warmup_epochs",
-        "box",
-        "cls",
-        "dfl",
-        "degrees",
-        "shear",
-        "time",
-        "workspace",
-        "batch",
-        "gaussian_noise_mean",
-    }
-)
-CFG_FRACTION_KEYS = frozenset(
-    {  # fractional float arguments with 0.0<=values<=1.0
-        "dropout",
-        "lr0",
-        "lrf",
-        "momentum",
-        "weight_decay",
-        "warmup_momentum",
-        "warmup_bias_lr",
-        "hsv_h",
-        "hsv_s",
-        "hsv_v",
-        "translate",
-        "scale",
-        "perspective",
-        "flipud",
-        "fliplr",
-        "bgr",
-        "mosaic",
-        "mixup",
-        "cutmix",
-        "copy_paste",
-        "gaussian_noise_p",
-        "conf",
-        "iou",
-        "fraction",
-        "multi_scale",
-        "deeppcb_safe_fliplr",
-        "deeppcb_safe_flipud",
-        "deeppcb_safe_crop_p",
-        "deeppcb_safe_crop_min_frac",
-        "deeppcb_safe_translate",
-        "deeppcb_safe_scale",
-    }
-)
-CFG_INT_KEYS = frozenset(
-    {  # integer-only arguments
-        "epochs",
-        "patience",
-        "workers",
-        "seed",
-        "close_mosaic",
-        "mask_ratio",
-        "max_det",
-        "vid_stride",
-        "line_width",
-        "nbs",
-        "save_period",
-    }
-)
-CFG_BOOL_KEYS = frozenset(
-    {  # boolean-only arguments
-        "save",
-        "exist_ok",
-        "verbose",
-        "deterministic",
-        "single_cls",
-        "rect",
-        "cos_lr",
-        "overlap_mask",
-        "val",
-        "save_json",
-        "half",
-        "dnn",
-        "plots",
-        "show",
-        "save_txt",
-        "save_conf",
-        "save_crop",
-        "save_frames",
-        "show_labels",
-        "show_conf",
-        "visualize",
-        "augment",
-        "agnostic_nms",
-        "retina_masks",
-        "show_boxes",
-        "keras",
-        "optimize",
-        "int8",
-        "dynamic",
-        "simplify",
-        "nms",
-        "profile",
-        "end2end",
-        "prebackbone_input_only_non_geo_aug",
-        "isdeeppcb",
-        "deeppcb_safe_aug",
-        "augment_train",
-    }
-)
-
-
-def cfg2dict(cfg: str | Path | dict | SimpleNamespace) -> dict:
-    """Convert a configuration object to a dictionary.
-
-    Args:
-        cfg (str | Path | dict | SimpleNamespace): Configuration object to be converted. Can be a file path, a string, a
-            dictionary, or a SimpleNamespace object.
-
-    Returns:
-        (dict): Configuration object in dictionary format.
-
-    Examples:
-        Convert a YAML file path to a dictionary:
-        >>> config_dict = cfg2dict("config.yaml")
-
-        Convert a SimpleNamespace to a dictionary:
-        >>> from types import SimpleNamespace
-        >>> config_sn = SimpleNamespace(param1="value1", param2="value2")
-        >>> config_dict = cfg2dict(config_sn)
-
-        Pass through an already existing dictionary:
-        >>> config_dict = cfg2dict({"param1": "value1", "param2": "value2"})
-
-    Notes:
-        - If cfg is a path or string, it's loaded as YAML and converted to a dictionary.
-        - If cfg is a SimpleNamespace object, it's converted to a dictionary using vars().
-        - If cfg is already a dictionary, it's returned unchanged.
-    """
-    if isinstance(cfg, STR_OR_PATH):
-        cfg = YAML.load(cfg)  # load dict
-    elif isinstance(cfg, SimpleNamespace):
-        cfg = vars(cfg)  # convert to dict
-    return cfg
-
-
-def get_cfg(
-    cfg: str | Path | dict | SimpleNamespace = DEFAULT_CFG_DICT, overrides: dict | None = None
-) -> SimpleNamespace:
-    """Load and merge configuration data from a file or dictionary, with optional overrides.
-
-    Args:
-        cfg (str | Path | dict | SimpleNamespace): Configuration data source. Can be a file path, dictionary, or
-            SimpleNamespace object.
-        overrides (dict | None): Dictionary containing key-value pairs to override the base configuration.
-
-    Returns:
-        (SimpleNamespace): Namespace containing the merged configuration arguments.
-
-    Examples:
-        >>> from ultralytics.cfg import get_cfg
-        >>> config = get_cfg()  # Load default configuration
-        >>> config_with_overrides = get_cfg("path/to/config.yaml", overrides={"epochs": 50, "batch_size": 16})
-
-    Notes:
-        - If both `cfg` and `overrides` are provided, the values in `overrides` will take precedence.
-        - Special handling ensures alignment and correctness of the configuration, such as converting numeric
-          `project` and `name` to strings and validating configuration keys and values.
-        - The function performs type and value checks on the configuration data.
-    """
-    cfg = cfg2dict(cfg)
-
-    # Merge overrides
-    if overrides:
-        overrides = cfg2dict(overrides)
-        check_dict_alignment(cfg, overrides)
-        cfg = {**cfg, **overrides}  # merge cfg and overrides dicts (prefer overrides)
-
-    # Special handling for numeric project/name
-    for k in "project", "name":
-        if k in cfg and isinstance(cfg[k], FLOAT_OR_INT):
-            cfg[k] = str(cfg[k])
-    if cfg.get("name") == "model":  # assign model to 'name' arg
-        cfg["name"] = str(cfg.get("model", "")).partition(".")[0]
-        LOGGER.warning(f"'name=model' automatically updated to 'name={cfg['name']}'.")
-
-    # Type and Value checks
-    check_cfg(cfg)
-
-    # Return instance
-    return IterableSimpleNamespace(**cfg)
-
-
-def check_cfg(cfg: dict, hard: bool = True) -> None:
-    """Check configuration argument types and values for the Ultralytics library.
-
-    This function validates the types and values of configuration arguments, ensuring correctness and converting them if
-    necessary. It checks for specific key types defined in global variables such as `CFG_FLOAT_KEYS`,
-    `CFG_FRACTION_KEYS`, `CFG_INT_KEYS`, and `CFG_BOOL_KEYS`.
-
-    Args:
-        cfg (dict): Configuration dictionary to validate.
-        hard (bool): If True, raises exceptions for invalid types and values; if False, attempts to convert them.
-
-    Examples:
-        >>> config = {
-        ...     "epochs": 50,  # valid integer
-        ...     "lr0": 0.01,  # valid float
-        ...     "momentum": 1.2,  # invalid float (out of 0.0-1.0 range)
-        ...     "save": "true",  # invalid bool
-        ... }
-        >>> check_cfg(config, hard=False)
-        >>> print(config)
-        {'epochs': 50, 'lr0': 0.01, 'momentum': 1.2, 'save': False}  # corrected 'save' key
-
-    Notes:
-        - The function modifies the input dictionary in-place.
-        - None values are ignored as they may be from optional arguments.
-        - Fraction keys are checked to be within the range [0.0, 1.0].
-    """
-    for k, v in cfg.items():
-        if v is not None:  # None values may be from optional args
-            if k in CFG_FLOAT_KEYS and not isinstance(v, FLOAT_OR_INT):
-                if hard:
-                    raise TypeError(
-                        f"'{k}={v}' is of invalid type {type(v).__name__}. "
-                        f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')"
-                    )
-                cfg[k] = float(v)
-            elif k in CFG_FRACTION_KEYS:
-                if not isinstance(v, FLOAT_OR_INT):
-                    if hard:
-                        raise TypeError(
-                            f"'{k}={v}' is of invalid type {type(v).__name__}. "
-                            f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')"
-                        )
-                    cfg[k] = v = float(v)
-                if not (0.0 <= v <= 1.0):
-                    raise ValueError(f"'{k}={v}' is an invalid value. Valid '{k}' values are between 0.0 and 1.0.")
-            elif k in CFG_INT_KEYS and not isinstance(v, int):
-                if hard:
-                    raise TypeError(
-                        f"'{k}={v}' is of invalid type {type(v).__name__}. '{k}' must be an int (i.e. '{k}=8')"
-                    )
-                cfg[k] = int(v)
-            elif k in CFG_BOOL_KEYS and not isinstance(v, bool):
-                if hard:
-                    raise TypeError(
-                        f"'{k}={v}' is of invalid type {type(v).__name__}. "
-                        f"'{k}' must be a bool (i.e. '{k}=True' or '{k}=False')"
-                    )
-                cfg[k] = bool(v)
-
-
-def get_save_dir(args: SimpleNamespace, name: str | None = None) -> Path:
-    """Return the directory path for saving outputs, derived from arguments or default settings.
-
-    Args:
-        args (SimpleNamespace): Namespace object containing configurations such as 'project', 'name', 'task', 'mode',
-            and 'save_dir'.
-        name (str | None): Optional name for the output directory. If not provided, it defaults to 'args.name' or the
-            'args.mode'.
-
-    Returns:
-        (Path): Directory path where outputs should be saved.
-
-    Examples:
-        >>> from types import SimpleNamespace
-        >>> args = SimpleNamespace(project="my_project", task="detect", mode="train", exist_ok=True)
-        >>> save_dir = get_save_dir(args)
-        >>> print(save_dir)
-        runs/detect/my_project/train
-    """
-    if getattr(args, "save_dir", None):
-        save_dir = args.save_dir
-    else:
-        from ultralytics.utils.files import increment_path
-
-        project = args.project or ""
-        if not Path(project).is_absolute():
-            project = (ROOT.parent / "tests/tmp/runs" if TESTS_RUNNING else RUNS_DIR) / args.task / project
-        name = name or args.name or f"{args.mode}"
-        save_dir = increment_path(Path(project) / name, exist_ok=args.exist_ok if RANK in {-1, 0} else True)
-
-    return Path(save_dir).resolve()  # resolve to display full path in console
-
-
-def _handle_deprecation(custom: dict) -> dict:
-    """Handle deprecated configuration keys by mapping them to current equivalents with deprecation warnings.
-
-    Args:
-        custom (dict): Configuration dictionary potentially containing deprecated keys.
-
-    Returns:
-        (dict): Updated configuration dictionary with deprecated keys replaced.
-
-    Examples:
-        >>> custom_config = {"boxes": True, "hide_labels": "False", "line_thickness": 2}
-        >>> _handle_deprecation(custom_config)
-        >>> print(custom_config)
-        {'show_boxes': True, 'show_labels': True, 'line_width': 2}
-
-    Notes:
-        This function modifies the input dictionary in-place, replacing deprecated keys with their current
-        equivalents. It also handles value conversions where necessary, such as inverting boolean values for
-        'hide_labels' and 'hide_conf'.
-    """
-    deprecated_mappings = {
-        "boxes": ("show_boxes", lambda v: v),
-        "hide_labels": ("show_labels", lambda v: not bool(v)),
-        "hide_conf": ("show_conf", lambda v: not bool(v)),
-        "line_thickness": ("line_width", lambda v: v),
-    }
-    removed_keys = {"label_smoothing", "save_hybrid", "crop_fraction"}
-
-    for old_key, (new_key, transform) in deprecated_mappings.items():
-        if old_key not in custom:
-            continue
-        deprecation_warn(old_key, new_key)
-        custom[new_key] = transform(custom.pop(old_key))
-
-    for key in removed_keys:
-        if key not in custom:
-            continue
-        deprecation_warn(key)
-        custom.pop(key)
-
-    return custom
-
-
-def check_dict_alignment(
-    base: dict, custom: dict, e: Exception | None = None, allowed_custom_keys: set | None = None
-) -> None:
-    """Check alignment between custom and base configuration dictionaries, handling deprecated keys and providing error
-    messages for mismatched keys.
-
-    Args:
-        base (dict): The base configuration dictionary containing valid keys.
-        custom (dict): The custom configuration dictionary to be checked for alignment.
-        e (Exception | None): Optional error instance passed by the calling function.
-        allowed_custom_keys (set | None): Optional set of additional keys that are allowed in the custom dictionary.
-
-    Raises:
-        SystemExit: If mismatched keys are found between the custom and base dictionaries.
-
-    Examples:
-        >>> base_cfg = {"epochs": 50, "lr0": 0.01, "batch_size": 16}
-        >>> custom_cfg = {"epoch": 100, "lr": 0.02, "batch_size": 32}
-        >>> try:
-        ...     check_dict_alignment(base_cfg, custom_cfg)
-        ... except SystemExit:
-        ...     print("Mismatched keys found")
-
-    Notes:
-        - Suggests corrections for mismatched keys based on similarity to valid keys.
-        - Automatically replaces deprecated keys in the custom configuration with updated equivalents.
-        - Prints detailed error messages for each mismatched key to help users correct their configurations.
-    """
-    custom = _handle_deprecation(custom)
-    base_keys, custom_keys = (frozenset(x.keys()) for x in (base, custom))
-    # Allow 'augmentations' as a valid custom parameter for custom Albumentations transforms
-    if allowed_custom_keys is None:
-        allowed_custom_keys = {"augmentations", "save_dir"}
-    if mismatched := [k for k in custom_keys if k not in base_keys and k not in allowed_custom_keys]:
-        from difflib import get_close_matches
-
-        string = ""
-        for x in mismatched:
-            matches = get_close_matches(x, base_keys)  # key list
-            matches = [f"{k}={base[k]}" if base.get(k) is not None else k for k in matches]
-            match_str = f"Similar arguments are i.e. {matches}." if matches else ""
-            string += f"'{colorstr('red', 'bold', x)}' is not a valid YOLO argument. {match_str}\n"
-        raise SyntaxError(string + CLI_HELP_MSG) from e
-
-
-def merge_equals_args(args: list[str]) -> list[str]:
-    """Merge arguments around isolated '=' in a list of strings and join fragments with brackets.
-
-    This function handles the following cases:
-        1. ['arg', '=', 'val'] becomes ['arg=val']
-        2. ['arg=', 'val'] becomes ['arg=val']
-        3. ['arg', '=val'] becomes ['arg=val']
-        4. Joins fragments with brackets, e.g., ['imgsz=[3,', '640,', '640]'] becomes ['imgsz=[3,640,640]']
-
-    Args:
-        args (list[str]): A list of strings where each element represents an argument or fragment.
-
-    Returns:
-        (list[str]): A list of strings where the arguments around isolated '=' are merged and fragments with brackets
-            are joined.
-
-    Examples:
-        >>> args = ["arg1", "=", "value", "arg2=", "value2", "arg3", "=value3", "imgsz=[3,", "640,", "640]"]
-        >>> merge_equals_args(args)
-        ['arg1=value', 'arg2=value2', 'arg3=value3', 'imgsz=[3,640,640]']
-    """
-    new_args = []
-    current = ""
-    depth = 0
-
-    i = 0
-    while i < len(args):
-        arg = args[i]
-
-        # Handle equals sign merging
-        if arg == "=" and 0 < i < len(args) - 1:  # merge ['arg', '=', 'val']
-            new_args[-1] += f"={args[i + 1]}"
-            i += 2
-            continue
-        elif arg.endswith("=") and i < len(args) - 1 and "=" not in args[i + 1]:  # merge ['arg=', 'val']
-            new_args.append(f"{arg}{args[i + 1]}")
-            i += 2
-            continue
-        elif arg.startswith("=") and i > 0:  # merge ['arg', '=val']
-            new_args[-1] += arg
-            i += 1
-            continue
-
-        # Handle bracket joining
-        depth += arg.count("[") - arg.count("]")
-        current += arg
-        if depth == 0:
-            new_args.append(current)
-            current = ""
-
-        i += 1
-
-    # Append any remaining current string
-    if current:
-        new_args.append(current)
-
-    return new_args
-
-
-def handle_yolo_hub(args: list[str]) -> None:
-    """Handle Ultralytics HUB command-line interface (CLI) commands for authentication.
-
-    This function processes Ultralytics HUB CLI commands such as login and logout. It should be called when executing a
-    script with arguments related to HUB authentication.
-
-    Args:
-        args (list[str]): A list of command line arguments. The first argument should be either 'login' or 'logout'. For
-            'login', an optional second argument can be the API key.
-
-    Examples:
-        $ yolo login YOUR_API_KEY
-
-    Notes:
-        - The function imports the 'hub' module from ultralytics to perform login and logout operations.
-        - For the 'login' command, if no API key is provided, an empty string is passed to the login function.
-        - The 'logout' command does not require any additional arguments.
-    """
-    from ultralytics import hub
-
-    if args[0] == "login":
-        key = args[1] if len(args) > 1 else ""
-        # Log in to Ultralytics HUB using the provided API key
-        hub.login(key)
-    elif args[0] == "logout":
-        # Log out from Ultralytics HUB
-        hub.logout()
-
-
-def handle_yolo_settings(args: list[str]) -> None:
-    """Handle YOLO settings command-line interface (CLI) commands.
-
-    This function processes YOLO settings CLI commands such as reset and updating individual settings. It should be
-    called when executing a script with arguments related to YOLO settings management.
-
-    Args:
-        args (list[str]): A list of command line arguments for YOLO settings management.
-
-    Examples:
-        >>> handle_yolo_settings(["reset"])  # Reset YOLO settings
-        >>> handle_yolo_settings(["default_cfg_path=yolo26n.yaml"])  # Update a specific setting
-
-    Notes:
-        - If no arguments are provided, the function will display the current settings.
-        - The 'reset' command will delete the existing settings file and create new default settings.
-        - Other arguments are treated as key-value pairs to update specific settings.
-        - The function will check for alignment between the provided settings and the existing ones.
-        - After processing, the updated settings will be displayed.
-        - For more information on handling YOLO settings, visit:
-          https://docs.ultralytics.com/quickstart/#ultralytics-settings
-    """
-    url = "https://docs.ultralytics.com/quickstart/#ultralytics-settings"  # help URL
-    try:
-        if any(args):
-            if args[0] == "reset":
-                SETTINGS_FILE.unlink()  # delete the settings file
-                SETTINGS.reset()  # create new settings
-                LOGGER.info("Settings reset successfully")  # inform the user that settings have been reset
-            else:  # save a new setting
-                new = dict(parse_key_value_pair(a) for a in args)
-                check_dict_alignment(SETTINGS, new)
-                SETTINGS.update(new)
-                for k, v in new.items():
-                    LOGGER.info(f"✅ Updated '{k}={v}'")
-
-        LOGGER.info(SETTINGS)  # print the current settings
-        LOGGER.info(f"💡 Learn more about Ultralytics Settings at {url}")
-    except Exception as e:
-        LOGGER.warning(f"settings error: '{e}'. Please see {url} for help.")
-
-
-def handle_yolo_solutions(args: list[str]) -> None:
-    """Process YOLO solutions arguments and run the specified computer vision solutions pipeline.
-
-    Args:
-        args (list[str]): Command-line arguments for configuring and running the Ultralytics YOLO solutions.
-
-    Examples:
-        Run people counting solution with default settings:
-        >>> handle_yolo_solutions(["count"])
-
-        Run analytics with custom configuration:
-        >>> handle_yolo_solutions(["analytics", "conf=0.25", "source=path/to/video.mp4"])
-
-        Run inference with custom configuration, requires Streamlit version 1.29.0 or higher.
-        >>> handle_yolo_solutions(["inference", "model=yolo26n.pt"])
-
-    Notes:
-        - Arguments can be provided in the format 'key=value' or as boolean flags
-        - Available solutions are defined in SOLUTION_MAP with their respective classes and methods
-        - If an invalid solution is provided, defaults to 'count' solution
-        - Output videos are saved in 'runs/solution/{solution_name}' directory
-        - For 'analytics' solution, frame numbers are tracked for generating analytical graphs
-        - Video processing can be interrupted by pressing 'q'
-        - Processes video frames sequentially and saves output in .avi format
-        - If no source is specified, downloads and uses a default sample video
-        - The inference solution will be launched using the 'streamlit run' command.
-        - The Streamlit app file is located in the Ultralytics package directory.
-    """
-    from ultralytics.solutions.config import SolutionConfig
-
-    full_args_dict = vars(SolutionConfig())  # arguments dictionary
-    overrides = {}
-
-    # check dictionary alignment
-    for arg in merge_equals_args(args):
-        arg = arg.lstrip("-").rstrip(",")
-        if "=" in arg:
-            try:
-                k, v = parse_key_value_pair(arg)
-                overrides[k] = v
-            except (NameError, SyntaxError, ValueError, AssertionError) as e:
-                check_dict_alignment(full_args_dict, {arg: ""}, e)
-        elif arg in full_args_dict and isinstance(full_args_dict.get(arg), bool):
-            overrides[arg] = True
-    check_dict_alignment(full_args_dict, overrides)  # dict alignment
-
-    # Get solution name
-    if not args:
-        LOGGER.warning("No solution name provided. i.e `yolo solutions count`. Defaulting to 'count'.")
-        args = ["count"]
-    if args[0] == "help":
-        LOGGER.info(SOLUTIONS_HELP_MSG)
-        return  # Early return for 'help' case
-    elif args[0] in SOLUTION_MAP:
-        solution_name = args.pop(0)  # Extract the solution name directly
-    else:
-        LOGGER.warning(
-            f"❌ '{args[0]}' is not a valid solution. 💡 Defaulting to 'count'.\n"
-            f"🚀 Available solutions: {', '.join(list(SOLUTION_MAP.keys())[:-1])}\n"
-        )
-        solution_name = "count"  # Default for invalid solution
-
-    if solution_name == "inference":
-        checks.check_requirements("streamlit>=1.29.0")
-        LOGGER.info("💡 Loading Ultralytics live inference app...")
-        subprocess.run(
-            [  # Run subprocess with Streamlit custom argument
-                "streamlit",
-                "run",
-                str(ROOT / "solutions/streamlit_inference.py"),
-                "--server.headless",
-                "true",
-                overrides.pop("model", "yolo26n.pt"),
-            ]
-        )
-    else:
-        import cv2  # Only needed for cap and vw functionality
-
-        from ultralytics import solutions
-
-        solution = getattr(solutions, SOLUTION_MAP[solution_name])(is_cli=True, **overrides)  # class i.e. ObjectCounter
-
-        cap = cv2.VideoCapture(solution.CFG["source"])  # read the video file
-        if solution_name != "crop":
-            # extract width, height and fps of the video file, create save directory and initialize video writer
-            w, h, fps = (
-                int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS)
-            )
-            if solution_name == "analytics":  # analytical graphs follow fixed shape for output i.e w=1920, h=1080
-                w, h = 1280, 720
-            save_dir = get_save_dir(SimpleNamespace(task="solutions", name="exp", exist_ok=False, project=None))
-            save_dir.mkdir(parents=True, exist_ok=True)  # create the output directory i.e. runs/solutions/exp
-            vw = cv2.VideoWriter(str(save_dir / f"{solution_name}.avi"), cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
-
-        try:  # Process video frames
-            f_n = 0  # frame number, required for analytical graphs
-            while cap.isOpened():
-                success, frame = cap.read()
-                if not success:
-                    break
-                results = solution(frame, f_n := f_n + 1) if solution_name == "analytics" else solution(frame)
-                if solution_name != "crop":
-                    vw.write(results.plot_im)
-                if solution.CFG["show"] and cv2.waitKey(1) & 0xFF == ord("q"):
-                    break
-        finally:
-            cap.release()
-
-
-def parse_key_value_pair(pair: str = "key=value") -> tuple:
-    """Parse a key-value pair string into separate key and value components.
-
-    Args:
-        pair (str): A string containing a key-value pair in the format "key=value".
-
-    Returns:
-        key (str): The parsed key.
-        value (str): The parsed value.
-
-    Raises:
-        AssertionError: If the value is missing or empty.
-
-    Examples:
-        >>> key, value = parse_key_value_pair("model=yolo26n.pt")
-        >>> print(f"Key: {key}, Value: {value}")
-        Key: model, Value: yolo26n.pt
-
-        >>> key, value = parse_key_value_pair("epochs=100")
-        >>> print(f"Key: {key}, Value: {value}")
-        Key: epochs, Value: 100
-
-    Notes:
-        - The function splits the input string on the first '=' character.
-        - Leading and trailing whitespace is removed from both key and value.
-        - An assertion error is raised if the value is empty after stripping.
-    """
-    k, v = pair.split("=", 1)  # split on first '=' sign
-    k, v = k.strip(), v.strip()  # remove spaces
-    assert v, f"missing '{k}' value"
-    return k, smart_value(v)
-
-
-def smart_value(v: str) -> Any:
-    """Convert a string representation of a value to its appropriate Python type.
-
-    This function attempts to convert a given string into a Python object of the most appropriate type. It handles
-    conversions to None, bool, int, float, and other types that can be evaluated safely.
-
-    Args:
-        v (str): The string representation of the value to be converted.
-
-    Returns:
-        (Any): The converted value. The type can be None, bool, int, float, or the original string if no conversion is
-            applicable.
-
-    Examples:
-        >>> smart_value("42")
-        42
-        >>> smart_value("3.14")
-        3.14
-        >>> smart_value("True")
-        True
-        >>> smart_value("None")
-        None
-        >>> smart_value("some_string")
-        'some_string'
-
-    Notes:
-        - The function uses a case-insensitive comparison for boolean and None values.
-        - For other types, it attempts to use Python's ast.literal_eval() function for safe evaluation.
-        - If no conversion is possible, the original string is returned.
-    """
-    v_lower = v.lower()
-    if v_lower == "none":
-        return None
-    elif v_lower == "true":
-        return True
-    elif v_lower == "false":
-        return False
-    else:
-        try:
-            return ast.literal_eval(v)
-        except Exception:
-            return v
-
-
-def entrypoint(debug: str = "") -> None:
-    """Ultralytics entrypoint function for parsing and executing command-line arguments.
-
-    This function serves as the main entry point for the Ultralytics CLI, parsing command-line arguments and executing
-    the corresponding tasks such as training, validation, prediction, exporting models, and more.
-
-    Args:
-        debug (str): Space-separated string of command-line arguments for debugging purposes.
-
-    Examples:
-        Train a detection model for 10 epochs with an initial learning_rate of 0.01:
-        >>> entrypoint("train data=coco8.yaml model=yolo26n.pt epochs=10 lr0=0.01")
-
-        Predict a YouTube video using a pretrained segmentation model at image size 320:
-        >>> entrypoint("predict model=yolo26n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320")
-
-        Validate a pretrained detection model at batch-size 1 and image size 640:
-        >>> entrypoint("val model=yolo26n.pt data=coco8.yaml batch=1 imgsz=640")
-
-    Notes:
-        - If no arguments are passed, the function will display the usage help message.
-        - For a list of all available commands and their arguments, see the provided help messages and the
-          Ultralytics documentation at https://docs.ultralytics.com.
-    """
-    args = (debug.split(" ") if debug else ARGV)[1:]
-    if not args:  # no arguments passed
-        LOGGER.info(CLI_HELP_MSG)
-        return
-
-    special = {
-        "checks": checks.collect_system_info,
-        "version": lambda: LOGGER.info(__version__),
-        "settings": lambda: handle_yolo_settings(args[1:]),
-        "cfg": lambda: YAML.print(DEFAULT_CFG_PATH),
-        "hub": lambda: handle_yolo_hub(args[1:]),
-        "login": lambda: handle_yolo_hub(args),
-        "logout": lambda: handle_yolo_hub(args),
-        "copy-cfg": copy_default_cfg,
-        "solutions": lambda: handle_yolo_solutions(args[1:]),
-        "help": lambda: LOGGER.info(CLI_HELP_MSG),  # help below hub for -h flag precedence
-    }
-    full_args_dict = {**DEFAULT_CFG_DICT, **{k: None for k in TASKS}, **{k: None for k in MODES}, **special}
-
-    # Define common misuses of special commands, i.e. -h, -help, --help
-    special.update({k[0]: v for k, v in special.items()})  # singular
-    special.update({k[:-1]: v for k, v in special.items() if len(k) > 1 and k.endswith("s")})  # singular
-    special = {**special, **{f"-{k}": v for k, v in special.items()}, **{f"--{k}": v for k, v in special.items()}}
-
-    overrides = {}  # basic overrides, i.e. imgsz=320
-    for a in merge_equals_args(args):  # merge spaces around '=' sign
-        if a.startswith("--"):
-            LOGGER.warning(f"argument '{a}' does not require leading dashes '--', updating to '{a[2:]}'.")
-            a = a[2:]
-        if a.endswith(","):
-            LOGGER.warning(f"argument '{a}' does not require trailing comma ',', updating to '{a[:-1]}'.")
-            a = a[:-1]
-        if "=" in a:
-            try:
-                k, v = parse_key_value_pair(a)
-                if k == "cfg" and v is not None:  # custom.yaml passed
-                    LOGGER.info(f"Overriding {DEFAULT_CFG_PATH} with {v}")
-                    overrides = {k: val for k, val in YAML.load(checks.check_yaml(v)).items() if k != "cfg"}
-                else:
-                    overrides[k] = v
-            except (NameError, SyntaxError, ValueError, AssertionError) as e:
-                check_dict_alignment(full_args_dict, {a: ""}, e)
-
-        elif a in TASKS:
-            overrides["task"] = a
-        elif a in MODES:
-            overrides["mode"] = a
-        elif a.lower() in special:
-            special[a.lower()]()
-            return
-        elif a in DEFAULT_CFG_DICT and isinstance(DEFAULT_CFG_DICT[a], bool):
-            overrides[a] = True  # auto-True for default bool args, i.e. 'yolo show' sets show=True
-        elif a in DEFAULT_CFG_DICT:
-            raise SyntaxError(
-                f"'{colorstr('red', 'bold', a)}' is a valid YOLO argument but is missing an '=' sign "
-                f"to set its value, i.e. try '{a}={DEFAULT_CFG_DICT[a]}'\n{CLI_HELP_MSG}"
-            )
-        else:
-            check_dict_alignment(full_args_dict, {a: ""})
-
-    # Check keys
-    check_dict_alignment(full_args_dict, overrides)
-
-    # Mode
-    mode = overrides.get("mode")
-    if mode is None:
-        mode = DEFAULT_CFG.mode or "predict"
-        LOGGER.warning(f"'mode' argument is missing. Valid modes are {list(MODES)}. Using default 'mode={mode}'.")
-    elif mode not in MODES:
-        raise ValueError(f"Invalid 'mode={mode}'. Valid modes are {list(MODES)}.\n{CLI_HELP_MSG}")
-
-    # Task
-    task = overrides.pop("task", None)
-    if task:
-        if task not in TASKS:
-            if task == "track":
-                LOGGER.warning(
-                    f"invalid 'task=track', setting 'task=detect' and 'mode=track'. Valid tasks are {list(TASKS)}.\n{CLI_HELP_MSG}."
-                )
-                task, mode = "detect", "track"
-            else:
-                raise ValueError(f"Invalid 'task={task}'. Valid tasks are {list(TASKS)}.\n{CLI_HELP_MSG}")
-        if "model" not in overrides:
-            overrides["model"] = TASK2MODEL[task]
-
-    # Model
-    model = overrides.pop("model", DEFAULT_CFG.model)
-    if model is None:
-        model = "yolo26n.pt"
-        LOGGER.warning(f"'model' argument is missing. Using default 'model={model}'.")
-    overrides["model"] = model
-    stem = Path(model).stem.lower()
-    if "rtdetr" in stem:  # guess architecture
-        from ultralytics import RTDETR
-
-        model = RTDETR(model)  # no task argument
-    elif "fastsam" in stem:
-        from ultralytics import FastSAM
-
-        model = FastSAM(model)
-    elif "sam_" in stem or "sam2_" in stem or "sam2.1_" in stem:
-        from ultralytics import SAM
-
-        model = SAM(model)
-    else:
-        from ultralytics import YOLO
-
-        model = YOLO(model, task=task)
-        if "yoloe" in stem or "world" in stem:
-            cls_list = overrides.pop("classes", DEFAULT_CFG.classes)
-            if cls_list is not None and isinstance(cls_list, str):
-                model.set_classes(cls_list.split(","))  # convert "person, bus" -> ['person', ' bus'].
-    # Task Update
-    if task != model.task:
-        if task:
-            LOGGER.warning(
-                f"conflicting 'task={task}' passed with 'task={model.task}' model. "
-                f"Ignoring 'task={task}' and updating to 'task={model.task}' to match model."
-            )
-        task = model.task
-
-    # Mode
-    if mode in {"predict", "track"} and "source" not in overrides:
-        overrides["source"] = (
-            "https://ultralytics.com/images/boats.jpg" if task == "obb" else DEFAULT_CFG.source or ASSETS
-        )
-        LOGGER.warning(f"'source' argument is missing. Using default 'source={overrides['source']}'.")
-    elif mode in {"train", "val"}:
-        if "data" not in overrides and "resume" not in overrides:
-            overrides["data"] = DEFAULT_CFG.data or TASK2DATA.get(task or DEFAULT_CFG.task, DEFAULT_CFG.data)
-            LOGGER.warning(f"'data' argument is missing. Using default 'data={overrides['data']}'.")
-    elif mode == "export":
-        if "format" not in overrides:
-            overrides["format"] = DEFAULT_CFG.format or "torchscript"
-            LOGGER.warning(f"'format' argument is missing. Using default 'format={overrides['format']}'.")
-
-    # Run command in python
-    getattr(model, mode)(**overrides)  # default args from model
-
-    # Show help
-    LOGGER.info(f"💡 Learn more at https://docs.ultralytics.com/modes/{mode}")
-
-    # Recommend VS Code extension
-    if IS_VSCODE and SETTINGS.get("vscode_msg", True):
-        LOGGER.info(vscode_msg())
-
-
-# Special modes --------------------------------------------------------------------------------------------------------
-def copy_default_cfg() -> None:
-    """Copy the default configuration file and create a new one with '_copy' appended to its name.
-
-    This function duplicates the existing default configuration file (DEFAULT_CFG_PATH) and saves it with '_copy'
-    appended to its name in the current working directory. It provides a convenient way to create a custom configuration
-    file based on the default settings.
-
-    Examples:
-        >>> copy_default_cfg()
-        # Output: default.yaml copied to /path/to/current/directory/default_copy.yaml
-        # Example YOLO command with this new custom cfg:
-        #   yolo cfg='/path/to/current/directory/default_copy.yaml' imgsz=320 batch=8
-
-    Notes:
-        - The new configuration file is created in the current working directory.
-        - After copying, the function prints a message with the new file's location and an example
-          YOLO command demonstrating how to use the new configuration file.
-        - This function is useful for users who want to modify the default configuration without
-          altering the original file.
-    """
-    new_file = Path.cwd() / DEFAULT_CFG_PATH.name.replace(".yaml", "_copy.yaml")
-    shutil.copy2(DEFAULT_CFG_PATH, new_file)
-    LOGGER.info(
-        f"{DEFAULT_CFG_PATH} copied to {new_file}\n"
-        f"Example YOLO command with this new custom cfg:\n    yolo cfg='{new_file}' imgsz=320 batch=8"
-    )
-
-
-if __name__ == "__main__":
-    # Example: entrypoint(debug='yolo predict model=yolo26n.pt')
-    entrypoint(debug="")

vendor/ultralytics/cfg/datasets/Argoverse.yaml

@@ -1,78 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# Argoverse-HD dataset (ring-front-center camera) by Argo AI: https://www.cs.cmu.edu/~mengtial/proj/streaming/
-# Documentation: https://docs.ultralytics.com/datasets/detect/argoverse/
-# Example usage: yolo train data=Argoverse.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── Argoverse ← downloads here (31.5 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: Argoverse # dataset root dir
-train: Argoverse-1.1/images/train/ # train images (relative to 'path') 39384 images
-val: Argoverse-1.1/images/val/ # val images (relative to 'path') 15062 images
-test: Argoverse-1.1/images/test/ # test images (optional) https://eval.ai/web/challenges/challenge-page/800/overview
-
-# Classes
-names:
-  0: person
-  1: bicycle
-  2: car
-  3: motorcycle
-  4: bus
-  5: truck
-  6: traffic_light
-  7: stop_sign
-
-# Download script/URL (optional) ---------------------------------------------------------------------------------------
-download: |
-  import json
-  from pathlib import Path
-
-  from ultralytics.utils import TQDM
-  from ultralytics.utils.downloads import download
-
-  def argoverse2yolo(annotation_file):
-      """Convert Argoverse dataset annotations to YOLO format for object detection tasks."""
-      labels = {}
-      with open(annotation_file, encoding="utf-8") as f:
-          a = json.load(f)
-      for annot in TQDM(a["annotations"], desc=f"Converting {annotation_file} to YOLO format..."):
-          img_id = annot["image_id"]
-          img_name = a["images"][img_id]["name"]
-          img_label_name = f"{Path(img_name).stem}.txt"
-
-          cls = annot["category_id"]  # instance class id
-          x_center, y_center, width, height = annot["bbox"]
-          x_center = (x_center + width / 2) / 1920.0  # offset and scale
-          y_center = (y_center + height / 2) / 1200.0  # offset and scale
-          width /= 1920.0  # scale
-          height /= 1200.0  # scale
-
-          img_dir = annotation_file.parents[2] / "Argoverse-1.1" / "labels" / a["seq_dirs"][a["images"][annot["image_id"]]["sid"]]
-          if not img_dir.exists():
-              img_dir.mkdir(parents=True, exist_ok=True)
-
-          k = str(img_dir / img_label_name)
-          if k not in labels:
-              labels[k] = []
-          labels[k].append(f"{cls} {x_center} {y_center} {width} {height}\n")
-
-      for k in labels:
-          with open(k, "w", encoding="utf-8") as f:
-              f.writelines(labels[k])
-
-
-  # Download 'https://argoverse-hd.s3.us-east-2.amazonaws.com/Argoverse-HD-Full.zip' (deprecated S3 link)
-  dir = Path(yaml["path"])  # dataset root dir
-  urls = ["https://drive.google.com/file/d/1st9qW3BeIwQsnR0t8mRpvbsSWIo16ACi/view?usp=drive_link"]
-  print("\n\nWARNING: Argoverse dataset MUST be downloaded manually, autodownload will NOT work.")
-  print(f"WARNING: Manually download Argoverse dataset '{urls[0]}' to '{dir}' and re-run your command.\n\n")
-  # download(urls, dir=dir)
-
-  # Convert
-  annotations_dir = "Argoverse-HD/annotations/"
-  (dir / "Argoverse-1.1" / "tracking").rename(dir / "Argoverse-1.1" / "images")  # rename 'tracking' to 'images'
-  for d in "train.json", "val.json":
-      argoverse2yolo(dir / annotations_dir / d)  # convert Argoverse annotations to YOLO labels

vendor/ultralytics/cfg/datasets/DOTAv1.5.yaml

@@ -1,37 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# DOTA 1.5 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
-# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2/
-# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.5.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── dota1.5 ← downloads here (2 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: DOTAv1.5 # dataset root dir
-train: images/train # train images (relative to 'path') 1411 images
-val: images/val # val images (relative to 'path') 458 images
-test: images/test # test images (optional) 937 images
-
-# Classes for DOTA 1.5
-names:
-  0: plane
-  1: ship
-  2: storage tank
-  3: baseball diamond
-  4: tennis court
-  5: basketball court
-  6: ground track field
-  7: harbor
-  8: bridge
-  9: large vehicle
-  10: small vehicle
-  11: helicopter
-  12: roundabout
-  13: soccer ball field
-  14: swimming pool
-  15: container crane
-
-# Download script/URL (optional)
-download: https://github.com/ultralytics/assets/releases/download/v0.0.0/DOTAv1.5.zip

vendor/ultralytics/cfg/datasets/DOTAv1.yaml

@@ -1,36 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# DOTA 1.0 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
-# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2/
-# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── dota1 ← downloads here (2 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: DOTAv1 # dataset root dir
-train: images/train # train images (relative to 'path') 1411 images
-val: images/val # val images (relative to 'path') 458 images
-test: images/test # test images (optional) 937 images
-
-# Classes for DOTA 1.0
-names:
-  0: plane
-  1: ship
-  2: storage tank
-  3: baseball diamond
-  4: tennis court
-  5: basketball court
-  6: ground track field
-  7: harbor
-  8: bridge
-  9: large vehicle
-  10: small vehicle
-  11: helicopter
-  12: roundabout
-  13: soccer ball field
-  14: swimming pool
-
-# Download script/URL (optional)
-download: https://github.com/ultralytics/assets/releases/download/v0.0.0/DOTAv1.zip

vendor/ultralytics/cfg/datasets/GlobalWheat2020.yaml

@@ -1,68 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# Global Wheat 2020 dataset https://www.global-wheat.com/ by University of Saskatchewan
-# Documentation: https://docs.ultralytics.com/datasets/detect/globalwheat2020/
-# Example usage: yolo train data=GlobalWheat2020.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── GlobalWheat2020 ← downloads here (7.0 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: GlobalWheat2020 # dataset root dir
-train: # train images (relative to 'path') 3422 images
-  - images/arvalis_1
-  - images/arvalis_2
-  - images/arvalis_3
-  - images/ethz_1
-  - images/rres_1
-  - images/inrae_1
-  - images/usask_1
-val: # val images (relative to 'path') 748 images (WARNING: train set contains ethz_1)
-  - images/ethz_1
-test: # test images (optional) 1276 images
-  - images/utokyo_1
-  - images/utokyo_2
-  - images/nau_1
-  - images/uq_1
-
-# Classes
-names:
-  0: wheat_head
-
-# Download script/URL (optional) ---------------------------------------------------------------------------------------
-download: |
-  from pathlib import Path
-
-  from ultralytics.utils.downloads import download
-
-  # Download
-  dir = Path(yaml["path"])  # dataset root dir
-  urls = [
-      "https://zenodo.org/record/4298502/files/global-wheat-codalab-official.zip",
-      "https://github.com/ultralytics/assets/releases/download/v0.0.0/GlobalWheat2020_labels.zip",
-  ]
-  download(urls, dir=dir)
-
-  # Make Directories
-  for p in "annotations", "images", "labels":
-      (dir / p).mkdir(parents=True, exist_ok=True)
-
-  # Move
-  for p in (
-      "arvalis_1",
-      "arvalis_2",
-      "arvalis_3",
-      "ethz_1",
-      "rres_1",
-      "inrae_1",
-      "usask_1",
-      "utokyo_1",
-      "utokyo_2",
-      "nau_1",
-      "uq_1",
-  ):
-      (dir / "global-wheat-codalab-official" / p).rename(dir / "images" / p)  # move to /images
-      f = (dir / "global-wheat-codalab-official" / p).with_suffix(".json")  # json file
-      if f.exists():
-          f.rename((dir / "annotations" / p).with_suffix(".json"))  # move to /annotations

vendor/ultralytics/cfg/datasets/HomeObjects-3K.yaml

@@ -1,32 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# HomeObjects-3K dataset by Ultralytics
-# Documentation: https://docs.ultralytics.com/datasets/detect/homeobjects-3k/
-# Example usage: yolo train data=HomeObjects-3K.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── homeobjects-3K ← downloads here (390 MB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: homeobjects-3K # dataset root dir
-train: images/train # train images (relative to 'path') 2285 images
-val: images/val # val images (relative to 'path') 404 images
-
-# Classes
-names:
-  0: bed
-  1: sofa
-  2: chair
-  3: table
-  4: lamp
-  5: tv
-  6: laptop
-  7: wardrobe
-  8: window
-  9: door
-  10: potted plant
-  11: photo frame
-
-# Download script/URL (optional)
-download: https://github.com/ultralytics/assets/releases/download/v0.0.0/homeobjects-3K.zip

vendor/ultralytics/cfg/datasets/ImageNet.yaml

@@ -1,2025 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# ImageNet-1k dataset https://www.image-net.org/index.php by Stanford University
-# Simplified class names from https://github.com/anishathalye/imagenet-simple-labels
-# Documentation: https://docs.ultralytics.com/datasets/classify/imagenet/
-# Example usage: yolo train task=classify data=imagenet
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── imagenet ← downloads here (144 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: imagenet # dataset root dir
-train: train # train images (relative to 'path') 1281167 images
-val: val # val images (relative to 'path') 50000 images
-test: # test images (optional)
-
-# Classes
-names:
-  0: tench
-  1: goldfish
-  2: great white shark
-  3: tiger shark
-  4: hammerhead shark
-  5: electric ray
-  6: stingray
-  7: cock
-  8: hen
-  9: ostrich
-  10: brambling
-  11: goldfinch
-  12: house finch
-  13: junco
-  14: indigo bunting
-  15: American robin
-  16: bulbul
-  17: jay
-  18: magpie
-  19: chickadee
-  20: American dipper
-  21: kite
-  22: bald eagle
-  23: vulture
-  24: great grey owl
-  25: fire salamander
-  26: smooth newt
-  27: newt
-  28: spotted salamander
-  29: axolotl
-  30: American bullfrog
-  31: tree frog
-  32: tailed frog
-  33: loggerhead sea turtle
-  34: leatherback sea turtle
-  35: mud turtle
-  36: terrapin
-  37: box turtle
-  38: banded gecko
-  39: green iguana
-  40: Carolina anole
-  41: desert grassland whiptail lizard
-  42: agama
-  43: frilled-necked lizard
-  44: alligator lizard
-  45: Gila monster
-  46: European green lizard
-  47: chameleon
-  48: Komodo dragon
-  49: Nile crocodile
-  50: American alligator
-  51: triceratops
-  52: worm snake
-  53: ring-necked snake
-  54: eastern hog-nosed snake
-  55: smooth green snake
-  56: kingsnake
-  57: garter snake
-  58: water snake
-  59: vine snake
-  60: night snake
-  61: boa constrictor
-  62: African rock python
-  63: Indian cobra
-  64: green mamba
-  65: sea snake
-  66: Saharan horned viper
-  67: eastern diamondback rattlesnake
-  68: sidewinder
-  69: trilobite
-  70: harvestman
-  71: scorpion
-  72: yellow garden spider
-  73: barn spider
-  74: European garden spider
-  75: southern black widow
-  76: tarantula
-  77: wolf spider
-  78: tick
-  79: centipede
-  80: black grouse
-  81: ptarmigan
-  82: ruffed grouse
-  83: prairie grouse
-  84: peacock
-  85: quail
-  86: partridge
-  87: grey parrot
-  88: macaw
-  89: sulphur-crested cockatoo
-  90: lorikeet
-  91: coucal
-  92: bee eater
-  93: hornbill
-  94: hummingbird
-  95: jacamar
-  96: toucan
-  97: duck
-  98: red-breasted merganser
-  99: goose
-  100: black swan
-  101: tusker
-  102: echidna
-  103: platypus
-  104: wallaby
-  105: koala
-  106: wombat
-  107: jellyfish
-  108: sea anemone
-  109: brain coral
-  110: flatworm
-  111: nematode
-  112: conch
-  113: snail
-  114: slug
-  115: sea slug
-  116: chiton
-  117: chambered nautilus
-  118: Dungeness crab
-  119: rock crab
-  120: fiddler crab
-  121: red king crab
-  122: American lobster
-  123: spiny lobster
-  124: crayfish
-  125: hermit crab
-  126: isopod
-  127: white stork
-  128: black stork
-  129: spoonbill
-  130: flamingo
-  131: little blue heron
-  132: great egret
-  133: bittern
-  134: crane (bird)
-  135: limpkin
-  136: common gallinule
-  137: American coot
-  138: bustard
-  139: ruddy turnstone
-  140: dunlin
-  141: common redshank
-  142: dowitcher
-  143: oystercatcher
-  144: pelican
-  145: king penguin
-  146: albatross
-  147: grey whale
-  148: killer whale
-  149: dugong
-  150: sea lion
-  151: Chihuahua
-  152: Japanese Chin
-  153: Maltese
-  154: Pekingese
-  155: Shih Tzu
-  156: King Charles Spaniel
-  157: Papillon
-  158: toy terrier
-  159: Rhodesian Ridgeback
-  160: Afghan Hound
-  161: Basset Hound
-  162: Beagle
-  163: Bloodhound
-  164: Bluetick Coonhound
-  165: Black and Tan Coonhound
-  166: Treeing Walker Coonhound
-  167: English foxhound
-  168: Redbone Coonhound
-  169: borzoi
-  170: Irish Wolfhound
-  171: Italian Greyhound
-  172: Whippet
-  173: Ibizan Hound
-  174: Norwegian Elkhound
-  175: Otterhound
-  176: Saluki
-  177: Scottish Deerhound
-  178: Weimaraner
-  179: Staffordshire Bull Terrier
-  180: American Staffordshire Terrier
-  181: Bedlington Terrier
-  182: Border Terrier
-  183: Kerry Blue Terrier
-  184: Irish Terrier
-  185: Norfolk Terrier
-  186: Norwich Terrier
-  187: Yorkshire Terrier
-  188: Wire Fox Terrier
-  189: Lakeland Terrier
-  190: Sealyham Terrier
-  191: Airedale Terrier
-  192: Cairn Terrier
-  193: Australian Terrier
-  194: Dandie Dinmont Terrier
-  195: Boston Terrier
-  196: Miniature Schnauzer
-  197: Giant Schnauzer
-  198: Standard Schnauzer
-  199: Scottish Terrier
-  200: Tibetan Terrier
-  201: Australian Silky Terrier
-  202: Soft-coated Wheaten Terrier
-  203: West Highland White Terrier
-  204: Lhasa Apso
-  205: Flat-Coated Retriever
-  206: Curly-coated Retriever
-  207: Golden Retriever
-  208: Labrador Retriever
-  209: Chesapeake Bay Retriever
-  210: German Shorthaired Pointer
-  211: Vizsla
-  212: English Setter
-  213: Irish Setter
-  214: Gordon Setter
-  215: Brittany
-  216: Clumber Spaniel
-  217: English Springer Spaniel
-  218: Welsh Springer Spaniel
-  219: Cocker Spaniels
-  220: Sussex Spaniel
-  221: Irish Water Spaniel
-  222: Kuvasz
-  223: Schipperke
-  224: Groenendael
-  225: Malinois
-  226: Briard
-  227: Australian Kelpie
-  228: Komondor
-  229: Old English Sheepdog
-  230: Shetland Sheepdog
-  231: collie
-  232: Border Collie
-  233: Bouvier des Flandres
-  234: Rottweiler
-  235: German Shepherd Dog
-  236: Dobermann
-  237: Miniature Pinscher
-  238: Greater Swiss Mountain Dog
-  239: Bernese Mountain Dog
-  240: Appenzeller Sennenhund
-  241: Entlebucher Sennenhund
-  242: Boxer
-  243: Bullmastiff
-  244: Tibetan Mastiff
-  245: French Bulldog
-  246: Great Dane
-  247: St. Bernard
-  248: husky
-  249: Alaskan Malamute
-  250: Siberian Husky
-  251: Dalmatian
-  252: Affenpinscher
-  253: Basenji
-  254: pug
-  255: Leonberger
-  256: Newfoundland
-  257: Pyrenean Mountain Dog
-  258: Samoyed
-  259: Pomeranian
-  260: Chow Chow
-  261: Keeshond
-  262: Griffon Bruxellois
-  263: Pembroke Welsh Corgi
-  264: Cardigan Welsh Corgi
-  265: Toy Poodle
-  266: Miniature Poodle
-  267: Standard Poodle
-  268: Mexican hairless dog
-  269: grey wolf
-  270: Alaskan tundra wolf
-  271: red wolf
-  272: coyote
-  273: dingo
-  274: dhole
-  275: African wild dog
-  276: hyena
-  277: red fox
-  278: kit fox
-  279: Arctic fox
-  280: grey fox
-  281: tabby cat
-  282: tiger cat
-  283: Persian cat
-  284: Siamese cat
-  285: Egyptian Mau
-  286: cougar
-  287: lynx
-  288: leopard
-  289: snow leopard
-  290: jaguar
-  291: lion
-  292: tiger
-  293: cheetah
-  294: brown bear
-  295: American black bear
-  296: polar bear
-  297: sloth bear
-  298: mongoose
-  299: meerkat
-  300: tiger beetle
-  301: ladybug
-  302: ground beetle
-  303: longhorn beetle
-  304: leaf beetle
-  305: dung beetle
-  306: rhinoceros beetle
-  307: weevil
-  308: fly
-  309: bee
-  310: ant
-  311: grasshopper
-  312: cricket
-  313: stick insect
-  314: cockroach
-  315: mantis
-  316: cicada
-  317: leafhopper
-  318: lacewing
-  319: dragonfly
-  320: damselfly
-  321: red admiral
-  322: ringlet
-  323: monarch butterfly
-  324: small white
-  325: sulfur butterfly
-  326: gossamer-winged butterfly
-  327: starfish
-  328: sea urchin
-  329: sea cucumber
-  330: cottontail rabbit
-  331: hare
-  332: Angora rabbit
-  333: hamster
-  334: porcupine
-  335: fox squirrel
-  336: marmot
-  337: beaver
-  338: guinea pig
-  339: common sorrel
-  340: zebra
-  341: pig
-  342: wild boar
-  343: warthog
-  344: hippopotamus
-  345: ox
-  346: water buffalo
-  347: bison
-  348: ram
-  349: bighorn sheep
-  350: Alpine ibex
-  351: hartebeest
-  352: impala
-  353: gazelle
-  354: dromedary
-  355: llama
-  356: weasel
-  357: mink
-  358: European polecat
-  359: black-footed ferret
-  360: otter
-  361: skunk
-  362: badger
-  363: armadillo
-  364: three-toed sloth
-  365: orangutan
-  366: gorilla
-  367: chimpanzee
-  368: gibbon
-  369: siamang
-  370: guenon
-  371: patas monkey
-  372: baboon
-  373: macaque
-  374: langur
-  375: black-and-white colobus
-  376: proboscis monkey
-  377: marmoset
-  378: white-headed capuchin
-  379: howler monkey
-  380: titi
-  381: Geoffroy's spider monkey
-  382: common squirrel monkey
-  383: ring-tailed lemur
-  384: indri
-  385: Asian elephant
-  386: African bush elephant
-  387: red panda
-  388: giant panda
-  389: snoek
-  390: eel
-  391: coho salmon
-  392: rock beauty
-  393: clownfish
-  394: sturgeon
-  395: garfish
-  396: lionfish
-  397: pufferfish
-  398: abacus
-  399: abaya
-  400: academic gown
-  401: accordion
-  402: acoustic guitar
-  403: aircraft carrier
-  404: airliner
-  405: airship
-  406: altar
-  407: ambulance
-  408: amphibious vehicle
-  409: analog clock
-  410: apiary
-  411: apron
-  412: waste container
-  413: assault rifle
-  414: backpack
-  415: bakery
-  416: balance beam
-  417: balloon
-  418: ballpoint pen
-  419: Band-Aid
-  420: banjo
-  421: baluster
-  422: barbell
-  423: barber chair
-  424: barbershop
-  425: barn
-  426: barometer
-  427: barrel
-  428: wheelbarrow
-  429: baseball
-  430: basketball
-  431: bassinet
-  432: bassoon
-  433: swimming cap
-  434: bath towel
-  435: bathtub
-  436: station wagon
-  437: lighthouse
-  438: beaker
-  439: military cap
-  440: beer bottle
-  441: beer glass
-  442: bell-cot
-  443: bib
-  444: tandem bicycle
-  445: bikini
-  446: ring binder
-  447: binoculars
-  448: birdhouse
-  449: boathouse
-  450: bobsleigh
-  451: bolo tie
-  452: poke bonnet
-  453: bookcase
-  454: bookstore
-  455: bottle cap
-  456: bow
-  457: bow tie
-  458: brass
-  459: bra
-  460: breakwater
-  461: breastplate
-  462: broom
-  463: bucket
-  464: buckle
-  465: bulletproof vest
-  466: high-speed train
-  467: butcher shop
-  468: taxicab
-  469: cauldron
-  470: candle
-  471: cannon
-  472: canoe
-  473: can opener
-  474: cardigan
-  475: car mirror
-  476: carousel
-  477: tool kit
-  478: carton
-  479: car wheel
-  480: automated teller machine
-  481: cassette
-  482: cassette player
-  483: castle
-  484: catamaran
-  485: CD player
-  486: cello
-  487: mobile phone
-  488: chain
-  489: chain-link fence
-  490: chain mail
-  491: chainsaw
-  492: chest
-  493: chiffonier
-  494: chime
-  495: china cabinet
-  496: Christmas stocking
-  497: church
-  498: movie theater
-  499: cleaver
-  500: cliff dwelling
-  501: cloak
-  502: clogs
-  503: cocktail shaker
-  504: coffee mug
-  505: coffeemaker
-  506: coil
-  507: combination lock
-  508: computer keyboard
-  509: confectionery store
-  510: container ship
-  511: convertible
-  512: corkscrew
-  513: cornet
-  514: cowboy boot
-  515: cowboy hat
-  516: cradle
-  517: crane (machine)
-  518: crash helmet
-  519: crate
-  520: infant bed
-  521: Crock Pot
-  522: croquet ball
-  523: crutch
-  524: cuirass
-  525: dam
-  526: desk
-  527: desktop computer
-  528: rotary dial telephone
-  529: diaper
-  530: digital clock
-  531: digital watch
-  532: dining table
-  533: dishcloth
-  534: dishwasher
-  535: disc brake
-  536: dock
-  537: dog sled
-  538: dome
-  539: doormat
-  540: drilling rig
-  541: drum
-  542: drumstick
-  543: dumbbell
-  544: Dutch oven
-  545: electric fan
-  546: electric guitar
-  547: electric locomotive
-  548: entertainment center
-  549: envelope
-  550: espresso machine
-  551: face powder
-  552: feather boa
-  553: filing cabinet
-  554: fireboat
-  555: fire engine
-  556: fire screen sheet
-  557: flagpole
-  558: flute
-  559: folding chair
-  560: football helmet
-  561: forklift
-  562: fountain
-  563: fountain pen
-  564: four-poster bed
-  565: freight car
-  566: French horn
-  567: frying pan
-  568: fur coat
-  569: garbage truck
-  570: gas mask
-  571: gas pump
-  572: goblet
-  573: go-kart
-  574: golf ball
-  575: golf cart
-  576: gondola
-  577: gong
-  578: gown
-  579: grand piano
-  580: greenhouse
-  581: grille
-  582: grocery store
-  583: guillotine
-  584: barrette
-  585: hair spray
-  586: half-track
-  587: hammer
-  588: hamper
-  589: hair dryer
-  590: hand-held computer
-  591: handkerchief
-  592: hard disk drive
-  593: harmonica
-  594: harp
-  595: harvester
-  596: hatchet
-  597: holster
-  598: home theater
-  599: honeycomb
-  600: hook
-  601: hoop skirt
-  602: horizontal bar
-  603: horse-drawn vehicle
-  604: hourglass
-  605: iPod
-  606: clothes iron
-  607: jack-o'-lantern
-  608: jeans
-  609: jeep
-  610: T-shirt
-  611: jigsaw puzzle
-  612: pulled rickshaw
-  613: joystick
-  614: kimono
-  615: knee pad
-  616: knot
-  617: lab coat
-  618: ladle
-  619: lampshade
-  620: laptop computer
-  621: lawn mower
-  622: lens cap
-  623: paper knife
-  624: library
-  625: lifeboat
-  626: lighter
-  627: limousine
-  628: ocean liner
-  629: lipstick
-  630: slip-on shoe
-  631: lotion
-  632: speaker
-  633: loupe
-  634: sawmill
-  635: magnetic compass
-  636: mail bag
-  637: mailbox
-  638: tights
-  639: tank suit
-  640: manhole cover
-  641: maraca
-  642: marimba
-  643: mask
-  644: match
-  645: maypole
-  646: maze
-  647: measuring cup
-  648: medicine chest
-  649: megalith
-  650: microphone
-  651: microwave oven
-  652: military uniform
-  653: milk can
-  654: minibus
-  655: miniskirt
-  656: minivan
-  657: missile
-  658: mitten
-  659: mixing bowl
-  660: mobile home
-  661: Model T
-  662: modem
-  663: monastery
-  664: monitor
-  665: moped
-  666: mortar
-  667: square academic cap
-  668: mosque
-  669: mosquito net
-  670: scooter
-  671: mountain bike
-  672: tent
-  673: computer mouse
-  674: mousetrap
-  675: moving van
-  676: muzzle
-  677: nail
-  678: neck brace
-  679: necklace
-  680: nipple
-  681: notebook computer
-  682: obelisk
-  683: oboe
-  684: ocarina
-  685: odometer
-  686: oil filter
-  687: organ
-  688: oscilloscope
-  689: overskirt
-  690: bullock cart
-  691: oxygen mask
-  692: packet
-  693: paddle
-  694: paddle wheel
-  695: padlock
-  696: paintbrush
-  697: pajamas
-  698: palace
-  699: pan flute
-  700: paper towel
-  701: parachute
-  702: parallel bars
-  703: park bench
-  704: parking meter
-  705: passenger car
-  706: patio
-  707: payphone
-  708: pedestal
-  709: pencil case
-  710: pencil sharpener
-  711: perfume
-  712: Petri dish
-  713: photocopier
-  714: plectrum
-  715: Pickelhaube
-  716: picket fence
-  717: pickup truck
-  718: pier
-  719: piggy bank
-  720: pill bottle
-  721: pillow
-  722: ping-pong ball
-  723: pinwheel
-  724: pirate ship
-  725: pitcher
-  726: hand plane
-  727: planetarium
-  728: plastic bag
-  729: plate rack
-  730: plow
-  731: plunger
-  732: Polaroid camera
-  733: pole
-  734: police van
-  735: poncho
-  736: billiard table
-  737: soda bottle
-  738: pot
-  739: potter's wheel
-  740: power drill
-  741: prayer rug
-  742: printer
-  743: prison
-  744: projectile
-  745: projector
-  746: hockey puck
-  747: punching bag
-  748: purse
-  749: quill
-  750: quilt
-  751: race car
-  752: racket
-  753: radiator
-  754: radio
-  755: radio telescope
-  756: rain barrel
-  757: recreational vehicle
-  758: reel
-  759: reflex camera
-  760: refrigerator
-  761: remote control
-  762: restaurant
-  763: revolver
-  764: rifle
-  765: rocking chair
-  766: rotisserie
-  767: eraser
-  768: rugby ball
-  769: ruler
-  770: running shoe
-  771: safe
-  772: safety pin
-  773: salt shaker
-  774: sandal
-  775: sarong
-  776: saxophone
-  777: scabbard
-  778: weighing scale
-  779: school bus
-  780: schooner
-  781: scoreboard
-  782: CRT screen
-  783: screw
-  784: screwdriver
-  785: seat belt
-  786: sewing machine
-  787: shield
-  788: shoe store
-  789: shoji
-  790: shopping basket
-  791: shopping cart
-  792: shovel
-  793: shower cap
-  794: shower curtain
-  795: ski
-  796: ski mask
-  797: sleeping bag
-  798: slide rule
-  799: sliding door
-  800: slot machine
-  801: snorkel
-  802: snowmobile
-  803: snowplow
-  804: soap dispenser
-  805: soccer ball
-  806: sock
-  807: solar thermal collector
-  808: sombrero
-  809: soup bowl
-  810: space bar
-  811: space heater
-  812: space shuttle
-  813: spatula
-  814: motorboat
-  815: spider web
-  816: spindle
-  817: sports car
-  818: spotlight
-  819: stage
-  820: steam locomotive
-  821: through arch bridge
-  822: steel drum
-  823: stethoscope
-  824: scarf
-  825: stone wall
-  826: stopwatch
-  827: stove
-  828: strainer
-  829: tram
-  830: stretcher
-  831: couch
-  832: stupa
-  833: submarine
-  834: suit
-  835: sundial
-  836: sunglass
-  837: sunglasses
-  838: sunscreen
-  839: suspension bridge
-  840: mop
-  841: sweatshirt
-  842: swimsuit
-  843: swing
-  844: switch
-  845: syringe
-  846: table lamp
-  847: tank
-  848: tape player
-  849: teapot
-  850: teddy bear
-  851: television
-  852: tennis ball
-  853: thatched roof
-  854: front curtain
-  855: thimble
-  856: threshing machine
-  857: throne
-  858: tile roof
-  859: toaster
-  860: tobacco shop
-  861: toilet seat
-  862: torch
-  863: totem pole
-  864: tow truck
-  865: toy store
-  866: tractor
-  867: semi-trailer truck
-  868: tray
-  869: trench coat
-  870: tricycle
-  871: trimaran
-  872: tripod
-  873: triumphal arch
-  874: trolleybus
-  875: trombone
-  876: tub
-  877: turnstile
-  878: typewriter keyboard
-  879: umbrella
-  880: unicycle
-  881: upright piano
-  882: vacuum cleaner
-  883: vase
-  884: vault
-  885: velvet
-  886: vending machine
-  887: vestment
-  888: viaduct
-  889: violin
-  890: volleyball
-  891: waffle iron
-  892: wall clock
-  893: wallet
-  894: wardrobe
-  895: military aircraft
-  896: sink
-  897: washing machine
-  898: water bottle
-  899: water jug
-  900: water tower
-  901: whiskey jug
-  902: whistle
-  903: wig
-  904: window screen
-  905: window shade
-  906: Windsor tie
-  907: wine bottle
-  908: wing
-  909: wok
-  910: wooden spoon
-  911: wool
-  912: split-rail fence
-  913: shipwreck
-  914: yawl
-  915: yurt
-  916: website
-  917: comic book
-  918: crossword
-  919: traffic sign
-  920: traffic light
-  921: dust jacket
-  922: menu
-  923: plate
-  924: guacamole
-  925: consomme
-  926: hot pot
-  927: trifle
-  928: ice cream
-  929: ice pop
-  930: baguette
-  931: bagel
-  932: pretzel
-  933: cheeseburger
-  934: hot dog
-  935: mashed potato
-  936: cabbage
-  937: broccoli
-  938: cauliflower
-  939: zucchini
-  940: spaghetti squash
-  941: acorn squash
-  942: butternut squash
-  943: cucumber
-  944: artichoke
-  945: bell pepper
-  946: cardoon
-  947: mushroom
-  948: Granny Smith
-  949: strawberry
-  950: orange
-  951: lemon
-  952: fig
-  953: pineapple
-  954: banana
-  955: jackfruit
-  956: custard apple
-  957: pomegranate
-  958: hay
-  959: carbonara
-  960: chocolate syrup
-  961: dough
-  962: meatloaf
-  963: pizza
-  964: pot pie
-  965: burrito
-  966: red wine
-  967: espresso
-  968: cup
-  969: eggnog
-  970: alp
-  971: bubble
-  972: cliff
-  973: coral reef
-  974: geyser
-  975: lakeshore
-  976: promontory
-  977: shoal
-  978: seashore
-  979: valley
-  980: volcano
-  981: baseball player
-  982: bridegroom
-  983: scuba diver
-  984: rapeseed
-  985: daisy
-  986: yellow lady's slipper
-  987: corn
-  988: acorn
-  989: rose hip
-  990: horse chestnut seed
-  991: coral fungus
-  992: agaric
-  993: gyromitra
-  994: stinkhorn mushroom
-  995: earth star
-  996: hen-of-the-woods
-  997: bolete
-  998: ear
-  999: toilet paper
-
-# Imagenet class codes to human-readable names
-map:
-  n01440764: tench
-  n01443537: goldfish
-  n01484850: great_white_shark
-  n01491361: tiger_shark
-  n01494475: hammerhead
-  n01496331: electric_ray
-  n01498041: stingray
-  n01514668: cock
-  n01514859: hen
-  n01518878: ostrich
-  n01530575: brambling
-  n01531178: goldfinch
-  n01532829: house_finch
-  n01534433: junco
-  n01537544: indigo_bunting
-  n01558993: robin
-  n01560419: bulbul
-  n01580077: jay
-  n01582220: magpie
-  n01592084: chickadee
-  n01601694: water_ouzel
-  n01608432: kite
-  n01614925: bald_eagle
-  n01616318: vulture
-  n01622779: great_grey_owl
-  n01629819: European_fire_salamander
-  n01630670: common_newt
-  n01631663: eft
-  n01632458: spotted_salamander
-  n01632777: axolotl
-  n01641577: bullfrog
-  n01644373: tree_frog
-  n01644900: tailed_frog
-  n01664065: loggerhead
-  n01665541: leatherback_turtle
-  n01667114: mud_turtle
-  n01667778: terrapin
-  n01669191: box_turtle
-  n01675722: banded_gecko
-  n01677366: common_iguana
-  n01682714: American_chameleon
-  n01685808: whiptail
-  n01687978: agama
-  n01688243: frilled_lizard
-  n01689811: alligator_lizard
-  n01692333: Gila_monster
-  n01693334: green_lizard
-  n01694178: African_chameleon
-  n01695060: Komodo_dragon
-  n01697457: African_crocodile
-  n01698640: American_alligator
-  n01704323: triceratops
-  n01728572: thunder_snake
-  n01728920: ringneck_snake
-  n01729322: hognose_snake
-  n01729977: green_snake
-  n01734418: king_snake
-  n01735189: garter_snake
-  n01737021: water_snake
-  n01739381: vine_snake
-  n01740131: night_snake
-  n01742172: boa_constrictor
-  n01744401: rock_python
-  n01748264: Indian_cobra
-  n01749939: green_mamba
-  n01751748: sea_snake
-  n01753488: horned_viper
-  n01755581: diamondback
-  n01756291: sidewinder
-  n01768244: trilobite
-  n01770081: harvestman
-  n01770393: scorpion
-  n01773157: black_and_gold_garden_spider
-  n01773549: barn_spider
-  n01773797: garden_spider
-  n01774384: black_widow
-  n01774750: tarantula
-  n01775062: wolf_spider
-  n01776313: tick
-  n01784675: centipede
-  n01795545: black_grouse
-  n01796340: ptarmigan
-  n01797886: ruffed_grouse
-  n01798484: prairie_chicken
-  n01806143: peacock
-  n01806567: quail
-  n01807496: partridge
-  n01817953: African_grey
-  n01818515: macaw
-  n01819313: sulphur-crested_cockatoo
-  n01820546: lorikeet
-  n01824575: coucal
-  n01828970: bee_eater
-  n01829413: hornbill
-  n01833805: hummingbird
-  n01843065: jacamar
-  n01843383: toucan
-  n01847000: drake
-  n01855032: red-breasted_merganser
-  n01855672: goose
-  n01860187: black_swan
-  n01871265: tusker
-  n01872401: echidna
-  n01873310: platypus
-  n01877812: wallaby
-  n01882714: koala
-  n01883070: wombat
-  n01910747: jellyfish
-  n01914609: sea_anemone
-  n01917289: brain_coral
-  n01924916: flatworm
-  n01930112: nematode
-  n01943899: conch
-  n01944390: snail
-  n01945685: slug
-  n01950731: sea_slug
-  n01955084: chiton
-  n01968897: chambered_nautilus
-  n01978287: Dungeness_crab
-  n01978455: rock_crab
-  n01980166: fiddler_crab
-  n01981276: king_crab
-  n01983481: American_lobster
-  n01984695: spiny_lobster
-  n01985128: crayfish
-  n01986214: hermit_crab
-  n01990800: isopod
-  n02002556: white_stork
-  n02002724: black_stork
-  n02006656: spoonbill
-  n02007558: flamingo
-  n02009229: little_blue_heron
-  n02009912: American_egret
-  n02011460: bittern
-  n02012849: crane_(bird)
-  n02013706: limpkin
-  n02017213: European_gallinule
-  n02018207: American_coot
-  n02018795: bustard
-  n02025239: ruddy_turnstone
-  n02027492: red-backed_sandpiper
-  n02028035: redshank
-  n02033041: dowitcher
-  n02037110: oystercatcher
-  n02051845: pelican
-  n02056570: king_penguin
-  n02058221: albatross
-  n02066245: grey_whale
-  n02071294: killer_whale
-  n02074367: dugong
-  n02077923: sea_lion
-  n02085620: Chihuahua
-  n02085782: Japanese_spaniel
-  n02085936: Maltese_dog
-  n02086079: Pekinese
-  n02086240: Shih-Tzu
-  n02086646: Blenheim_spaniel
-  n02086910: papillon
-  n02087046: toy_terrier
-  n02087394: Rhodesian_ridgeback
-  n02088094: Afghan_hound
-  n02088238: basset
-  n02088364: beagle
-  n02088466: bloodhound
-  n02088632: bluetick
-  n02089078: black-and-tan_coonhound
-  n02089867: Walker_hound
-  n02089973: English_foxhound
-  n02090379: redbone
-  n02090622: borzoi
-  n02090721: Irish_wolfhound
-  n02091032: Italian_greyhound
-  n02091134: whippet
-  n02091244: Ibizan_hound
-  n02091467: Norwegian_elkhound
-  n02091635: otterhound
-  n02091831: Saluki
-  n02092002: Scottish_deerhound
-  n02092339: Weimaraner
-  n02093256: Staffordshire_bullterrier
-  n02093428: American_Staffordshire_terrier
-  n02093647: Bedlington_terrier
-  n02093754: Border_terrier
-  n02093859: Kerry_blue_terrier
-  n02093991: Irish_terrier
-  n02094114: Norfolk_terrier
-  n02094258: Norwich_terrier
-  n02094433: Yorkshire_terrier
-  n02095314: wire-haired_fox_terrier
-  n02095570: Lakeland_terrier
-  n02095889: Sealyham_terrier
-  n02096051: Airedale
-  n02096177: cairn
-  n02096294: Australian_terrier
-  n02096437: Dandie_Dinmont
-  n02096585: Boston_bull
-  n02097047: miniature_schnauzer
-  n02097130: giant_schnauzer
-  n02097209: standard_schnauzer
-  n02097298: Scotch_terrier
-  n02097474: Tibetan_terrier
-  n02097658: silky_terrier
-  n02098105: soft-coated_wheaten_terrier
-  n02098286: West_Highland_white_terrier
-  n02098413: Lhasa
-  n02099267: flat-coated_retriever
-  n02099429: curly-coated_retriever
-  n02099601: golden_retriever
-  n02099712: Labrador_retriever
-  n02099849: Chesapeake_Bay_retriever
-  n02100236: German_short-haired_pointer
-  n02100583: vizsla
-  n02100735: English_setter
-  n02100877: Irish_setter
-  n02101006: Gordon_setter
-  n02101388: Brittany_spaniel
-  n02101556: clumber
-  n02102040: English_springer
-  n02102177: Welsh_springer_spaniel
-  n02102318: cocker_spaniel
-  n02102480: Sussex_spaniel
-  n02102973: Irish_water_spaniel
-  n02104029: kuvasz
-  n02104365: schipperke
-  n02105056: groenendael
-  n02105162: malinois
-  n02105251: briard
-  n02105412: kelpie
-  n02105505: komondor
-  n02105641: Old_English_sheepdog
-  n02105855: Shetland_sheepdog
-  n02106030: collie
-  n02106166: Border_collie
-  n02106382: Bouvier_des_Flandres
-  n02106550: Rottweiler
-  n02106662: German_shepherd
-  n02107142: Doberman
-  n02107312: miniature_pinscher
-  n02107574: Greater_Swiss_Mountain_dog
-  n02107683: Bernese_mountain_dog
-  n02107908: Appenzeller
-  n02108000: EntleBucher
-  n02108089: boxer
-  n02108422: bull_mastiff
-  n02108551: Tibetan_mastiff
-  n02108915: French_bulldog
-  n02109047: Great_Dane
-  n02109525: Saint_Bernard
-  n02109961: Eskimo_dog
-  n02110063: malamute
-  n02110185: Siberian_husky
-  n02110341: dalmatian
-  n02110627: affenpinscher
-  n02110806: basenji
-  n02110958: pug
-  n02111129: Leonberg
-  n02111277: Newfoundland
-  n02111500: Great_Pyrenees
-  n02111889: Samoyed
-  n02112018: Pomeranian
-  n02112137: chow
-  n02112350: keeshond
-  n02112706: Brabancon_griffon
-  n02113023: Pembroke
-  n02113186: Cardigan
-  n02113624: toy_poodle
-  n02113712: miniature_poodle
-  n02113799: standard_poodle
-  n02113978: Mexican_hairless
-  n02114367: timber_wolf
-  n02114548: white_wolf
-  n02114712: red_wolf
-  n02114855: coyote
-  n02115641: dingo
-  n02115913: dhole
-  n02116738: African_hunting_dog
-  n02117135: hyena
-  n02119022: red_fox
-  n02119789: kit_fox
-  n02120079: Arctic_fox
-  n02120505: grey_fox
-  n02123045: tabby
-  n02123159: tiger_cat
-  n02123394: Persian_cat
-  n02123597: Siamese_cat
-  n02124075: Egyptian_cat
-  n02125311: cougar
-  n02127052: lynx
-  n02128385: leopard
-  n02128757: snow_leopard
-  n02128925: jaguar
-  n02129165: lion
-  n02129604: tiger
-  n02130308: cheetah
-  n02132136: brown_bear
-  n02133161: American_black_bear
-  n02134084: ice_bear
-  n02134418: sloth_bear
-  n02137549: mongoose
-  n02138441: meerkat
-  n02165105: tiger_beetle
-  n02165456: ladybug
-  n02167151: ground_beetle
-  n02168699: long-horned_beetle
-  n02169497: leaf_beetle
-  n02172182: dung_beetle
-  n02174001: rhinoceros_beetle
-  n02177972: weevil
-  n02190166: fly
-  n02206856: bee
-  n02219486: ant
-  n02226429: grasshopper
-  n02229544: cricket
-  n02231487: walking_stick
-  n02233338: cockroach
-  n02236044: mantis
-  n02256656: cicada
-  n02259212: leafhopper
-  n02264363: lacewing
-  n02268443: dragonfly
-  n02268853: damselfly
-  n02276258: admiral
-  n02277742: ringlet
-  n02279972: monarch
-  n02280649: cabbage_butterfly
-  n02281406: sulphur_butterfly
-  n02281787: lycaenid
-  n02317335: starfish
-  n02319095: sea_urchin
-  n02321529: sea_cucumber
-  n02325366: wood_rabbit
-  n02326432: hare
-  n02328150: Angora
-  n02342885: hamster
-  n02346627: porcupine
-  n02356798: fox_squirrel
-  n02361337: marmot
-  n02363005: beaver
-  n02364673: guinea_pig
-  n02389026: sorrel
-  n02391049: zebra
-  n02395406: hog
-  n02396427: wild_boar
-  n02397096: warthog
-  n02398521: hippopotamus
-  n02403003: ox
-  n02408429: water_buffalo
-  n02410509: bison
-  n02412080: ram
-  n02415577: bighorn
-  n02417914: ibex
-  n02422106: hartebeest
-  n02422699: impala
-  n02423022: gazelle
-  n02437312: Arabian_camel
-  n02437616: llama
-  n02441942: weasel
-  n02442845: mink
-  n02443114: polecat
-  n02443484: black-footed_ferret
-  n02444819: otter
-  n02445715: skunk
-  n02447366: badger
-  n02454379: armadillo
-  n02457408: three-toed_sloth
-  n02480495: orangutan
-  n02480855: gorilla
-  n02481823: chimpanzee
-  n02483362: gibbon
-  n02483708: siamang
-  n02484975: guenon
-  n02486261: patas
-  n02486410: baboon
-  n02487347: macaque
-  n02488291: langur
-  n02488702: colobus
-  n02489166: proboscis_monkey
-  n02490219: marmoset
-  n02492035: capuchin
-  n02492660: howler_monkey
-  n02493509: titi
-  n02493793: spider_monkey
-  n02494079: squirrel_monkey
-  n02497673: Madagascar_cat
-  n02500267: indri
-  n02504013: Indian_elephant
-  n02504458: African_elephant
-  n02509815: lesser_panda
-  n02510455: giant_panda
-  n02514041: barracouta
-  n02526121: eel
-  n02536864: coho
-  n02606052: rock_beauty
-  n02607072: anemone_fish
-  n02640242: sturgeon
-  n02641379: gar
-  n02643566: lionfish
-  n02655020: puffer
-  n02666196: abacus
-  n02667093: abaya
-  n02669723: academic_gown
-  n02672831: accordion
-  n02676566: acoustic_guitar
-  n02687172: aircraft_carrier
-  n02690373: airliner
-  n02692877: airship
-  n02699494: altar
-  n02701002: ambulance
-  n02704792: amphibian
-  n02708093: analog_clock
-  n02727426: apiary
-  n02730930: apron
-  n02747177: ashcan
-  n02749479: assault_rifle
-  n02769748: backpack
-  n02776631: bakery
-  n02777292: balance_beam
-  n02782093: balloon
-  n02783161: ballpoint
-  n02786058: Band_Aid
-  n02787622: banjo
-  n02788148: bannister
-  n02790996: barbell
-  n02791124: barber_chair
-  n02791270: barbershop
-  n02793495: barn
-  n02794156: barometer
-  n02795169: barrel
-  n02797295: barrow
-  n02799071: baseball
-  n02802426: basketball
-  n02804414: bassinet
-  n02804610: bassoon
-  n02807133: bathing_cap
-  n02808304: bath_towel
-  n02808440: bathtub
-  n02814533: beach_wagon
-  n02814860: beacon
-  n02815834: beaker
-  n02817516: bearskin
-  n02823428: beer_bottle
-  n02823750: beer_glass
-  n02825657: bell_cote
-  n02834397: bib
-  n02835271: bicycle-built-for-two
-  n02837789: bikini
-  n02840245: binder
-  n02841315: binoculars
-  n02843684: birdhouse
-  n02859443: boathouse
-  n02860847: bobsled
-  n02865351: bolo_tie
-  n02869837: bonnet
-  n02870880: bookcase
-  n02871525: bookshop
-  n02877765: bottlecap
-  n02879718: bow
-  n02883205: bow_tie
-  n02892201: brass
-  n02892767: brassiere
-  n02894605: breakwater
-  n02895154: breastplate
-  n02906734: broom
-  n02909870: bucket
-  n02910353: buckle
-  n02916936: bulletproof_vest
-  n02917067: bullet_train
-  n02927161: butcher_shop
-  n02930766: cab
-  n02939185: caldron
-  n02948072: candle
-  n02950826: cannon
-  n02951358: canoe
-  n02951585: can_opener
-  n02963159: cardigan
-  n02965783: car_mirror
-  n02966193: carousel
-  n02966687: carpenter's_kit
-  n02971356: carton
-  n02974003: car_wheel
-  n02977058: cash_machine
-  n02978881: cassette
-  n02979186: cassette_player
-  n02980441: castle
-  n02981792: catamaran
-  n02988304: CD_player
-  n02992211: cello
-  n02992529: cellular_telephone
-  n02999410: chain
-  n03000134: chainlink_fence
-  n03000247: chain_mail
-  n03000684: chain_saw
-  n03014705: chest
-  n03016953: chiffonier
-  n03017168: chime
-  n03018349: china_cabinet
-  n03026506: Christmas_stocking
-  n03028079: church
-  n03032252: cinema
-  n03041632: cleaver
-  n03042490: cliff_dwelling
-  n03045698: cloak
-  n03047690: clog
-  n03062245: cocktail_shaker
-  n03063599: coffee_mug
-  n03063689: coffeepot
-  n03065424: coil
-  n03075370: combination_lock
-  n03085013: computer_keyboard
-  n03089624: confectionery
-  n03095699: container_ship
-  n03100240: convertible
-  n03109150: corkscrew
-  n03110669: cornet
-  n03124043: cowboy_boot
-  n03124170: cowboy_hat
-  n03125729: cradle
-  n03126707: crane_(machine)
-  n03127747: crash_helmet
-  n03127925: crate
-  n03131574: crib
-  n03133878: Crock_Pot
-  n03134739: croquet_ball
-  n03141823: crutch
-  n03146219: cuirass
-  n03160309: dam
-  n03179701: desk
-  n03180011: desktop_computer
-  n03187595: dial_telephone
-  n03188531: diaper
-  n03196217: digital_clock
-  n03197337: digital_watch
-  n03201208: dining_table
-  n03207743: dishrag
-  n03207941: dishwasher
-  n03208938: disk_brake
-  n03216828: dock
-  n03218198: dogsled
-  n03220513: dome
-  n03223299: doormat
-  n03240683: drilling_platform
-  n03249569: drum
-  n03250847: drumstick
-  n03255030: dumbbell
-  n03259280: Dutch_oven
-  n03271574: electric_fan
-  n03272010: electric_guitar
-  n03272562: electric_locomotive
-  n03290653: entertainment_center
-  n03291819: envelope
-  n03297495: espresso_maker
-  n03314780: face_powder
-  n03325584: feather_boa
-  n03337140: file
-  n03344393: fireboat
-  n03345487: fire_engine
-  n03347037: fire_screen
-  n03355925: flagpole
-  n03372029: flute
-  n03376595: folding_chair
-  n03379051: football_helmet
-  n03384352: forklift
-  n03388043: fountain
-  n03388183: fountain_pen
-  n03388549: four-poster
-  n03393912: freight_car
-  n03394916: French_horn
-  n03400231: frying_pan
-  n03404251: fur_coat
-  n03417042: garbage_truck
-  n03424325: gasmask
-  n03425413: gas_pump
-  n03443371: goblet
-  n03444034: go-kart
-  n03445777: golf_ball
-  n03445924: golfcart
-  n03447447: gondola
-  n03447721: gong
-  n03450230: gown
-  n03452741: grand_piano
-  n03457902: greenhouse
-  n03459775: grille
-  n03461385: grocery_store
-  n03467068: guillotine
-  n03476684: hair_slide
-  n03476991: hair_spray
-  n03478589: half_track
-  n03481172: hammer
-  n03482405: hamper
-  n03483316: hand_blower
-  n03485407: hand-held_computer
-  n03485794: handkerchief
-  n03492542: hard_disc
-  n03494278: harmonica
-  n03495258: harp
-  n03496892: harvester
-  n03498962: hatchet
-  n03527444: holster
-  n03529860: home_theater
-  n03530642: honeycomb
-  n03532672: hook
-  n03534580: hoopskirt
-  n03535780: horizontal_bar
-  n03538406: horse_cart
-  n03544143: hourglass
-  n03584254: iPod
-  n03584829: iron
-  n03590841: jack-o'-lantern
-  n03594734: jean
-  n03594945: jeep
-  n03595614: jersey
-  n03598930: jigsaw_puzzle
-  n03599486: jinrikisha
-  n03602883: joystick
-  n03617480: kimono
-  n03623198: knee_pad
-  n03627232: knot
-  n03630383: lab_coat
-  n03633091: ladle
-  n03637318: lampshade
-  n03642806: laptop
-  n03649909: lawn_mower
-  n03657121: lens_cap
-  n03658185: letter_opener
-  n03661043: library
-  n03662601: lifeboat
-  n03666591: lighter
-  n03670208: limousine
-  n03673027: liner
-  n03676483: lipstick
-  n03680355: Loafer
-  n03690938: lotion
-  n03691459: loudspeaker
-  n03692522: loupe
-  n03697007: lumbermill
-  n03706229: magnetic_compass
-  n03709823: mailbag
-  n03710193: mailbox
-  n03710637: maillot_(tights)
-  n03710721: maillot_(tank_suit)
-  n03717622: manhole_cover
-  n03720891: maraca
-  n03721384: marimba
-  n03724870: mask
-  n03729826: matchstick
-  n03733131: maypole
-  n03733281: maze
-  n03733805: measuring_cup
-  n03742115: medicine_chest
-  n03743016: megalith
-  n03759954: microphone
-  n03761084: microwave
-  n03763968: military_uniform
-  n03764736: milk_can
-  n03769881: minibus
-  n03770439: miniskirt
-  n03770679: minivan
-  n03773504: missile
-  n03775071: mitten
-  n03775546: mixing_bowl
-  n03776460: mobile_home
-  n03777568: Model_T
-  n03777754: modem
-  n03781244: monastery
-  n03782006: monitor
-  n03785016: moped
-  n03786901: mortar
-  n03787032: mortarboard
-  n03788195: mosque
-  n03788365: mosquito_net
-  n03791053: motor_scooter
-  n03792782: mountain_bike
-  n03792972: mountain_tent
-  n03793489: mouse
-  n03794056: mousetrap
-  n03796401: moving_van
-  n03803284: muzzle
-  n03804744: nail
-  n03814639: neck_brace
-  n03814906: necklace
-  n03825788: nipple
-  n03832673: notebook
-  n03837869: obelisk
-  n03838899: oboe
-  n03840681: ocarina
-  n03841143: odometer
-  n03843555: oil_filter
-  n03854065: organ
-  n03857828: oscilloscope
-  n03866082: overskirt
-  n03868242: oxcart
-  n03868863: oxygen_mask
-  n03871628: packet
-  n03873416: paddle
-  n03874293: paddlewheel
-  n03874599: padlock
-  n03876231: paintbrush
-  n03877472: pajama
-  n03877845: palace
-  n03884397: panpipe
-  n03887697: paper_towel
-  n03888257: parachute
-  n03888605: parallel_bars
-  n03891251: park_bench
-  n03891332: parking_meter
-  n03895866: passenger_car
-  n03899768: patio
-  n03902125: pay-phone
-  n03903868: pedestal
-  n03908618: pencil_box
-  n03908714: pencil_sharpener
-  n03916031: perfume
-  n03920288: Petri_dish
-  n03924679: photocopier
-  n03929660: pick
-  n03929855: pickelhaube
-  n03930313: picket_fence
-  n03930630: pickup
-  n03933933: pier
-  n03935335: piggy_bank
-  n03937543: pill_bottle
-  n03938244: pillow
-  n03942813: ping-pong_ball
-  n03944341: pinwheel
-  n03947888: pirate
-  n03950228: pitcher
-  n03954731: plane
-  n03956157: planetarium
-  n03958227: plastic_bag
-  n03961711: plate_rack
-  n03967562: plow
-  n03970156: plunger
-  n03976467: Polaroid_camera
-  n03976657: pole
-  n03977966: police_van
-  n03980874: poncho
-  n03982430: pool_table
-  n03983396: pop_bottle
-  n03991062: pot
-  n03992509: potter's_wheel
-  n03995372: power_drill
-  n03998194: prayer_rug
-  n04004767: printer
-  n04005630: prison
-  n04008634: projectile
-  n04009552: projector
-  n04019541: puck
-  n04023962: punching_bag
-  n04026417: purse
-  n04033901: quill
-  n04033995: quilt
-  n04037443: racer
-  n04039381: racket
-  n04040759: radiator
-  n04041544: radio
-  n04044716: radio_telescope
-  n04049303: rain_barrel
-  n04065272: recreational_vehicle
-  n04067472: reel
-  n04069434: reflex_camera
-  n04070727: refrigerator
-  n04074963: remote_control
-  n04081281: restaurant
-  n04086273: revolver
-  n04090263: rifle
-  n04099969: rocking_chair
-  n04111531: rotisserie
-  n04116512: rubber_eraser
-  n04118538: rugby_ball
-  n04118776: rule
-  n04120489: running_shoe
-  n04125021: safe
-  n04127249: safety_pin
-  n04131690: saltshaker
-  n04133789: sandal
-  n04136333: sarong
-  n04141076: sax
-  n04141327: scabbard
-  n04141975: scale
-  n04146614: school_bus
-  n04147183: schooner
-  n04149813: scoreboard
-  n04152593: screen
-  n04153751: screw
-  n04154565: screwdriver
-  n04162706: seat_belt
-  n04179913: sewing_machine
-  n04192698: shield
-  n04200800: shoe_shop
-  n04201297: shoji
-  n04204238: shopping_basket
-  n04204347: shopping_cart
-  n04208210: shovel
-  n04209133: shower_cap
-  n04209239: shower_curtain
-  n04228054: ski
-  n04229816: ski_mask
-  n04235860: sleeping_bag
-  n04238763: slide_rule
-  n04239074: sliding_door
-  n04243546: slot
-  n04251144: snorkel
-  n04252077: snowmobile
-  n04252225: snowplow
-  n04254120: soap_dispenser
-  n04254680: soccer_ball
-  n04254777: sock
-  n04258138: solar_dish
-  n04259630: sombrero
-  n04263257: soup_bowl
-  n04264628: space_bar
-  n04265275: space_heater
-  n04266014: space_shuttle
-  n04270147: spatula
-  n04273569: speedboat
-  n04275548: spider_web
-  n04277352: spindle
-  n04285008: sports_car
-  n04286575: spotlight
-  n04296562: stage
-  n04310018: steam_locomotive
-  n04311004: steel_arch_bridge
-  n04311174: steel_drum
-  n04317175: stethoscope
-  n04325704: stole
-  n04326547: stone_wall
-  n04328186: stopwatch
-  n04330267: stove
-  n04332243: strainer
-  n04335435: streetcar
-  n04336792: stretcher
-  n04344873: studio_couch
-  n04346328: stupa
-  n04347754: submarine
-  n04350905: suit
-  n04355338: sundial
-  n04355933: sunglass
-  n04356056: sunglasses
-  n04357314: sunscreen
-  n04366367: suspension_bridge
-  n04367480: swab
-  n04370456: sweatshirt
-  n04371430: swimming_trunks
-  n04371774: swing
-  n04372370: switch
-  n04376876: syringe
-  n04380533: table_lamp
-  n04389033: tank
-  n04392985: tape_player
-  n04398044: teapot
-  n04399382: teddy
-  n04404412: television
-  n04409515: tennis_ball
-  n04417672: thatch
-  n04418357: theater_curtain
-  n04423845: thimble
-  n04428191: thresher
-  n04429376: throne
-  n04435653: tile_roof
-  n04442312: toaster
-  n04443257: tobacco_shop
-  n04447861: toilet_seat
-  n04456115: torch
-  n04458633: totem_pole
-  n04461696: tow_truck
-  n04462240: toyshop
-  n04465501: tractor
-  n04467665: trailer_truck
-  n04476259: tray
-  n04479046: trench_coat
-  n04482393: tricycle
-  n04483307: trimaran
-  n04485082: tripod
-  n04486054: triumphal_arch
-  n04487081: trolleybus
-  n04487394: trombone
-  n04493381: tub
-  n04501370: turnstile
-  n04505470: typewriter_keyboard
-  n04507155: umbrella
-  n04509417: unicycle
-  n04515003: upright
-  n04517823: vacuum
-  n04522168: vase
-  n04523525: vault
-  n04525038: velvet
-  n04525305: vending_machine
-  n04532106: vestment
-  n04532670: viaduct
-  n04536866: violin
-  n04540053: volleyball
-  n04542943: waffle_iron
-  n04548280: wall_clock
-  n04548362: wallet
-  n04550184: wardrobe
-  n04552348: warplane
-  n04553703: washbasin
-  n04554684: washer
-  n04557648: water_bottle
-  n04560804: water_jug
-  n04562935: water_tower
-  n04579145: whiskey_jug
-  n04579432: whistle
-  n04584207: wig
-  n04589890: window_screen
-  n04590129: window_shade
-  n04591157: Windsor_tie
-  n04591713: wine_bottle
-  n04592741: wing
-  n04596742: wok
-  n04597913: wooden_spoon
-  n04599235: wool
-  n04604644: worm_fence
-  n04606251: wreck
-  n04612504: yawl
-  n04613696: yurt
-  n06359193: web_site
-  n06596364: comic_book
-  n06785654: crossword_puzzle
-  n06794110: street_sign
-  n06874185: traffic_light
-  n07248320: book_jacket
-  n07565083: menu
-  n07579787: plate
-  n07583066: guacamole
-  n07584110: consomme
-  n07590611: hot_pot
-  n07613480: trifle
-  n07614500: ice_cream
-  n07615774: ice_lolly
-  n07684084: French_loaf
-  n07693725: bagel
-  n07695742: pretzel
-  n07697313: cheeseburger
-  n07697537: hotdog
-  n07711569: mashed_potato
-  n07714571: head_cabbage
-  n07714990: broccoli
-  n07715103: cauliflower
-  n07716358: zucchini
-  n07716906: spaghetti_squash
-  n07717410: acorn_squash
-  n07717556: butternut_squash
-  n07718472: cucumber
-  n07718747: artichoke
-  n07720875: bell_pepper
-  n07730033: cardoon
-  n07734744: mushroom
-  n07742313: Granny_Smith
-  n07745940: strawberry
-  n07747607: orange
-  n07749582: lemon
-  n07753113: fig
-  n07753275: pineapple
-  n07753592: banana
-  n07754684: jackfruit
-  n07760859: custard_apple
-  n07768694: pomegranate
-  n07802026: hay
-  n07831146: carbonara
-  n07836838: chocolate_sauce
-  n07860988: dough
-  n07871810: meat_loaf
-  n07873807: pizza
-  n07875152: potpie
-  n07880968: burrito
-  n07892512: red_wine
-  n07920052: espresso
-  n07930864: cup
-  n07932039: eggnog
-  n09193705: alp
-  n09229709: bubble
-  n09246464: cliff
-  n09256479: coral_reef
-  n09288635: geyser
-  n09332890: lakeside
-  n09399592: promontory
-  n09421951: sandbar
-  n09428293: seashore
-  n09468604: valley
-  n09472597: volcano
-  n09835506: ballplayer
-  n10148035: groom
-  n10565667: scuba_diver
-  n11879895: rapeseed
-  n11939491: daisy
-  n12057211: yellow_lady's_slipper
-  n12144580: corn
-  n12267677: acorn
-  n12620546: hip
-  n12768682: buckeye
-  n12985857: coral_fungus
-  n12998815: agaric
-  n13037406: gyromitra
-  n13040303: stinkhorn
-  n13044778: earthstar
-  n13052670: hen-of-the-woods
-  n13054560: bolete
-  n13133613: ear
-  n15075141: toilet_tissue
-
-# Download script/URL (optional)
-download: ultralytics/data/scripts/get_imagenet.sh

vendor/ultralytics/cfg/datasets/Objects365.yaml

@@ -1,447 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# Objects365 dataset https://www.objects365.org/ by Megvii
-# Documentation: https://docs.ultralytics.com/datasets/detect/objects365/
-# Example usage: yolo train data=Objects365.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── Objects365 ← downloads here (712 GB = 367G data + 345G zips)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: Objects365 # dataset root dir
-train: images/train # train images (relative to 'path') 1742289 images
-val: images/val # val images (relative to 'path') 80000 images
-test: # test images (optional)
-
-# Classes
-names:
-  0: Person
-  1: Sneakers
-  2: Chair
-  3: Other Shoes
-  4: Hat
-  5: Car
-  6: Lamp
-  7: Glasses
-  8: Bottle
-  9: Desk
-  10: Cup
-  11: Street Lights
-  12: Cabinet/shelf
-  13: Handbag/Satchel
-  14: Bracelet
-  15: Plate
-  16: Picture/Frame
-  17: Helmet
-  18: Book
-  19: Gloves
-  20: Storage box
-  21: Boat
-  22: Leather Shoes
-  23: Flower
-  24: Bench
-  25: Potted Plant
-  26: Bowl/Basin
-  27: Flag
-  28: Pillow
-  29: Boots
-  30: Vase
-  31: Microphone
-  32: Necklace
-  33: Ring
-  34: SUV
-  35: Wine Glass
-  36: Belt
-  37: Monitor/TV
-  38: Backpack
-  39: Umbrella
-  40: Traffic Light
-  41: Speaker
-  42: Watch
-  43: Tie
-  44: Trash bin Can
-  45: Slippers
-  46: Bicycle
-  47: Stool
-  48: Barrel/bucket
-  49: Van
-  50: Couch
-  51: Sandals
-  52: Basket
-  53: Drum
-  54: Pen/Pencil
-  55: Bus
-  56: Wild Bird
-  57: High Heels
-  58: Motorcycle
-  59: Guitar
-  60: Carpet
-  61: Cell Phone
-  62: Bread
-  63: Camera
-  64: Canned
-  65: Truck
-  66: Traffic cone
-  67: Cymbal
-  68: Lifesaver
-  69: Towel
-  70: Stuffed Toy
-  71: Candle
-  72: Sailboat
-  73: Laptop
-  74: Awning
-  75: Bed
-  76: Faucet
-  77: Tent
-  78: Horse
-  79: Mirror
-  80: Power outlet
-  81: Sink
-  82: Apple
-  83: Air Conditioner
-  84: Knife
-  85: Hockey Stick
-  86: Paddle
-  87: Pickup Truck
-  88: Fork
-  89: Traffic Sign
-  90: Balloon
-  91: Tripod
-  92: Dog
-  93: Spoon
-  94: Clock
-  95: Pot
-  96: Cow
-  97: Cake
-  98: Dining Table
-  99: Sheep
-  100: Hanger
-  101: Blackboard/Whiteboard
-  102: Napkin
-  103: Other Fish
-  104: Orange/Tangerine
-  105: Toiletry
-  106: Keyboard
-  107: Tomato
-  108: Lantern
-  109: Machinery Vehicle
-  110: Fan
-  111: Green Vegetables
-  112: Banana
-  113: Baseball Glove
-  114: Airplane
-  115: Mouse
-  116: Train
-  117: Pumpkin
-  118: Soccer
-  119: Skiboard
-  120: Luggage
-  121: Nightstand
-  122: Tea pot
-  123: Telephone
-  124: Trolley
-  125: Head Phone
-  126: Sports Car
-  127: Stop Sign
-  128: Dessert
-  129: Scooter
-  130: Stroller
-  131: Crane
-  132: Remote
-  133: Refrigerator
-  134: Oven
-  135: Lemon
-  136: Duck
-  137: Baseball Bat
-  138: Surveillance Camera
-  139: Cat
-  140: Jug
-  141: Broccoli
-  142: Piano
-  143: Pizza
-  144: Elephant
-  145: Skateboard
-  146: Surfboard
-  147: Gun
-  148: Skating and Skiing shoes
-  149: Gas stove
-  150: Donut
-  151: Bow Tie
-  152: Carrot
-  153: Toilet
-  154: Kite
-  155: Strawberry
-  156: Other Balls
-  157: Shovel
-  158: Pepper
-  159: Computer Box
-  160: Toilet Paper
-  161: Cleaning Products
-  162: Chopsticks
-  163: Microwave
-  164: Pigeon
-  165: Baseball
-  166: Cutting/chopping Board
-  167: Coffee Table
-  168: Side Table
-  169: Scissors
-  170: Marker
-  171: Pie
-  172: Ladder
-  173: Snowboard
-  174: Cookies
-  175: Radiator
-  176: Fire Hydrant
-  177: Basketball
-  178: Zebra
-  179: Grape
-  180: Giraffe
-  181: Potato
-  182: Sausage
-  183: Tricycle
-  184: Violin
-  185: Egg
-  186: Fire Extinguisher
-  187: Candy
-  188: Fire Truck
-  189: Billiards
-  190: Converter
-  191: Bathtub
-  192: Wheelchair
-  193: Golf Club
-  194: Briefcase
-  195: Cucumber
-  196: Cigar/Cigarette
-  197: Paint Brush
-  198: Pear
-  199: Heavy Truck
-  200: Hamburger
-  201: Extractor
-  202: Extension Cord
-  203: Tong
-  204: Tennis Racket
-  205: Folder
-  206: American Football
-  207: earphone
-  208: Mask
-  209: Kettle
-  210: Tennis
-  211: Ship
-  212: Swing
-  213: Coffee Machine
-  214: Slide
-  215: Carriage
-  216: Onion
-  217: Green beans
-  218: Projector
-  219: Frisbee
-  220: Washing Machine/Drying Machine
-  221: Chicken
-  222: Printer
-  223: Watermelon
-  224: Saxophone
-  225: Tissue
-  226: Toothbrush
-  227: Ice cream
-  228: Hot-air balloon
-  229: Cello
-  230: French Fries
-  231: Scale
-  232: Trophy
-  233: Cabbage
-  234: Hot dog
-  235: Blender
-  236: Peach
-  237: Rice
-  238: Wallet/Purse
-  239: Volleyball
-  240: Deer
-  241: Goose
-  242: Tape
-  243: Tablet
-  244: Cosmetics
-  245: Trumpet
-  246: Pineapple
-  247: Golf Ball
-  248: Ambulance
-  249: Parking meter
-  250: Mango
-  251: Key
-  252: Hurdle
-  253: Fishing Rod
-  254: Medal
-  255: Flute
-  256: Brush
-  257: Penguin
-  258: Megaphone
-  259: Corn
-  260: Lettuce
-  261: Garlic
-  262: Swan
-  263: Helicopter
-  264: Green Onion
-  265: Sandwich
-  266: Nuts
-  267: Speed Limit Sign
-  268: Induction Cooker
-  269: Broom
-  270: Trombone
-  271: Plum
-  272: Rickshaw
-  273: Goldfish
-  274: Kiwi fruit
-  275: Router/modem
-  276: Poker Card
-  277: Toaster
-  278: Shrimp
-  279: Sushi
-  280: Cheese
-  281: Notepaper
-  282: Cherry
-  283: Pliers
-  284: CD
-  285: Pasta
-  286: Hammer
-  287: Cue
-  288: Avocado
-  289: Hami melon
-  290: Flask
-  291: Mushroom
-  292: Screwdriver
-  293: Soap
-  294: Recorder
-  295: Bear
-  296: Eggplant
-  297: Board Eraser
-  298: Coconut
-  299: Tape Measure/Ruler
-  300: Pig
-  301: Showerhead
-  302: Globe
-  303: Chips
-  304: Steak
-  305: Crosswalk Sign
-  306: Stapler
-  307: Camel
-  308: Formula 1
-  309: Pomegranate
-  310: Dishwasher
-  311: Crab
-  312: Hoverboard
-  313: Meatball
-  314: Rice Cooker
-  315: Tuba
-  316: Calculator
-  317: Papaya
-  318: Antelope
-  319: Parrot
-  320: Seal
-  321: Butterfly
-  322: Dumbbell
-  323: Donkey
-  324: Lion
-  325: Urinal
-  326: Dolphin
-  327: Electric Drill
-  328: Hair Dryer
-  329: Egg tart
-  330: Jellyfish
-  331: Treadmill
-  332: Lighter
-  333: Grapefruit
-  334: Game board
-  335: Mop
-  336: Radish
-  337: Baozi
-  338: Target
-  339: French
-  340: Spring Rolls
-  341: Monkey
-  342: Rabbit
-  343: Pencil Case
-  344: Yak
-  345: Red Cabbage
-  346: Binoculars
-  347: Asparagus
-  348: Barbell
-  349: Scallop
-  350: Noddles
-  351: Comb
-  352: Dumpling
-  353: Oyster
-  354: Table Tennis paddle
-  355: Cosmetics Brush/Eyeliner Pencil
-  356: Chainsaw
-  357: Eraser
-  358: Lobster
-  359: Durian
-  360: Okra
-  361: Lipstick
-  362: Cosmetics Mirror
-  363: Curling
-  364: Table Tennis
-
-# Download script/URL (optional) ---------------------------------------------------------------------------------------
-download: |
-  from concurrent.futures import ThreadPoolExecutor
-  from pathlib import Path
-
-  import numpy as np
-
-  from ultralytics.utils import TQDM
-  from ultralytics.utils.checks import check_requirements
-  from ultralytics.utils.downloads import download
-  from ultralytics.utils.ops import xyxy2xywhn
-
-  check_requirements("faster-coco-eval")
-  from faster_coco_eval import COCO
-
-  # Train, Val Splits
-  dir = Path(yaml["path"])
-  for split, patches in [("train", 50 + 1), ("val", 43 + 1)]:
-      print(f"Processing {split} in {patches} patches ...")
-      images, labels = dir / "images" / split, dir / "labels" / split
-      images.mkdir(parents=True, exist_ok=True)
-      labels.mkdir(parents=True, exist_ok=True)
-
-      # Download
-      url = f"https://dorc.ks3-cn-beijing.ksyun.com/data-set/2020Objects365%E6%95%B0%E6%8D%AE%E9%9B%86/{split}/"
-      if split == "train":
-          download([f"{url}zhiyuan_objv2_{split}.tar.gz"], dir=dir)  # annotations json
-          download([f"{url}patch{i}.tar.gz" for i in range(patches)], dir=images, threads=17)  # 51 patches / 17 threads = 3
-      elif split == "val":
-          download([f"{url}zhiyuan_objv2_{split}.json"], dir=dir)  # annotations json
-          download([f"{url}images/v1/patch{i}.tar.gz" for i in range(15 + 1)], dir=images, threads=16)
-          download([f"{url}images/v2/patch{i}.tar.gz" for i in range(16, patches)], dir=images, threads=16)
-
-      # Move
-      files = list(images.rglob("*.jpg"))
-      with ThreadPoolExecutor(max_workers=16) as executor:
-          list(TQDM(executor.map(lambda f: f.rename(images / f.name), files), total=len(files), desc=f"Moving {split} images"))
-
-      # Labels
-      coco = COCO(dir / f"zhiyuan_objv2_{split}.json")
-      names = [x["name"] for x in coco.loadCats(coco.getCatIds())]
-      for cid, cat in enumerate(names):
-          catIds = coco.getCatIds(catNms=[cat])
-          imgIds = coco.getImgIds(catIds=catIds)
-
-          def process_annotation(im):
-              """Process and write annotations for a single image."""
-              try:
-                  width, height = im["width"], im["height"]
-                  path = Path(im["file_name"])
-                  with open(labels / path.with_suffix(".txt").name, "a", encoding="utf-8") as file:
-                      annIds = coco.getAnnIds(imgIds=im["id"], catIds=catIds, iscrowd=None)
-                      for a in coco.loadAnns(annIds):
-                          x, y, w, h = a["bbox"]  # bounding box in xywh (xy top-left corner)
-                          xyxy = np.array([x, y, x + w, y + h])[None]  # pixels(1,4)
-                          x, y, w, h = xyxy2xywhn(xyxy, w=width, h=height, clip=True)[0]  # normalized and clipped
-                          file.write(f"{cid} {x:.5f} {y:.5f} {w:.5f} {h:.5f}\n")
-              except Exception as e:
-                  print(e)
-
-          images_list = coco.loadImgs(imgIds)
-          with ThreadPoolExecutor(max_workers=16) as executor:
-              list(TQDM(executor.map(process_annotation, images_list), total=len(images_list), desc=f"Class {cid + 1}/{len(names)} {cat}"))

vendor/ultralytics/cfg/datasets/SKU-110K.yaml

@@ -1,58 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# SKU-110K retail items dataset https://github.com/eg4000/SKU110K_CVPR19 by Trax Retail
-# Documentation: https://docs.ultralytics.com/datasets/detect/sku-110k/
-# Example usage: yolo train data=SKU-110K.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── SKU-110K ← downloads here (13.6 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: SKU-110K # dataset root dir
-train: train.txt # train images (relative to 'path') 8219 images
-val: val.txt # val images (relative to 'path') 588 images
-test: test.txt # test images (optional) 2936 images
-
-# Classes
-names:
-  0: object
-
-# Download script/URL (optional) ---------------------------------------------------------------------------------------
-download: |
-  import shutil
-  from pathlib import Path
-
-  import numpy as np
-  import polars as pl
-
-  from ultralytics.utils import TQDM
-  from ultralytics.utils.downloads import download
-  from ultralytics.utils.ops import xyxy2xywh
-
-  # Download
-  dir = Path(yaml["path"])  # dataset root dir
-  parent = Path(dir.parent)  # download dir
-  urls = ["http://trax-geometry.s3.amazonaws.com/cvpr_challenge/SKU110K_fixed.tar.gz"]
-  download(urls, dir=parent)
-
-  # Rename directories
-  if dir.exists():
-      shutil.rmtree(dir)
-  (parent / "SKU110K_fixed").rename(dir)  # rename dir
-  (dir / "labels").mkdir(parents=True, exist_ok=True)  # create labels dir
-
-  # Convert labels
-  names = "image", "x1", "y1", "x2", "y2", "class", "image_width", "image_height"  # column names
-  for d in "annotations_train.csv", "annotations_val.csv", "annotations_test.csv":
-      x = pl.read_csv(dir / "annotations" / d, has_header=False, new_columns=names, infer_schema_length=None).to_numpy()  # annotations
-      images, unique_images = x[:, 0], np.unique(x[:, 0])
-      with open((dir / d).with_suffix(".txt").__str__().replace("annotations_", ""), "w", encoding="utf-8") as f:
-          f.writelines(f"./images/{s}\n" for s in unique_images)
-      for im in TQDM(unique_images, desc=f"Converting {dir / d}"):
-          cls = 0  # single-class dataset
-          with open((dir / "labels" / im).with_suffix(".txt"), "a", encoding="utf-8") as f:
-              for r in x[images == im]:
-                  w, h = r[6], r[7]  # image width, height
-                  xywh = xyxy2xywh(np.array([[r[1] / w, r[2] / h, r[3] / w, r[4] / h]]))[0]  # instance
-                  f.write(f"{cls} {xywh[0]:.5f} {xywh[1]:.5f} {xywh[2]:.5f} {xywh[3]:.5f}\n")  # write label

vendor/ultralytics/cfg/datasets/TT100K.yaml

@@ -1,346 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# Tsinghua-Tencent 100K (TT100K) dataset https://cg.cs.tsinghua.edu.cn/traffic-sign/ by Tsinghua University
-# Documentation: https://cg.cs.tsinghua.edu.cn/traffic-sign/tutorial.html
-# Paper: Traffic-Sign Detection and Classification in the Wild (CVPR 2016)
-# License: CC BY-NC 2.0 license for non-commercial use only
-# Example usage: yolo train data=TT100K.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── TT100K ← downloads here (~18 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: TT100K # dataset root dir
-train: images/train # train images (relative to 'path') 6105 images
-val: images/val # val images (relative to 'path') 7641 images (original 'other' split)
-test: images/test # test images (relative to 'path') 3071 images
-
-# Classes (221 traffic sign categories, 45 with sufficient training instances)
-names:
-  0: pl5
-  1: pl10
-  2: pl15
-  3: pl20
-  4: pl25
-  5: pl30
-  6: pl40
-  7: pl50
-  8: pl60
-  9: pl70
-  10: pl80
-  11: pl90
-  12: pl100
-  13: pl110
-  14: pl120
-  15: pm5
-  16: pm10
-  17: pm13
-  18: pm15
-  19: pm20
-  20: pm25
-  21: pm30
-  22: pm35
-  23: pm40
-  24: pm46
-  25: pm50
-  26: pm55
-  27: pm8
-  28: pn
-  29: pne
-  30: ph4
-  31: ph4.5
-  32: ph5
-  33: ps
-  34: pg
-  35: ph1.5
-  36: ph2
-  37: ph2.1
-  38: ph2.2
-  39: ph2.4
-  40: ph2.5
-  41: ph2.8
-  42: ph2.9
-  43: ph3
-  44: ph3.2
-  45: ph3.5
-  46: ph3.8
-  47: ph4.2
-  48: ph4.3
-  49: ph4.8
-  50: ph5.3
-  51: ph5.5
-  52: pb
-  53: pr10
-  54: pr100
-  55: pr20
-  56: pr30
-  57: pr40
-  58: pr45
-  59: pr50
-  60: pr60
-  61: pr70
-  62: pr80
-  63: pr90
-  64: p1
-  65: p2
-  66: p3
-  67: p4
-  68: p5
-  69: p6
-  70: p7
-  71: p8
-  72: p9
-  73: p10
-  74: p11
-  75: p12
-  76: p13
-  77: p14
-  78: p15
-  79: p16
-  80: p17
-  81: p18
-  82: p19
-  83: p20
-  84: p21
-  85: p22
-  86: p23
-  87: p24
-  88: p25
-  89: p26
-  90: p27
-  91: p28
-  92: pa8
-  93: pa10
-  94: pa12
-  95: pa13
-  96: pa14
-  97: pb5
-  98: pc
-  99: pg
-  100: ph1
-  101: ph1.3
-  102: ph1.5
-  103: ph2
-  104: ph3
-  105: ph4
-  106: ph5
-  107: pi
-  108: pl0
-  109: pl4
-  110: pl5
-  111: pl8
-  112: pl10
-  113: pl15
-  114: pl20
-  115: pl25
-  116: pl30
-  117: pl35
-  118: pl40
-  119: pl50
-  120: pl60
-  121: pl65
-  122: pl70
-  123: pl80
-  124: pl90
-  125: pl100
-  126: pl110
-  127: pl120
-  128: pm2
-  129: pm8
-  130: pm10
-  131: pm13
-  132: pm15
-  133: pm20
-  134: pm25
-  135: pm30
-  136: pm35
-  137: pm40
-  138: pm46
-  139: pm50
-  140: pm55
-  141: pn
-  142: pne
-  143: po
-  144: pr10
-  145: pr100
-  146: pr20
-  147: pr30
-  148: pr40
-  149: pr45
-  150: pr50
-  151: pr60
-  152: pr70
-  153: pr80
-  154: ps
-  155: w1
-  156: w2
-  157: w3
-  158: w5
-  159: w8
-  160: w10
-  161: w12
-  162: w13
-  163: w16
-  164: w18
-  165: w20
-  166: w21
-  167: w22
-  168: w24
-  169: w28
-  170: w30
-  171: w31
-  172: w32
-  173: w34
-  174: w35
-  175: w37
-  176: w38
-  177: w41
-  178: w42
-  179: w43
-  180: w44
-  181: w45
-  182: w46
-  183: w47
-  184: w48
-  185: w49
-  186: w50
-  187: w51
-  188: w52
-  189: w53
-  190: w54
-  191: w55
-  192: w56
-  193: w57
-  194: w58
-  195: w59
-  196: w60
-  197: w62
-  198: w63
-  199: w66
-  200: i1
-  201: i2
-  202: i3
-  203: i4
-  204: i5
-  205: i6
-  206: i7
-  207: i8
-  208: i9
-  209: i10
-  210: i11
-  211: i12
-  212: i13
-  213: i14
-  214: i15
-  215: il60
-  216: il80
-  217: il100
-  218: il110
-  219: io
-  220: ip
-
-# Download script/URL (optional) ---------------------------------------------------------------------------------------
-download: |
-  import json
-  import shutil
-  from pathlib import Path
-
-  from PIL import Image
-
-  from ultralytics.utils import TQDM
-  from ultralytics.utils.downloads import download
-
-
-  def tt100k2yolo(dir):
-      """Convert TT100K annotations to YOLO format with images/{split} and labels/{split} structure."""
-      data_dir = dir / "data"
-      anno_file = data_dir / "annotations.json"
-
-      print("Loading annotations...")
-      with open(anno_file, encoding="utf-8") as f:
-          data = json.load(f)
-
-      # Build class name to index mapping from yaml
-      names = yaml["names"]
-      class_to_idx = {v: k for k, v in names.items()}
-
-      # Create directories
-      for split in ["train", "val", "test"]:
-          (dir / "images" / split).mkdir(parents=True, exist_ok=True)
-          (dir / "labels" / split).mkdir(parents=True, exist_ok=True)
-
-      print("Converting annotations to YOLO format...")
-      skipped = 0
-      for img_id, img_data in TQDM(data["imgs"].items(), desc="Processing"):
-          img_path_str = img_data["path"]
-          if "train" in img_path_str:
-              split = "train"
-          elif "test" in img_path_str:
-              split = "test"
-          else:
-              split = "val"
-
-          # Source and destination paths
-          src_img = data_dir / img_path_str
-          if not src_img.exists():
-              continue
-
-          dst_img = dir / "images" / split / src_img.name
-
-          # Get image dimensions
-          try:
-              with Image.open(src_img) as img:
-                  img_width, img_height = img.size
-          except Exception as e:
-              print(f"Error reading {src_img}: {e}")
-              continue
-
-          # Copy image to destination
-          shutil.copy2(src_img, dst_img)
-
-          # Convert annotations
-          label_file = dir / "labels" / split / f"{src_img.stem}.txt"
-          lines = []
-
-          for obj in img_data.get("objects", []):
-              category = obj["category"]
-              if category not in class_to_idx:
-                  skipped += 1
-                  continue
-
-              bbox = obj["bbox"]
-              xmin, ymin = bbox["xmin"], bbox["ymin"]
-              xmax, ymax = bbox["xmax"], bbox["ymax"]
-
-              # Convert to YOLO format (normalized center coordinates and dimensions)
-              x_center = ((xmin + xmax) / 2.0) / img_width
-              y_center = ((ymin + ymax) / 2.0) / img_height
-              width = (xmax - xmin) / img_width
-              height = (ymax - ymin) / img_height
-
-              # Clip to valid range
-              x_center = max(0, min(1, x_center))
-              y_center = max(0, min(1, y_center))
-              width = max(0, min(1, width))
-              height = max(0, min(1, height))
-
-              cls_idx = class_to_idx[category]
-              lines.append(f"{cls_idx} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}\n")
-
-          # Write label file
-          if lines:
-              label_file.write_text("".join(lines), encoding="utf-8")
-
-      if skipped:
-          print(f"Skipped {skipped} annotations with unknown categories")
-      print("Conversion complete!")
-
-
-  # Download
-  dir = Path(yaml["path"])  # dataset root dir
-  urls = ["https://cg.cs.tsinghua.edu.cn/traffic-sign/data_model_code/data.zip"]
-  download(urls, dir=dir, curl=True, threads=1)
-
-  # Convert
-  tt100k2yolo(dir)

vendor/ultralytics/cfg/datasets/VOC.yaml

@@ -1,102 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# PASCAL VOC dataset http://host.robots.ox.ac.uk/pascal/VOC by University of Oxford
-# Documentation: https://docs.ultralytics.com/datasets/detect/voc/
-# Example usage: yolo train data=VOC.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── VOC ← downloads here (2.8 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: VOC
-train: # train images (relative to 'path') 16551 images
-  - images/train2012
-  - images/train2007
-  - images/val2012
-  - images/val2007
-val: # val images (relative to 'path') 4952 images
-  - images/test2007
-test: # test images (optional)
-  - images/test2007
-
-# Classes
-names:
-  0: aeroplane
-  1: bicycle
-  2: bird
-  3: boat
-  4: bottle
-  5: bus
-  6: car
-  7: cat
-  8: chair
-  9: cow
-  10: diningtable
-  11: dog
-  12: horse
-  13: motorbike
-  14: person
-  15: pottedplant
-  16: sheep
-  17: sofa
-  18: train
-  19: tvmonitor
-
-# Download script/URL (optional) ---------------------------------------------------------------------------------------
-download: |
-  import xml.etree.ElementTree as ET
-  from pathlib import Path
-
-  from ultralytics.utils.downloads import download
-  from ultralytics.utils import ASSETS_URL, TQDM
-
-  def convert_label(path, lb_path, year, image_id):
-      """Converts XML annotations from VOC format to YOLO format by extracting bounding boxes and class IDs."""
-
-      def convert_box(size, box):
-          dw, dh = 1.0 / size[0], 1.0 / size[1]
-          x, y, w, h = (box[0] + box[1]) / 2.0 - 1, (box[2] + box[3]) / 2.0 - 1, box[1] - box[0], box[3] - box[2]
-          return x * dw, y * dh, w * dw, h * dh
-
-      with open(path / f"VOC{year}/Annotations/{image_id}.xml") as in_file, open(lb_path, "w", encoding="utf-8") as out_file:
-          tree = ET.parse(in_file)
-          root = tree.getroot()
-          size = root.find("size")
-          w = int(size.find("width").text)
-          h = int(size.find("height").text)
-
-          names = list(yaml["names"].values())  # names list
-          for obj in root.iter("object"):
-              cls = obj.find("name").text
-              if cls in names and int(obj.find("difficult").text) != 1:
-                  xmlbox = obj.find("bndbox")
-                  bb = convert_box((w, h), [float(xmlbox.find(x).text) for x in ("xmin", "xmax", "ymin", "ymax")])
-                  cls_id = names.index(cls)  # class id
-                  out_file.write(" ".join(str(a) for a in (cls_id, *bb)) + "\n")
-
-
-  # Download
-  dir = Path(yaml["path"])  # dataset root dir
-  urls = [
-      f"{ASSETS_URL}/VOCtrainval_06-Nov-2007.zip",  # 446MB, 5012 images
-      f"{ASSETS_URL}/VOCtest_06-Nov-2007.zip",  # 438MB, 4953 images
-      f"{ASSETS_URL}/VOCtrainval_11-May-2012.zip",  # 1.95GB, 17126 images
-  ]
-  download(urls, dir=dir / "images", threads=3, exist_ok=True)  # download and unzip over existing (required)
-
-  # Convert
-  path = dir / "images/VOCdevkit"
-  for year, image_set in ("2012", "train"), ("2012", "val"), ("2007", "train"), ("2007", "val"), ("2007", "test"):
-      imgs_path = dir / "images" / f"{image_set}{year}"
-      lbs_path = dir / "labels" / f"{image_set}{year}"
-      imgs_path.mkdir(exist_ok=True, parents=True)
-      lbs_path.mkdir(exist_ok=True, parents=True)
-
-      with open(path / f"VOC{year}/ImageSets/Main/{image_set}.txt") as f:
-          image_ids = f.read().strip().split()
-      for id in TQDM(image_ids, desc=f"{image_set}{year}"):
-          f = path / f"VOC{year}/JPEGImages/{id}.jpg"  # old img path
-          lb_path = (lbs_path / f.name).with_suffix(".txt")  # new label path
-          f.rename(imgs_path / f.name)  # move image
-          convert_label(path, lb_path, year, id)  # convert labels to YOLO format

vendor/ultralytics/cfg/datasets/VisDrone.yaml

@@ -1,87 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# VisDrone2019-DET dataset https://github.com/VisDrone/VisDrone-Dataset by Tianjin University
-# Documentation: https://docs.ultralytics.com/datasets/detect/visdrone/
-# Example usage: yolo train data=VisDrone.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── VisDrone ← downloads here (2.3 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: VisDrone # dataset root dir
-train: images/train # train images (relative to 'path') 6471 images
-val: images/val # val images (relative to 'path') 548 images
-test: images/test # test-dev images (optional) 1610 images
-
-# Classes
-names:
-  0: pedestrian
-  1: people
-  2: bicycle
-  3: car
-  4: van
-  5: truck
-  6: tricycle
-  7: awning-tricycle
-  8: bus
-  9: motor
-
-# Download script/URL (optional) ---------------------------------------------------------------------------------------
-download: |
-  import os
-  from pathlib import Path
-  import shutil
-
-  from ultralytics.utils.downloads import download
-  from ultralytics.utils import ASSETS_URL, TQDM
-
-
-  def visdrone2yolo(dir, split, source_name=None):
-      """Convert VisDrone annotations to YOLO format with images/{split} and labels/{split} structure."""
-      from PIL import Image
-
-      source_dir = dir / (source_name or f"VisDrone2019-DET-{split}")
-      images_dir = dir / "images" / split
-      labels_dir = dir / "labels" / split
-      labels_dir.mkdir(parents=True, exist_ok=True)
-
-      # Move images to new structure
-      if (source_images_dir := source_dir / "images").exists():
-          images_dir.mkdir(parents=True, exist_ok=True)
-          for img in source_images_dir.glob("*.jpg"):
-              img.rename(images_dir / img.name)
-
-      for f in TQDM((source_dir / "annotations").glob("*.txt"), desc=f"Converting {split}"):
-          img_size = Image.open(images_dir / f.with_suffix(".jpg").name).size
-          dw, dh = 1.0 / img_size[0], 1.0 / img_size[1]
-          lines = []
-
-          with open(f, encoding="utf-8") as file:
-              for row in [x.split(",") for x in file.read().strip().splitlines()]:
-                  if row[4] != "0":  # Skip ignored regions
-                      x, y, w, h = map(int, row[:4])
-                      cls = int(row[5]) - 1
-                      # Convert to YOLO format
-                      x_center, y_center = (x + w / 2) * dw, (y + h / 2) * dh
-                      w_norm, h_norm = w * dw, h * dh
-                      lines.append(f"{cls} {x_center:.6f} {y_center:.6f} {w_norm:.6f} {h_norm:.6f}\n")
-
-          (labels_dir / f.name).write_text("".join(lines), encoding="utf-8")
-
-
-  # Download (ignores test-challenge split)
-  dir = Path(yaml["path"])  # dataset root dir
-  urls = [
-      f"{ASSETS_URL}/VisDrone2019-DET-train.zip",
-      f"{ASSETS_URL}/VisDrone2019-DET-val.zip",
-      f"{ASSETS_URL}/VisDrone2019-DET-test-dev.zip",
-      # f"{ASSETS_URL}/VisDrone2019-DET-test-challenge.zip",
-  ]
-  download(urls, dir=dir, threads=4)
-
-  # Convert
-  splits = {"VisDrone2019-DET-train": "train", "VisDrone2019-DET-val": "val", "VisDrone2019-DET-test-dev": "test"}
-  for folder, split in splits.items():
-      visdrone2yolo(dir, split, folder)  # convert VisDrone annotations to YOLO labels
-      shutil.rmtree(dir / folder)  # cleanup original directory

vendor/ultralytics/cfg/datasets/african-wildlife.yaml

@@ -1,25 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# African Wildlife dataset by Ultralytics
-# Documentation: https://docs.ultralytics.com/datasets/detect/african-wildlife/
-# Example usage: yolo train data=african-wildlife.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── african-wildlife ← downloads here (100 MB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: african-wildlife # dataset root dir
-train: images/train # train images (relative to 'path') 1052 images
-val: images/val # val images (relative to 'path') 225 images
-test: images/test # test images (relative to 'path') 227 images
-
-# Classes
-names:
-  0: buffalo
-  1: elephant
-  2: rhino
-  3: zebra
-
-# Download script/URL (optional)
-download: https://github.com/ultralytics/assets/releases/download/v0.0.0/african-wildlife.zip

vendor/ultralytics/cfg/datasets/brain-tumor.yaml

@@ -1,22 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# Brain-tumor dataset by Ultralytics
-# Documentation: https://docs.ultralytics.com/datasets/detect/brain-tumor/
-# Example usage: yolo train data=brain-tumor.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── brain-tumor ← downloads here (4.21 MB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: brain-tumor # dataset root dir
-train: images/train # train images (relative to 'path') 893 images
-val: images/val # val images (relative to 'path') 223 images
-
-# Classes
-names:
-  0: negative
-  1: positive
-
-# Download script/URL (optional)
-download: https://github.com/ultralytics/assets/releases/download/v0.0.0/brain-tumor.zip

vendor/ultralytics/cfg/datasets/carparts-seg.yaml

@@ -1,44 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# Carparts-seg dataset by Ultralytics
-# Documentation: https://docs.ultralytics.com/datasets/segment/carparts-seg/
-# Example usage: yolo train data=carparts-seg.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── carparts-seg ← downloads here (133 MB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: carparts-seg # dataset root dir
-train: images/train # train images (relative to 'path') 3516 images
-val: images/val # val images (relative to 'path') 276 images
-test: images/test # test images (relative to 'path') 401 images
-
-# Classes
-names:
-  0: back_bumper
-  1: back_door
-  2: back_glass
-  3: back_left_door
-  4: back_left_light
-  5: back_light
-  6: back_right_door
-  7: back_right_light
-  8: front_bumper
-  9: front_door
-  10: front_glass
-  11: front_left_door
-  12: front_left_light
-  13: front_light
-  14: front_right_door
-  15: front_right_light
-  16: hood
-  17: left_mirror
-  18: object
-  19: right_mirror
-  20: tailgate
-  21: trunk
-  22: wheel
-
-# Download script/URL (optional)
-download: https://github.com/ultralytics/assets/releases/download/v0.0.0/carparts-seg.zip

vendor/ultralytics/cfg/datasets/coco-pose.yaml

@@ -1,64 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# COCO 2017 Keypoints dataset https://cocodataset.org by Microsoft
-# Documentation: https://docs.ultralytics.com/datasets/pose/coco/
-# Example usage: yolo train data=coco-pose.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── coco-pose ← downloads here (20.1 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: coco-pose # dataset root dir
-train: train2017.txt # train images (relative to 'path') 56599 images
-val: val2017.txt # val images (relative to 'path') 2346 images
-test: test-dev2017.txt # 20288 of 40670 images, submit to https://codalab.lisn.upsaclay.fr/competitions/7403
-
-# Keypoints
-kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
-flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
-
-# Classes
-names:
-  0: person
-
-# Keypoint names per class
-kpt_names:
-  0:
-    - nose
-    - left_eye
-    - right_eye
-    - left_ear
-    - right_ear
-    - left_shoulder
-    - right_shoulder
-    - left_elbow
-    - right_elbow
-    - left_wrist
-    - right_wrist
-    - left_hip
-    - right_hip
-    - left_knee
-    - right_knee
-    - left_ankle
-    - right_ankle
-
-# Download script/URL (optional)
-download: |
-  from pathlib import Path
-
-  from ultralytics.utils import ASSETS_URL
-  from ultralytics.utils.downloads import download
-
-  # Download labels
-  dir = Path(yaml["path"])  # dataset root dir
-
-  urls = [f"{ASSETS_URL}/coco2017labels-pose.zip"]
-  download(urls, dir=dir.parent)
-  # Download data
-  urls = [
-      "http://images.cocodataset.org/zips/train2017.zip",  # 19G, 118k images
-      "http://images.cocodataset.org/zips/val2017.zip",  # 1G, 5k images
-      "http://images.cocodataset.org/zips/test2017.zip",  # 7G, 41k images (optional)
-  ]
-  download(urls, dir=dir / "images", threads=3)

vendor/ultralytics/cfg/datasets/coco.yaml

@@ -1,118 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-# COCO 2017 dataset https://cocodataset.org by Microsoft
-# Documentation: https://docs.ultralytics.com/datasets/detect/coco/
-# Example usage: yolo train data=coco.yaml
-# parent
-# ├── ultralytics
-# └── datasets
-#     └── coco ← downloads here (20.1 GB)
-
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: coco # dataset root dir
-train: train2017.txt # train images (relative to 'path') 118287 images
-val: val2017.txt # val images (relative to 'path') 5000 images
-test: test-dev2017.txt # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
-
-# Classes
-names:
-  0: person
-  1: bicycle
-  2: car
-  3: motorcycle
-  4: airplane
-  5: bus
-  6: train
-  7: truck
-  8: boat
-  9: traffic light
-  10: fire hydrant
-  11: stop sign
-  12: parking meter
-  13: bench
-  14: bird
-  15: cat
-  16: dog
-  17: horse
-  18: sheep
-  19: cow
-  20: elephant
-  21: bear
-  22: zebra
-  23: giraffe
-  24: backpack
-  25: umbrella
-  26: handbag
-  27: tie
-  28: suitcase
-  29: frisbee
-  30: skis
-  31: snowboard
-  32: sports ball
-  33: kite
-  34: baseball bat
-  35: baseball glove
-  36: skateboard
-  37: surfboard
-  38: tennis racket
-  39: bottle
-  40: wine glass
-  41: cup
-  42: fork
-  43: knife
-  44: spoon
-  45: bowl
-  46: banana
-  47: apple
-  48: sandwich
-  49: orange
-  50: broccoli
-  51: carrot
-  52: hot dog
-  53: pizza
-  54: donut
-  55: cake
-  56: chair
-  57: couch
-  58: potted plant
-  59: bed
-  60: dining table
-  61: toilet
-  62: tv
-  63: laptop
-  64: mouse
-  65: remote
-  66: keyboard
-  67: cell phone
-  68: microwave
-  69: oven
-  70: toaster
-  71: sink
-  72: refrigerator
-  73: book
-  74: clock
-  75: vase
-  76: scissors
-  77: teddy bear
-  78: hair drier
-  79: toothbrush
-
-# Download script/URL (optional)
-download: |
-  from pathlib import Path
-
-  from ultralytics.utils import ASSETS_URL
-  from ultralytics.utils.downloads import download
-
-  # Download labels
-  segments = True  # segment or box labels
-  dir = Path(yaml["path"])  # dataset root dir
-  urls = [ASSETS_URL + ("/coco2017labels-segments.zip" if segments else "/coco2017labels.zip")]  # labels
-  download(urls, dir=dir.parent)
-  # Download data
-  urls = [
-      "http://images.cocodataset.org/zips/train2017.zip",  # 19G, 118k images
-      "http://images.cocodataset.org/zips/val2017.zip",  # 1G, 5k images
-      "http://images.cocodataset.org/zips/test2017.zip",  # 7G, 41k images (optional)
-  ]
-  download(urls, dir=dir / "images", threads=3)