dgenerate-ultralytics-headless 8.3.193__tar.gz → 8.3.194__tar.gz

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.193
+Version: 8.3.194
 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.193 → dgenerate_ultralytics_headless-8.3.194}/dgenerate_ultralytics_headless.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.193
+Version: 8.3.194
 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.193 → dgenerate_ultralytics_headless-8.3.194}/dgenerate_ultralytics_headless.egg-info/SOURCES.txt

@@ -259,6 +259,7 @@ ultralytics/utils/checks.py
 ultralytics/utils/dist.py
 ultralytics/utils/downloads.py
 ultralytics/utils/errors.py
+ultralytics/utils/events.py
 ultralytics/utils/export.py
 ultralytics/utils/files.py
 ultralytics/utils/git.py

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/tests/test_exports.py

@@ -120,14 +120,16 @@ def test_export_torchscript_matrix(task, dynamic, int8, half, batch, nms):
 @pytest.mark.skipif(not TORCH_1_9, reason="CoreML>=7.2 not supported with PyTorch<=1.8")
 @pytest.mark.skipif(checks.IS_PYTHON_3_13, reason="CoreML not supported in Python 3.13")
 @pytest.mark.parametrize(
-    "task, dynamic, int8, half, batch",
+    "task, dynamic, int8, half, nms, batch",
     [  # generate all combinations except for exclusion cases
-        (task, dynamic, int8, half, batch)
-        for task, dynamic, int8, half, batch in product(TASKS, [False], [True, False], [True, False], [1])
-        if not (int8 and half)
+        (task, dynamic, int8, half, nms, batch)
+        for task, dynamic, int8, half, nms, batch in product(
+            TASKS, [False], [True, False], [True, False], [True, False], [1]
+        )
+        if not (int8 and half) and not (task != "detect" and nms)
     ],
 )
-def test_export_coreml_matrix(task, dynamic, int8, half, batch):
+def test_export_coreml_matrix(task, dynamic, int8, half, nms, batch):
     """Test YOLO export to CoreML format with various parameter configurations."""
     file = YOLO(TASK2MODEL[task]).export(
         format="coreml",
@@ -136,6 +138,7 @@ def test_export_coreml_matrix(task, dynamic, int8, half, batch):
         int8=int8,
         half=half,
         batch=batch,
+        nms=nms,
     )
     YOLO(file)([SOURCE] * batch, imgsz=32)  # exported model inference
     shutil.rmtree(file)  # cleanup

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/tests/test_python.py

@@ -375,7 +375,7 @@ def test_data_annotator():
 
 def test_events():
     """Test event sending functionality."""
-    from ultralytics.hub.utils import Events
+    from ultralytics.utils.events import Events
 
     events = Events()
     events.enabled = True

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/ultralytics/__init__.py

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

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/ultralytics/engine/exporter.py

@@ -587,7 +587,7 @@ class Exporter:
         """Export YOLO model to ONNX format."""
         requirements = ["onnx>=1.12.0"]
         if self.args.simplify:
-            requirements += ["onnxslim==0.1.65", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
+            requirements += ["onnxslim>=0.1.67", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
         check_requirements(requirements)
         import onnx  # noqa
 
@@ -955,17 +955,17 @@ class Exporter:
         try:
             import tensorflow as tf  # noqa
         except ImportError:
-            check_requirements("tensorflow>=2.0.0")
+            check_requirements("tensorflow>=2.0.0,<=2.19.0")
             import tensorflow as tf  # noqa
         check_requirements(
             (
-                "tf_keras",  # required by 'onnx2tf' package
+                "tf_keras<=2.19.0",  # required by 'onnx2tf' package
                 "sng4onnx>=1.0.1",  # required by 'onnx2tf' package
                 "onnx_graphsurgeon>=0.3.26",  # required by 'onnx2tf' package
                 "ai-edge-litert>=1.2.0,<1.4.0",  # required by 'onnx2tf' package
                 "onnx>=1.12.0",
                 "onnx2tf>=1.26.3",
-                "onnxslim==0.1.65",
+                "onnxslim>=0.1.67",
                 "onnxruntime-gpu" if cuda else "onnxruntime",
                 "protobuf>=5",
             ),

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/ultralytics/hub/__init__.py

@@ -3,7 +3,7 @@
 from ultralytics.data.utils import HUBDatasetStats
 from ultralytics.hub.auth import Auth
 from ultralytics.hub.session import HUBTrainingSession
-from ultralytics.hub.utils import HUB_API_ROOT, HUB_WEB_ROOT, PREFIX, events
+from ultralytics.hub.utils import HUB_API_ROOT, HUB_WEB_ROOT, PREFIX
 from ultralytics.utils import LOGGER, SETTINGS, checks
 
 __all__ = (
@@ -17,7 +17,6 @@ __all__ = (
     "export_model",
     "get_export",
     "check_dataset",
-    "events",
 )
 
 

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/ultralytics/hub/utils.py

@@ -1,31 +1,17 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 import os
-import random
 import threading
 import time
-from pathlib import Path
 from typing import Any
 
-from ultralytics import __version__
 from ultralytics.utils import (
-    ARGV,
-    ENVIRONMENT,
-    GIT,
     IS_COLAB,
-    IS_PIP_PACKAGE,
     LOGGER,
-    ONLINE,
-    PYTHON_VERSION,
-    RANK,
-    SETTINGS,
-    TESTS_RUNNING,
     TQDM,
     TryExcept,
     colorstr,
 )
-from ultralytics.utils.downloads import GITHUB_ASSETS_NAMES
-from ultralytics.utils.torch_utils import get_cpu_info
 
 HUB_API_ROOT = os.environ.get("ULTRALYTICS_HUB_API", "https://api.ultralytics.com")
 HUB_WEB_ROOT = os.environ.get("ULTRALYTICS_HUB_WEB", "https://hub.ultralytics.com")
@@ -177,90 +163,3 @@ def smart_request(
         threading.Thread(target=func, args=args, kwargs=kwargs, daemon=True).start()
     else:
         return func(*args, **kwargs)
-
-
-class Events:
-    """
-    A class for collecting anonymous event analytics.
-
-    Event analytics are enabled when sync=True in settings and disabled when sync=False. Run 'yolo settings' to see and
-    update settings.
-
-    Attributes:
-        url (str): The URL to send anonymous events.
-        events (list): List of collected events to be sent.
-        rate_limit (float): The rate limit in seconds for sending events.
-        t (float): Rate limit timer in seconds.
-        metadata (dict): A dictionary containing metadata about the environment.
-        enabled (bool): A flag to enable or disable Events based on certain conditions.
-    """
-
-    url = "https://www.google-analytics.com/mp/collect?measurement_id=G-X8NCJYTQXM&api_secret=QLQrATrNSwGRFRLE-cbHJw"
-
-    def __init__(self):
-        """Initialize the Events object with default values for events, rate_limit, and metadata."""
-        self.events = []  # events list
-        self.rate_limit = 30.0  # rate limit (seconds)
-        self.t = 0.0  # rate limit timer (seconds)
-        self.metadata = {
-            "cli": Path(ARGV[0]).name == "yolo",
-            "install": "git" if GIT.is_repo else "pip" if IS_PIP_PACKAGE else "other",
-            "python": PYTHON_VERSION.rsplit(".", 1)[0],  # i.e. 3.13
-            "CPU": get_cpu_info(),
-            # "GPU": get_gpu_info(index=0) if cuda else None,
-            "version": __version__,
-            "env": ENVIRONMENT,
-            "session_id": round(random.random() * 1e15),
-            "engagement_time_msec": 1000,
-        }
-        self.enabled = (
-            SETTINGS["sync"]
-            and RANK in {-1, 0}
-            and not TESTS_RUNNING
-            and ONLINE
-            and (IS_PIP_PACKAGE or GIT.origin == "https://github.com/ultralytics/ultralytics.git")
-        )
-
-    def __call__(self, cfg, device=None):
-        """
-        Attempt to add a new event to the events list and send events if the rate limit is reached.
-
-        Args:
-            cfg (IterableSimpleNamespace): The configuration object containing mode and task information.
-            device (torch.device | str, optional): The device type (e.g., 'cpu', 'cuda').
-        """
-        if not self.enabled:
-            # Events disabled, do nothing
-            return
-
-        # Attempt to add to events
-        if len(self.events) < 25:  # Events list limited to 25 events (drop any events past this)
-            params = {
-                **self.metadata,
-                "task": cfg.task,
-                "model": cfg.model if cfg.model in GITHUB_ASSETS_NAMES else "custom",
-                "device": str(device),
-            }
-            if cfg.mode == "export":
-                params["format"] = cfg.format
-            self.events.append({"name": cfg.mode, "params": params})
-
-        # Check rate limit
-        t = time.time()
-        if (t - self.t) < self.rate_limit:
-            # Time is under rate limiter, wait to send
-            return
-
-        # Time is over rate limiter, send now
-        data = {"client_id": SETTINGS["uuid"], "events": self.events}  # SHA-256 anonymized UUID hash and events list
-
-        # POST equivalent to requests.post(self.url, json=data)
-        smart_request("post", self.url, json=data, retry=0, verbose=False)
-
-        # Reset events and rate limit timer
-        self.events = []
-        self.t = t
-
-
-# Run below code on hub/utils init -------------------------------------------------------------------------------------
-events = Events()

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/ultralytics/models/sam/predict.py

@@ -1761,7 +1761,7 @@ class SAM2DynamicInteractivePredictor(SAM2Predictor):
     @smart_inference_mode()
     def inference(
         self,
-        img: torch.Tensor | np.ndarray,
+        im: torch.Tensor | np.ndarray,
         bboxes: list[list[float]] | None = None,
         masks: torch.Tensor | np.ndarray | None = None,
         points: list[list[float]] | None = None,
@@ -1777,7 +1777,7 @@ class SAM2DynamicInteractivePredictor(SAM2Predictor):
         When update_memory is False, it will only run inference on the provided image without updating the memory.
 
         Args:
-            img (torch.Tensor | np.ndarray): The input image tensor or numpy array.
+            im (torch.Tensor | np.ndarray): The input image tensor or numpy array.
             bboxes (List[List[float]] | None): Optional list of bounding boxes to update the memory.
             masks (List[torch.Tensor | np.ndarray] | None): Optional masks to update the memory.
             points (List[List[float]] | None): Optional list of points to update the memory, each point is [x, y].
@@ -1789,7 +1789,7 @@ class SAM2DynamicInteractivePredictor(SAM2Predictor):
             res_masks (torch.Tensor): The output masks in shape (C, H, W)
             object_score_logits (torch.Tensor): Quality scores for each mask
         """
-        self.get_im_features(img)
+        self.get_im_features(im)
         points, labels, masks = self._prepare_prompts(
             dst_shape=self.imgsz,
             src_shape=self.batch[1][0].shape[:2],

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/ultralytics/nn/autobackend.py

@@ -724,17 +724,14 @@ class AutoBackend(nn.Module):
             im_pil = Image.fromarray((im * 255).astype("uint8"))
             # im = im.resize((192, 320), Image.BILINEAR)
             y = self.model.predict({"image": im_pil})  # coordinates are xywh normalized
-            if "confidence" in y:
-                raise TypeError(
-                    "Ultralytics only supports inference of non-pipelined CoreML models exported with "
-                    f"'nms=False', but 'model={w}' has an NMS pipeline created by an 'nms=True' export."
-                )
-                # TODO: CoreML NMS inference handling
-                # from ultralytics.utils.ops import xywh2xyxy
-                # box = xywh2xyxy(y['coordinates'] * [[w, h, w, h]])  # xyxy pixels
-                # conf, cls = y['confidence'].max(1), y['confidence'].argmax(1).astype(np.float32)
-                # y = np.concatenate((box, conf.reshape(-1, 1), cls.reshape(-1, 1)), 1)
-            y = list(y.values())
+            if "confidence" in y:  # NMS included
+                from ultralytics.utils.ops import xywh2xyxy
+
+                box = xywh2xyxy(y["coordinates"] * [[w, h, w, h]])  # xyxy pixels
+                cls = y["confidence"].argmax(1, keepdims=True)
+                y = np.concatenate((box, np.take_along_axis(y["confidence"], cls, axis=1), cls), 1)[None]
+            else:
+                y = list(y.values())
             if len(y) == 2 and len(y[1].shape) != 4:  # segmentation model
                 y = list(reversed(y))  # reversed for segmentation models (pred, proto)
 

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/ultralytics/utils/__init__.py

@@ -460,8 +460,7 @@ def set_logging(name="LOGGING_NAME", verbose=True):
 
 # Set logger
 LOGGER = set_logging(LOGGING_NAME, verbose=VERBOSE)  # define globally (used in train.py, val.py, predict.py, etc.)
-for logger in "sentry_sdk", "urllib3.connectionpool":
-    logging.getLogger(logger).setLevel(logging.CRITICAL + 1)
+logging.getLogger("sentry_sdk").setLevel(logging.CRITICAL + 1)
 
 
 def emojis(string=""):

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/ultralytics/utils/callbacks/hub.py

@@ -3,8 +3,9 @@
 import json
 from time import time
 
-from ultralytics.hub import HUB_WEB_ROOT, PREFIX, HUBTrainingSession, events
+from ultralytics.hub import HUB_WEB_ROOT, PREFIX, HUBTrainingSession
 from ultralytics.utils import LOGGER, RANK, SETTINGS
+from ultralytics.utils.events import events
 
 
 def on_pretrain_routine_start(trainer):

dgenerate_ultralytics_headless-8.3.194/ultralytics/utils/events.py

@@ -0,0 +1,115 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import json
+import random
+import time
+from pathlib import Path
+from threading import Thread
+from urllib.request import Request, urlopen
+
+from ultralytics import SETTINGS, __version__
+from ultralytics.utils import ARGV, ENVIRONMENT, GIT, IS_PIP_PACKAGE, ONLINE, PYTHON_VERSION, RANK, TESTS_RUNNING
+from ultralytics.utils.downloads import GITHUB_ASSETS_NAMES
+from ultralytics.utils.torch_utils import get_cpu_info
+
+
+def _post(url: str, data: dict, timeout: float = 5.0) -> None:
+    """Send a one-shot JSON POST request."""
+    try:
+        body = json.dumps(data, separators=(",", ":")).encode()  # compact JSON
+        req = Request(url, data=body, headers={"Content-Type": "application/json"})
+        urlopen(req, timeout=timeout).close()
+    except Exception:
+        pass
+
+
+class Events:
+    """
+    Collect and send anonymous usage analytics with rate-limiting.
+
+    Event collection and transmission are enabled when sync is enabled in settings, the current process is rank -1 or 0,
+    tests are not running, the environment is online, and the installation source is either pip or the official
+    Ultralytics GitHub repository.
+
+    Attributes:
+        url (str): Measurement Protocol endpoint for receiving anonymous events.
+        events (list[dict]): In-memory queue of event payloads awaiting transmission.
+        rate_limit (float): Minimum time in seconds between POST requests.
+        t (float): Timestamp of the last transmission in seconds since the epoch.
+        metadata (dict): Static metadata describing runtime, installation source, and environment.
+        enabled (bool): Flag indicating whether analytics collection is active.
+
+    Methods:
+        __init__: Initialize the event queue, rate limiter, and runtime metadata.
+        __call__: Queue an event and trigger a non-blocking send when the rate limit elapses.
+    """
+
+    url = "https://www.google-analytics.com/mp/collect?measurement_id=G-X8NCJYTQXM&api_secret=QLQrATrNSwGRFRLE-cbHJw"
+
+    def __init__(self) -> None:
+        """Initialize the Events instance with queue, rate limiter, and environment metadata."""
+        self.events = []  # pending events
+        self.rate_limit = 30.0  # rate limit (seconds)
+        self.t = 0.0  # last send timestamp (seconds)
+        self.metadata = {
+            "cli": Path(ARGV[0]).name == "yolo",
+            "install": "git" if GIT.is_repo else "pip" if IS_PIP_PACKAGE else "other",
+            "python": PYTHON_VERSION.rsplit(".", 1)[0],  # i.e. 3.13
+            "CPU": get_cpu_info(),
+            # "GPU": get_gpu_info(index=0) if cuda else None,
+            "version": __version__,
+            "env": ENVIRONMENT,
+            "session_id": round(random.random() * 1e15),
+            "engagement_time_msec": 1000,
+        }
+        self.enabled = (
+            SETTINGS["sync"]
+            and RANK in {-1, 0}
+            and not TESTS_RUNNING
+            and ONLINE
+            and (IS_PIP_PACKAGE or GIT.origin == "https://github.com/ultralytics/ultralytics.git")
+        )
+
+    def __call__(self, cfg, device=None) -> None:
+        """
+        Queue an event and flush the queue asynchronously when the rate limit elapses.
+
+        Args:
+            cfg (IterableSimpleNamespace): The configuration object containing mode and task information.
+            device (torch.device | str, optional): The device type (e.g., 'cpu', 'cuda').
+        """
+        if not self.enabled:
+            # Events disabled, do nothing
+            return
+
+        # Attempt to enqueue a new event
+        if len(self.events) < 25:  # Queue limited to 25 events to bound memory and traffic
+            params = {
+                **self.metadata,
+                "task": cfg.task,
+                "model": cfg.model if cfg.model in GITHUB_ASSETS_NAMES else "custom",
+                "device": str(device),
+            }
+            if cfg.mode == "export":
+                params["format"] = cfg.format
+            self.events.append({"name": cfg.mode, "params": params})
+
+        # Check rate limit and return early if under limit
+        t = time.time()
+        if (t - self.t) < self.rate_limit:
+            return
+
+        # Overrate limit: send a snapshot of queued events in a background thread
+        payload_events = list(self.events)  # snapshot to avoid race with queue reset
+        Thread(
+            target=_post,
+            args=(self.url, {"client_id": SETTINGS["uuid"], "events": payload_events}),  # SHA-256 anonymized
+            daemon=True,
+        ).start()
+
+        # Reset queue and rate limit timer
+        self.events = []
+        self.t = t
+
+
+events = Events()

{dgenerate_ultralytics_headless-8.3.193 → dgenerate_ultralytics_headless-8.3.194}/ultralytics/utils/ops.py

@@ -244,7 +244,9 @@ def scale_image(masks, im0_shape, ratio_pad=None):
     if len(masks.shape) < 2:
         raise ValueError(f'"len of masks shape" should be 2 or 3, but got {len(masks.shape)}')
     masks = masks[top:bottom, left:right]
-    masks = cv2.resize(masks, (im0_w, im0_h))
+    # handle the cv2.resize 512 channels limitation: https://github.com/ultralytics/ultralytics/pull/21947
+    masks = [cv2.resize(array, (im0_w, im0_h)) for array in np.array_split(masks, masks.shape[-1] // 512 + 1, axis=-1)]
+    masks = np.concatenate(masks, axis=-1) if len(masks) > 1 else masks[0]
     if len(masks.shape) == 2:
         masks = masks[:, :, None]