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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.250
+Version: 8.3.252
 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.252}/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.252
 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.252}/ultralytics/__init__.py

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

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.252}/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.252}/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.252}/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:

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

{dgenerate_ultralytics_headless-8.3.250 → dgenerate_ultralytics_headless-8.3.252}/ultralytics/utils/callbacks/platform.py

@@ -2,6 +2,7 @@
 
 import os
 import platform
+import re
 import socket
 import sys
 from concurrent.futures import ThreadPoolExecutor
@@ -11,9 +12,14 @@ from time import time
 from ultralytics.utils import ENVIRONMENT, GIT, LOGGER, PYTHON_VERSION, RANK, SETTINGS, TESTS_RUNNING, colorstr
 
 PREFIX = colorstr("Platform: ")
-_last_upload = 0  # Rate limit model uploads
-_console_logger = None  # Global console logger instance
-_system_logger = None  # Cached system logger instance
+
+
+def slugify(text):
+    """Convert text to URL-safe slug (e.g., 'My Project 1' -> 'my-project-1')."""
+    if not text:
+        return text
+    return re.sub(r"-+", "-", re.sub(r"[^a-z0-9\s-]", "", str(text).lower()).replace(" ", "-")).strip("-")[:128]
+
 
 try:
     assert not TESTS_RUNNING  # do not log pytest
@@ -78,8 +84,6 @@ def resolve_platform_uri(uri, hard=True):
     else:
         raise ValueError(f"Invalid platform URI: {uri}. Use ul://user/datasets/name or ul://user/project/model")
 
-    LOGGER.info(f"Resolving {uri} from Ultralytics Platform...")
-
     try:
         r = requests.head(url, headers=headers, allow_redirects=False, timeout=30)
 
@@ -139,22 +143,28 @@ def _interp_plot(plot, n=101):
     return result
 
 
-def _send(event, data, project, name):
-    """Send event to Platform endpoint."""
+def _send(event, data, project, name, model_id=None):
+    """Send event to Platform endpoint. Returns response JSON on success."""
     try:
-        requests.post(
+        payload = {"event": event, "project": project, "name": name, "data": data}
+        if model_id:
+            payload["modelId"] = model_id
+        r = requests.post(
             "https://alpha.ultralytics.com/api/webhooks/training/metrics",
-            json={"event": event, "project": project, "name": name, "data": data},
+            json=payload,
             headers={"Authorization": f"Bearer {_api_key}"},
             timeout=10,
-        ).raise_for_status()
+        )
+        r.raise_for_status()
+        return r.json()
     except Exception as e:
         LOGGER.debug(f"Platform: Failed to send {event}: {e}")
+        return None
 
 
-def _send_async(event, data, project, name):
+def _send_async(event, data, project, name, model_id=None):
     """Send event asynchronously using bounded thread pool."""
-    _executor.submit(_send, event, data, project, name)
+    _executor.submit(_send, event, data, project, name, model_id)
 
 
 def _upload_model(model_path, project, name):
@@ -248,132 +258,146 @@ def _get_environment_info():
     return env
 
 
+def _get_project_name(trainer):
+    """Get slugified project and name from trainer args."""
+    raw = str(trainer.args.project)
+    parts = raw.split("/", 1)
+    project = f"{parts[0]}/{slugify(parts[1])}" if len(parts) == 2 else slugify(raw)
+    return project, slugify(str(trainer.args.name or "train"))
+
+
 def on_pretrain_routine_start(trainer):
     """Initialize Platform logging at training start."""
-    global _console_logger, _last_upload
-
     if RANK not in {-1, 0} or not trainer.args.project:
         return
 
-    # Initialize upload timer to now so first checkpoint waits 15 min from training start
-    _last_upload = time()
+    # Per-trainer state to isolate concurrent training runs
+    trainer._platform_model_id = None
+    trainer._platform_last_upload = time()
 
-    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    project, name = _get_project_name(trainer)
     url = f"https://alpha.ultralytics.com/{project}/{name}"
     LOGGER.info(f"{PREFIX}Streaming to {url}")
 
     # Create callback to send console output to Platform
     def send_console_output(content, line_count, chunk_id):
         """Send batched console output to Platform webhook."""
-        _send_async("console_output", {"chunkId": chunk_id, "content": content, "lineCount": line_count}, project, name)
+        _send_async(
+            "console_output",
+            {"chunkId": chunk_id, "content": content, "lineCount": line_count},
+            project,
+            name,
+            getattr(trainer, "_platform_model_id", None),
+        )
 
     # Start console capture with batching (5 lines or 5 seconds)
-    _console_logger = ConsoleLogger(batch_size=5, flush_interval=5.0, on_flush=send_console_output)
-    _console_logger.start_capture()
-
-    # Gather model info for richer metadata
-    model_info = {}
-    try:
-        info = model_info_for_loggers(trainer)
-        model_info = {
-            "parameters": info.get("model/parameters", 0),
-            "gflops": info.get("model/GFLOPs", 0),
-            "classes": getattr(trainer.model, "yaml", {}).get("nc", 0),  # number of classes
-        }
-    except Exception:
-        pass
+    trainer._platform_console_logger = ConsoleLogger(batch_size=5, flush_interval=5.0, on_flush=send_console_output)
+    trainer._platform_console_logger.start_capture()
 
     # Collect environment info (W&B-style metadata)
     environment = _get_environment_info()
 
-    _send_async(
+    # Build trainArgs - callback runs before get_dataset() so args.data is still original (e.g., ul:// URIs)
+    # Note: model_info is sent later in on_fit_epoch_end (epoch 0) when the model is actually loaded
+    train_args = {k: str(v) for k, v in vars(trainer.args).items()}
+
+    # Send synchronously to get modelId for subsequent webhooks
+    response = _send(
         "training_started",
         {
-            "trainArgs": {k: str(v) for k, v in vars(trainer.args).items()},
+            "trainArgs": train_args,
             "epochs": trainer.epochs,
             "device": str(trainer.device),
-            "modelInfo": model_info,
             "environment": environment,
         },
         project,
         name,
     )
+    if response and response.get("modelId"):
+        trainer._platform_model_id = response["modelId"]
 
 
 def on_fit_epoch_end(trainer):
     """Log training and system metrics at epoch end."""
-    global _system_logger
-
     if RANK not in {-1, 0} or not trainer.args.project:
         return
 
-    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    project, name = _get_project_name(trainer)
     metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics}
 
     if trainer.optimizer and trainer.optimizer.param_groups:
         metrics["lr"] = trainer.optimizer.param_groups[0]["lr"]
+
+    # Extract model info at epoch 0 (sent as separate field, not in metrics)
+    model_info = None
     if trainer.epoch == 0:
         try:
-            metrics.update(model_info_for_loggers(trainer))
+            info = model_info_for_loggers(trainer)
+            model_info = {
+                "parameters": info.get("model/parameters", 0),
+                "gflops": info.get("model/GFLOPs", 0),
+                "speedMs": info.get("model/speed_PyTorch(ms)", 0),
+            }
         except Exception:
             pass
 
-    # Get system metrics (cache SystemLogger for efficiency)
+    # Get system metrics (cache SystemLogger on trainer for efficiency)
     system = {}
     try:
-        if _system_logger is None:
-            _system_logger = SystemLogger()
-        system = _system_logger.get_metrics(rates=True)
+        if not hasattr(trainer, "_platform_system_logger"):
+            trainer._platform_system_logger = SystemLogger()
+        system = trainer._platform_system_logger.get_metrics(rates=True)
     except Exception:
         pass
 
+    payload = {
+        "epoch": trainer.epoch,
+        "metrics": metrics,
+        "system": system,
+        "fitness": trainer.fitness,
+        "best_fitness": trainer.best_fitness,
+    }
+    if model_info:
+        payload["modelInfo"] = model_info
+
     _send_async(
         "epoch_end",
-        {
-            "epoch": trainer.epoch,
-            "metrics": metrics,
-            "system": system,
-            "fitness": trainer.fitness,
-            "best_fitness": trainer.best_fitness,
-        },
+        payload,
         project,
         name,
+        getattr(trainer, "_platform_model_id", None),
     )
 
 
 def on_model_save(trainer):
     """Upload model checkpoint (rate limited to every 15 min)."""
-    global _last_upload
-
     if RANK not in {-1, 0} or not trainer.args.project:
         return
 
     # Rate limit to every 15 minutes (900 seconds)
-    if time() - _last_upload < 900:
+    if time() - getattr(trainer, "_platform_last_upload", 0) < 900:
         return
 
     model_path = trainer.best if trainer.best and Path(trainer.best).exists() else trainer.last
     if not model_path:
         return
 
-    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    project, name = _get_project_name(trainer)
     _upload_model_async(model_path, project, name)
-    _last_upload = time()
+    trainer._platform_last_upload = time()
 
 
 def on_train_end(trainer):
     """Log final results, upload best model, and send validation plot data."""
-    global _console_logger
-
     if RANK not in {-1, 0} or not trainer.args.project:
         return
 
-    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    project, name = _get_project_name(trainer)
 
     # Stop console capture
-    if _console_logger:
-        _console_logger.stop_capture()
-        _console_logger = None
+    if hasattr(trainer, "_platform_console_logger") and trainer._platform_console_logger:
+        trainer._platform_console_logger.stop_capture()
+        trainer._platform_console_logger = None
 
     # Upload best model (blocking to ensure it completes)
     model_path = None
@@ -411,6 +435,7 @@ def on_train_end(trainer):
         },
         project,
         name,
+        getattr(trainer, "_platform_model_id", None),
     )
     url = f"https://alpha.ultralytics.com/{project}/{name}"
     LOGGER.info(f"{PREFIX}View results at {url}")