ultralytics-opencv-headless 8.3.246__py3-none-any.whl → 8.3.251__py3-none-any.whl

ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-__version__ = "8.3.246"
+__version__ = "8.3.251"
 
 import importlib
 import os

ultralytics/cfg/__init__.py

@@ -410,9 +410,11 @@ def get_save_dir(args: SimpleNamespace, name: str | None = None) -> Path:
     else:
         from ultralytics.utils.files import increment_path
 
-        project = args.project or (ROOT.parent / "tests/tmp/runs" if TESTS_RUNNING else RUNS_DIR) / args.task
+        runs = (ROOT.parent / "tests/tmp/runs" if TESTS_RUNNING else RUNS_DIR) / args.task
+        nested = args.project and len(Path(args.project).parts) > 1  # e.g. "user/project" or "org\repo"
+        project = runs / args.project if nested else args.project or runs
         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)
+        save_dir = increment_path(Path(project) / name, exist_ok=args.exist_ok if RANK in {-1, 0} else True, mkdir=True)
 
     return Path(save_dir).resolve()  # resolve to display full path in console
 
@@ -725,8 +727,8 @@ def handle_yolo_solutions(args: list[str]) -> None:
             )
             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(project="runs/solutions", name="exp", exist_ok=False))
-            save_dir.mkdir(parents=True)  # create the output directory i.e. runs/solutions/exp
+            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

ultralytics/cfg/datasets/TT100K.yaml

@@ -0,0 +1,346 @@
+# 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)

ultralytics/data/converter.py

@@ -353,7 +353,7 @@ def convert_segment_masks_to_yolo_seg(masks_dir: str, output_dir: str, classes:
     Args:
         masks_dir (str): The path to the directory where all mask images (png, jpg) are stored.
         output_dir (str): The path to the directory where the converted YOLO segmentation masks will be stored.
-        classes (int): Total classes in the dataset i.e. for COCO classes=80
+        classes (int): Total number of classes in the dataset, e.g., 80 for COCO.
 
     Examples:
         >>> from ultralytics.data.converter import convert_segment_masks_to_yolo_seg

ultralytics/engine/model.py

@@ -275,7 +275,7 @@ class Model(torch.nn.Module):
             >>> model._load("yolo11n.pt")
             >>> model._load("path/to/weights.pth", task="detect")
         """
-        if weights.lower().startswith(("https://", "http://", "rtsp://", "rtmp://", "tcp://")):
+        if weights.lower().startswith(("https://", "http://", "rtsp://", "rtmp://", "tcp://", "ul://")):
             weights = checks.check_file(weights, download_dir=SETTINGS["weights_dir"])  # download and return local file
         weights = checks.check_model_file_from_stem(weights)  # add suffix, i.e. yolo11n -> yolo11n.pt
 
@@ -403,7 +403,7 @@ class Model(torch.nn.Module):
         }
         torch.save({**self.ckpt, **updates}, filename)
 
-    def info(self, detailed: bool = False, verbose: bool = True):
+    def info(self, detailed: bool = False, verbose: bool = True, imgsz: int | list[int, int] = 640):
         """Display model information.
 
         This method provides an overview or detailed information about the model, depending on the arguments
@@ -412,6 +412,7 @@ class Model(torch.nn.Module):
         Args:
             detailed (bool): If True, shows detailed information about the model layers and parameters.
             verbose (bool): If True, prints the information. If False, returns the information as a list.
+            imgsz (int | list[int, int]): Input image size used for FLOPs calculation.
 
         Returns:
             (list[str]): A list of strings containing various types of information about the model, including model
@@ -423,7 +424,7 @@ class Model(torch.nn.Module):
             >>> info_list = model.info(detailed=True, verbose=False)  # Returns detailed info as a list
         """
         self._check_is_pytorch_model()
-        return self.model.info(detailed=detailed, verbose=verbose)
+        return self.model.info(detailed=detailed, verbose=verbose, imgsz=imgsz)
 
     def fuse(self) -> None:
         """Fuse Conv2d and BatchNorm2d layers in the model for optimized inference.

ultralytics/engine/results.py

@@ -954,8 +954,8 @@ class Boxes(BaseTensor):
             >>> boxes = Boxes(torch.tensor([[100, 50, 150, 100], [200, 150, 300, 250]]), orig_shape=(480, 640))
             >>> xywh = boxes.xywh
             >>> print(xywh)
-            tensor([[100.0000,  50.0000,  50.0000,  50.0000],
-                    [200.0000, 150.0000, 100.0000, 100.0000]])
+            tensor([[125.0000,  75.0000,  50.0000,  50.0000],
+                    [250.0000, 200.0000, 100.0000, 100.0000]])
         """
         return ops.xyxy2xywh(self.xyxy)
 

ultralytics/engine/trainer.py

@@ -157,6 +157,27 @@ class BaseTrainer:
         if self.device.type in {"cpu", "mps"}:
             self.args.workers = 0  # faster CPU training as time dominated by inference, not dataloading
 
+        # Callbacks - initialize early so on_pretrain_routine_start can capture original args.data
+        self.callbacks = _callbacks or callbacks.get_default_callbacks()
+
+        if isinstance(self.args.device, str) and len(self.args.device):  # i.e. device='0' or device='0,1,2,3'
+            world_size = len(self.args.device.split(","))
+        elif isinstance(self.args.device, (tuple, list)):  # i.e. device=[0, 1, 2, 3] (multi-GPU from CLI is list)
+            world_size = len(self.args.device)
+        elif self.args.device in {"cpu", "mps"}:  # i.e. device='cpu' or 'mps'
+            world_size = 0
+        elif torch.cuda.is_available():  # i.e. device=None or device='' or device=number
+            world_size = 1  # default to device 0
+        else:  # i.e. device=None or device=''
+            world_size = 0
+
+        self.ddp = world_size > 1 and "LOCAL_RANK" not in os.environ
+        self.world_size = world_size
+        # Run on_pretrain_routine_start before get_dataset() to capture original args.data (e.g., ul:// URIs)
+        if RANK in {-1, 0} and not self.ddp:
+            callbacks.add_integration_callbacks(self)
+            self.run_callbacks("on_pretrain_routine_start")
+
         # Model and Dataset
         self.model = check_model_file_from_stem(self.args.model)  # add suffix, i.e. yolo11n -> yolo11n.pt
         with torch_distributed_zero_first(LOCAL_RANK):  # avoid auto-downloading dataset multiple times
@@ -180,28 +201,6 @@ class BaseTrainer:
         self.plot_idx = [0, 1, 2]
         self.nan_recovery_attempts = 0
 
-        # Callbacks
-        self.callbacks = _callbacks or callbacks.get_default_callbacks()
-
-        if isinstance(self.args.device, str) and len(self.args.device):  # i.e. device='0' or device='0,1,2,3'
-            world_size = len(self.args.device.split(","))
-        elif isinstance(self.args.device, (tuple, list)):  # i.e. device=[0, 1, 2, 3] (multi-GPU from CLI is list)
-            world_size = len(self.args.device)
-        elif self.args.device in {"cpu", "mps"}:  # i.e. device='cpu' or 'mps'
-            world_size = 0
-        elif torch.cuda.is_available():  # i.e. device=None or device='' or device=number
-            world_size = 1  # default to device 0
-        else:  # i.e. device=None or device=''
-            world_size = 0
-
-        self.ddp = world_size > 1 and "LOCAL_RANK" not in os.environ
-        self.world_size = world_size
-        # Run subprocess if DDP training, else train normally
-        if RANK in {-1, 0} and not self.ddp:
-            callbacks.add_integration_callbacks(self)
-            # Start console logging immediately at trainer initialization
-            self.run_callbacks("on_pretrain_routine_start")
-
     def add_callback(self, event: str, callback):
         """Append the given callback to the event's callback list."""
         self.callbacks[event].append(callback)
@@ -631,13 +630,17 @@ class BaseTrainer:
         try:
             if self.args.task == "classify":
                 data = check_cls_dataset(self.args.data)
-            elif str(self.args.data).rsplit(".", 1)[-1] == "ndjson":
-                # Convert NDJSON to YOLO format
+            elif str(self.args.data).rsplit(".", 1)[-1] == "ndjson" or (
+                str(self.args.data).startswith("ul://") and "/datasets/" in str(self.args.data)
+            ):
+                # Convert NDJSON to YOLO format (including ul:// platform dataset URIs)
                 import asyncio
 
                 from ultralytics.data.converter import convert_ndjson_to_yolo
+                from ultralytics.utils.checks import check_file
 
-                yaml_path = asyncio.run(convert_ndjson_to_yolo(self.args.data))
+                ndjson_file = check_file(self.args.data)  # Resolve ul:// or URL to local .ndjson file
+                yaml_path = asyncio.run(convert_ndjson_to_yolo(ndjson_file))
                 self.args.data = str(yaml_path)
                 data = check_det_dataset(self.args.data)
             elif str(self.args.data).rsplit(".", 1)[-1] in {"yaml", "yml"} or self.args.task in {

ultralytics/engine/tuner.py

@@ -378,6 +378,7 @@ class Tuner:
             metrics = {}
             train_args = {**vars(self.args), **mutated_hyp}
             save_dir = get_save_dir(get_cfg(train_args))
+            train_args["save_dir"] = str(save_dir)  # pass save_dir to subprocess to ensure same path is used
             weights_dir = save_dir / "weights"
             try:
                 # Train YOLO model with mutated hyperparameters (run in subprocess to avoid dataloader hang)

ultralytics/engine/validator.py

@@ -364,7 +364,10 @@ class BaseValidator:
         return []
 
     def on_plot(self, name, data=None):
-        """Register plots for visualization."""
+        """Register plots for visualization, deduplicating by type."""
+        plot_type = data.get("type") if data else None
+        if plot_type and any((v.get("data") or {}).get("type") == plot_type for v in self.plots.values()):
+            return  # Skip duplicate plot types
         self.plots[Path(name)] = {"data": data, "timestamp": time.time()}
 
     def plot_val_samples(self, batch, ni):

ultralytics/models/sam/modules/utils.py

@@ -166,7 +166,7 @@ def reshape_for_broadcast(freqs_cis: torch.Tensor, x: torch.Tensor):
         AssertionError: If the shape of freqs_cis doesn't match the last two dimensions of x.
     """
     ndim = x.ndim
-    assert 0 <= 1 < ndim
+    assert ndim >= 2
     assert freqs_cis.shape == (x.shape[-2], x.shape[-1])
     shape = [d if i >= ndim - 2 else 1 for i, d in enumerate(x.shape)]
     return freqs_cis.view(*shape)

ultralytics/models/yolo/detect/val.py

@@ -347,14 +347,14 @@ class DetectionValidator(BaseValidator):
             ni (int): Batch index.
             max_det (Optional[int]): Maximum number of detections to plot.
         """
-        # TODO: optimize this
+        if not preds:
+            return
         for i, pred in enumerate(preds):
             pred["batch_idx"] = torch.ones_like(pred["conf"]) * i  # add batch index to predictions
         keys = preds[0].keys()
         max_det = max_det or self.args.max_det
         batched_preds = {k: torch.cat([x[k][:max_det] for x in preds], dim=0) for k in keys}
-        # TODO: fix this
-        batched_preds["bboxes"][:, :4] = ops.xyxy2xywh(batched_preds["bboxes"][:, :4])  # convert to xywh format
+        batched_preds["bboxes"] = ops.xyxy2xywh(batched_preds["bboxes"])  # convert to xywh format
         plot_images(
             images=batch["img"],
             labels=batched_preds,

ultralytics/nn/modules/transformer.py

@@ -305,16 +305,16 @@ class TransformerBlock(nn.Module):
         """Forward propagate the input through the transformer block.
 
         Args:
-            x (torch.Tensor): Input tensor with shape [b, c1, w, h].
+            x (torch.Tensor): Input tensor with shape [b, c1, h, w].
 
         Returns:
-            (torch.Tensor): Output tensor with shape [b, c2, w, h].
+            (torch.Tensor): Output tensor with shape [b, c2, h, w].
         """
         if self.conv is not None:
             x = self.conv(x)
-        b, _, w, h = x.shape
+        b, _, h, w = x.shape
         p = x.flatten(2).permute(2, 0, 1)
-        return self.tr(p + self.linear(p)).permute(1, 2, 0).reshape(b, self.c2, w, h)
+        return self.tr(p + self.linear(p)).permute(1, 2, 0).reshape(b, self.c2, h, w)
 
 
 class MLPBlock(nn.Module):

ultralytics/nn/tasks.py

@@ -407,7 +407,7 @@ class DetectionModel(BaseModel):
             self.model.train()  # Set model back to training(default) mode
             m.bias_init()  # only run once
         else:
-            self.stride = torch.Tensor([32])  # default stride for i.e. RTDETR
+            self.stride = torch.Tensor([32])  # default stride, e.g., RTDETR
 
         # Init weights, biases
         initialize_weights(self)
@@ -1589,7 +1589,7 @@ def parse_model(d, ch, verbose=True):
         n = n_ = max(round(n * depth), 1) if n > 1 else n  # depth gain
         if m in base_modules:
             c1, c2 = ch[f], args[0]
-            if c2 != nc:  # if c2 not equal to number of classes (i.e. for Classify() output)
+            if c2 != nc:  # if c2 != nc (e.g., Classify() output)
                 c2 = make_divisible(min(c2, max_channels) * width, 8)
             if m is C2fAttn:  # set 1) embed channels and 2) num heads
                 args[1] = make_divisible(min(args[1], max_channels // 2) * width, 8)

ultralytics/solutions/object_counter.py

@@ -129,7 +129,7 @@ class ObjectCounter(BaseSolution):
             str.capitalize(key): f"{'IN ' + str(value['IN']) if self.show_in else ''} "
             f"{'OUT ' + str(value['OUT']) if self.show_out else ''}".strip()
             for key, value in self.classwise_count.items()
-            if value["IN"] != 0 or (value["OUT"] != 0 and (self.show_in or self.show_out))
+            if (value["IN"] != 0 and self.show_in) or (value["OUT"] != 0 and self.show_out)
         }
         if labels_dict:
             self.annotator.display_analytics(plot_im, labels_dict, (104, 31, 17), (255, 255, 255), self.margin)

ultralytics/utils/benchmarks.py

@@ -460,7 +460,7 @@ class ProfileModels:
             if file.suffix in {".pt", ".yaml", ".yml"}:
                 model = YOLO(str(file))
                 model.fuse()  # to report correct params and GFLOPs in model.info()
-                model_info = model.info()
+                model_info = model.info(imgsz=self.imgsz)
                 if self.trt and self.device.type != "cpu" and not engine_file.is_file():
                     engine_file = model.export(
                         format="engine",