dgenerate-ultralytics-headless 8.3.250__tar.gz → 8.3.253__tar.gz

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.250
+Version: 8.3.253
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/dgenerate_ultralytics_headless.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.250
+Version: 8.3.253
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/ultralytics/__init__.py

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

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/ultralytics/cfg/__init__.py

@@ -414,7 +414,7 @@ def get_save_dir(args: SimpleNamespace, name: str | None = None) -> Path:
         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
 
@@ -727,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

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/ultralytics/cfg/datasets/TT100K.yaml

@@ -1,22 +1,22 @@
-# Ultralytics YOLO 🚀 AGPL-3.0 License - https://ultralytics.com/license
-# Tsinghua-Tencent 100K Traffic Sign Detection Dataset
-# Dataset: https://cg.cs.tsinghua.edu.cn/traffic-sign/
+# 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)
-# Documentation: 100,000 images with 30,000+ traffic sign annotations
+# 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 (~30 GB with images)
+#     └── TT100K ← downloads here (~18 GB)
 
-# Train/val/test sets
+# 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')
-val: images/val # val images (relative to 'path')
-test: images/test # test images (relative to 'path')
+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
-nc: 221
+# Classes (221 traffic sign categories, 45 with sufficient training instances)
 names:
   0: pl5
   1: pl10
@@ -242,57 +242,52 @@ names:
 
 # Download script/URL (optional) ---------------------------------------------------------------------------------------
 download: |
-  import os
   import json
   import shutil
   from pathlib import Path
-  from ultralytics.utils.downloads import download
+
+  from PIL import Image
+
   from ultralytics.utils import TQDM
+  from ultralytics.utils.downloads import download
+
 
   def tt100k2yolo(dir):
-      """Convert TT100K annotations to YOLO format."""
-      from PIL import Image
-      
+      """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, 'r', encoding='utf-8') as f:
+      with open(anno_file, encoding="utf-8") as f:
           data = json.load(f)
-      
-      # Get all unique classes
-      classes = set()
-      for img_id, img_data in data['imgs'].items():
-          for obj in img_data.get('objects', []):
-              classes.add(obj['category'])
-      class_to_idx = {cls: idx for idx, cls in enumerate(yaml["names"]) if cls in classes}
-      class_to_idx = {cls: idx for idx, cls in enumerate(classes)}
-      
-      print(f"Found {len(classes)} traffic sign classes")
-      
+
+      # 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)
-      
+      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...")
-      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'
+      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'
-          
+              split = "val"
+
           # Source and destination paths
           src_img = data_dir / img_path_str
           if not src_img.exists():
               continue
-          
-          img_name = src_img.name
-          dst_img = dir / 'images' / split / img_name
-          
+
+          dst_img = dir / "images" / split / src_img.name
+
           # Get image dimensions
           try:
               with Image.open(src_img) as img:
@@ -300,57 +295,52 @@ download: |
           except Exception as e:
               print(f"Error reading {src_img}: {e}")
               continue
+
+          # Copy image to destination
           shutil.copy2(src_img, dst_img)
-          label_file = dir / 'labels' / split / f"{src_img.stem}.txt"
+
+          # Convert annotations
+          label_file = dir / "labels" / split / f"{src_img.stem}.txt"
           lines = []
-          
-          for obj in img_data.get('objects', []):
-              category = obj['category']
+
+          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']
-              
+
+              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
-              
-              # Ensure valid coordinates
+
+              # 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")
-      
-      print(f"Conversion complete!")
-      print(f"Found {len(classes)} classes: {classes[:10]}..." if len(classes) > 10 else f"Classes: {classes}")
-      
-      return classes
-
-  # Download dataset
-  dir = Path(yaml['path'])  # dataset root dir
 
-  # TT100K dataset URLs
-  urls = [
-      'https://cg.cs.tsinghua.edu.cn/traffic-sign/data_model_code/data.zip',  # Main dataset with annotations
-  ]
+      if skipped:
+          print(f"Skipped {skipped} annotations with unknown categories")
+      print("Conversion complete!")
 
-  print("Downloading TT100K dataset...")
-  print("Note: This dataset is large (~30GB). Download may take some time.")
-  print("Dataset is under CC-BY-NC license for non-commercial use only.")
 
-  # Download and extract
-  download(urls, dir=dir, unzip=True, delete=False, curl=False, threads=1)
+  # 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 dataset in YOLO format
-  classes = tt100k2yolo(dir)
+  # Convert
+  tt100k2yolo(dir)

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/ultralytics/engine/exporter.py

@@ -505,6 +505,7 @@ class Exporter:
                 m.format = self.args.format
                 m.max_det = self.args.max_det
                 m.xyxy = self.args.nms and not coreml
+                m.shape = None  # reset cached shape for new export input size
                 if hasattr(model, "pe") and hasattr(m, "fuse"):  # for YOLOE models
                     m.fuse(model.pe.to(self.device))
             elif isinstance(m, C2f) and not is_tf_format:
@@ -812,11 +813,11 @@ class Exporter:
         assert not IS_JETSON, "Jetson Paddle exports not supported yet"
         check_requirements(
             (
-                "paddlepaddle-gpu"
+                "paddlepaddle-gpu>=3.0.0,!=3.3.0"  # exclude 3.3.0 https://github.com/PaddlePaddle/Paddle/issues/77340
                 if torch.cuda.is_available()
                 else "paddlepaddle==3.0.0"  # pin 3.0.0 for ARM64
                 if ARM64
-                else "paddlepaddle>=3.0.0",
+                else "paddlepaddle>=3.0.0,!=3.3.0",  # exclude 3.3.0 https://github.com/PaddlePaddle/Paddle/issues/77340
                 "x2paddle",
             )
         )
@@ -859,7 +860,8 @@ class Exporter:
     @try_export
     def export_ncnn(self, prefix=colorstr("NCNN:")):
         """Export YOLO model to NCNN format using PNNX https://github.com/pnnx/pnnx."""
-        check_requirements("ncnn", cmds="--no-deps")  # no deps to avoid installing opencv-python
+        # use git source for ARM64 due to broken PyPI packages https://github.com/Tencent/ncnn/issues/6509
+        check_requirements("git+https://github.com/Tencent/ncnn.git" if ARM64 else "ncnn", cmds="--no-deps")
         check_requirements("pnnx")
         import ncnn
         import pnnx

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/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.

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/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)

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/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)

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/ultralytics/nn/autobackend.py

@@ -497,11 +497,11 @@ class AutoBackend(nn.Module):
         elif paddle:
             LOGGER.info(f"Loading {w} for PaddlePaddle inference...")
             check_requirements(
-                "paddlepaddle-gpu"
+                "paddlepaddle-gpu>=3.0.0,!=3.3.0"  # exclude 3.3.0 https://github.com/PaddlePaddle/Paddle/issues/77340
                 if torch.cuda.is_available()
                 else "paddlepaddle==3.0.0"  # pin 3.0.0 for ARM64
                 if ARM64
-                else "paddlepaddle>=3.0.0"
+                else "paddlepaddle>=3.0.0,!=3.3.0"  # exclude 3.3.0 https://github.com/PaddlePaddle/Paddle/issues/77340
             )
             import paddle.inference as pdi
 
@@ -545,11 +545,17 @@ class AutoBackend(nn.Module):
         # NCNN
         elif ncnn:
             LOGGER.info(f"Loading {w} for NCNN inference...")
+            # use git source for ARM64 due to broken PyPI packages https://github.com/Tencent/ncnn/issues/6509
             check_requirements("git+https://github.com/Tencent/ncnn.git" if ARM64 else "ncnn", cmds="--no-deps")
             import ncnn as pyncnn
 
             net = pyncnn.Net()
-            net.opt.use_vulkan_compute = cuda
+            if isinstance(cuda, torch.device):
+                net.opt.use_vulkan_compute = cuda
+            elif isinstance(device, str) and device.startswith("vulkan"):
+                net.opt.use_vulkan_compute = True
+                net.set_vulkan_device(int(device.split(":")[1]))
+                device = torch.device("cpu")
             w = Path(w)
             if not w.is_file():  # if not *.param
                 w = next(w.glob("*.param"))  # get *.param file from *_ncnn_model dir

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.253}/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",