dgenerate-ultralytics-headless 8.3.189__tar.gz → 8.3.190__tar.gz

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/PKG-INFO

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

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

@@ -265,6 +265,7 @@ 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

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/__init__.py

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

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/data/utils.py

@@ -464,7 +464,7 @@ def check_det_dataset(dataset: str, autodownload: bool = True) -> Dict[str, Any]
                 safe_download(url=s, dir=DATASETS_DIR, delete=True)
             elif s.startswith("bash "):  # bash script
                 LOGGER.info(f"Running {s} ...")
-                r = os.system(s)
+                subprocess.run(s.split(), check=True)
             else:  # python script
                 exec(s, {"yaml": data})
             dt = f"({round(time.time() - t, 1)}s)"
@@ -509,7 +509,7 @@ def check_cls_dataset(dataset: Union[str, Path], split: str = "") -> Dict[str, A
         LOGGER.warning(f"Dataset not found, missing path {data_dir}, attempting download...")
         t = time.time()
         if str(dataset) == "imagenet":
-            subprocess.run(f"bash {ROOT / 'data/scripts/get_imagenet.sh'}", shell=True, check=True)
+            subprocess.run(["bash", str(ROOT / "data/scripts/get_imagenet.sh")], check=True)
         else:
             url = f"https://github.com/ultralytics/assets/releases/download/v0.0.0/{dataset}.zip"
             download(url, dir=data_dir.parent)

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/engine/exporter.py

@@ -107,7 +107,9 @@ from ultralytics.utils.checks import (
 from ultralytics.utils.downloads import attempt_download_asset, get_github_assets, safe_download
 from ultralytics.utils.export import export_engine, export_onnx
 from ultralytics.utils.files import file_size, spaces_in_path
-from ultralytics.utils.ops import Profile, nms_rotated
+from ultralytics.utils.metrics import batch_probiou
+from ultralytics.utils.nms import TorchNMS
+from ultralytics.utils.ops import Profile
 from ultralytics.utils.patches import arange_patch
 from ultralytics.utils.torch_utils import TORCH_1_13, get_latest_opset, select_device
 
@@ -1562,12 +1564,13 @@ class NMSModel(torch.nn.Module):
                 nmsbox = torch.cat((offbox, nmsbox[:, end:]), dim=-1)
             nms_fn = (
                 partial(
-                    nms_rotated,
+                    TorchNMS.fast_nms,
                     use_triu=not (
                         self.is_tf
                         or (self.args.opset or 14) < 14
                         or (self.args.format == "openvino" and self.args.int8)  # OpenVINO int8 error with triu
                     ),
+                    iou_func=batch_probiou,
                 )
                 if self.obb
                 else nms

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/engine/predictor.py

@@ -389,7 +389,7 @@ class BasePredictor:
             verbose (bool): Whether to print verbose output.
         """
         self.model = AutoBackend(
-            weights=model or self.args.model,
+            model=model or self.args.model,
             device=select_device(self.args.device, verbose=verbose),
             dnn=self.args.dnn,
             data=self.args.data,

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/engine/results.py

@@ -681,12 +681,12 @@ class Results(SimpleClass, DataExportMixin):
             - For classification tasks, it returns the top 5 class probabilities and their corresponding class names.
             - The returned string is comma-separated and ends with a comma and a space.
         """
-        probs = self.probs
+        boxes = self.obb if self.obb is not None else self.boxes
         if len(self) == 0:
-            return "" if probs is not None else "(no detections), "
-        if probs is not None:
-            return f"{', '.join(f'{self.names[j]} {probs.data[j]:.2f}' for j in probs.top5)}, "
-        if boxes := self.boxes:
+            return "" if self.probs is not None else "(no detections), "
+        if self.probs is not None:
+            return f"{', '.join(f'{self.names[j]} {self.probs.data[j]:.2f}' for j in self.probs.top5)}, "
+        if boxes:
             counts = boxes.cls.int().bincount()
             return "".join(f"{n} {self.names[i]}{'s' * (n > 1)}, " for i, n in enumerate(counts) if n > 0)
 

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/engine/trainer.py

@@ -36,6 +36,7 @@ from ultralytics.utils import (
     clean_url,
     colorstr,
     emojis,
+    get_git_commit,
 )
 from ultralytics.utils.autobatch import check_train_batch_size
 from ultralytics.utils.checks import check_amp, check_file, check_imgsz, check_model_file_from_stem, print_args
@@ -572,6 +573,7 @@ class BaseTrainer:
                 "train_results": self.read_results_csv(),
                 "date": datetime.now().isoformat(),
                 "version": __version__,
+                "git_commit": get_git_commit(),
                 "license": "AGPL-3.0 (https://ultralytics.com/license)",
                 "docs": "https://docs.ultralytics.com",
             },

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/engine/validator.py

@@ -101,6 +101,8 @@ class BaseValidator:
             args (SimpleNamespace, optional): Configuration for the validator.
             _callbacks (dict, optional): Dictionary to store various callback functions.
         """
+        import torchvision  # noqa (import here so torchvision import time not recorded in postprocess time)
+
         self.args = get_cfg(overrides=args)
         self.dataloader = dataloader
         self.stride = None
@@ -155,7 +157,7 @@ class BaseValidator:
                 LOGGER.warning("validating an untrained model YAML will result in 0 mAP.")
             callbacks.add_integration_callbacks(self)
             model = AutoBackend(
-                weights=model or self.args.model,
+                model=model or self.args.model,
                 device=select_device(self.args.device, self.args.batch),
                 dnn=self.args.dnn,
                 data=self.args.data,

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/hub/__init__.py

@@ -1,7 +1,5 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-import requests
-
 from ultralytics.data.utils import HUBDatasetStats
 from ultralytics.hub.auth import Auth
 from ultralytics.hub.session import HUBTrainingSession
@@ -75,6 +73,8 @@ def logout():
 
 def reset_model(model_id: str = ""):
     """Reset a trained model to an untrained state."""
+    import requests  # scoped as slow import
+
     r = requests.post(f"{HUB_API_ROOT}/model-reset", json={"modelId": model_id}, headers={"x-api-key": Auth().api_key})
     if r.status_code == 200:
         LOGGER.info(f"{PREFIX}Model reset successfully")
@@ -105,6 +105,8 @@ def export_model(model_id: str = "", format: str = "torchscript"):
         >>> from ultralytics import hub
         >>> hub.export_model(model_id="your_model_id", format="torchscript")
     """
+    import requests  # scoped as slow import
+
     assert format in export_fmts_hub(), f"Unsupported export format '{format}', valid formats are {export_fmts_hub()}"
     r = requests.post(
         f"{HUB_API_ROOT}/v1/models/{model_id}/export", json={"format": format}, headers={"x-api-key": Auth().api_key}
@@ -132,6 +134,8 @@ def get_export(model_id: str = "", format: str = "torchscript"):
         >>> from ultralytics import hub
         >>> result = hub.get_export(model_id="your_model_id", format="torchscript")
     """
+    import requests  # scoped as slow import
+
     assert format in export_fmts_hub(), f"Unsupported export format '{format}', valid formats are {export_fmts_hub()}"
     r = requests.post(
         f"{HUB_API_ROOT}/get-export",

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/hub/auth.py

@@ -1,7 +1,5 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-import requests
-
 from ultralytics.hub.utils import HUB_API_ROOT, HUB_WEB_ROOT, PREFIX, request_with_credentials
 from ultralytics.utils import IS_COLAB, LOGGER, SETTINGS, emojis
 
@@ -110,6 +108,8 @@ class Auth:
         Returns:
             (bool): True if authentication is successful, False otherwise.
         """
+        import requests  # scoped as slow import
+
         try:
             if header := self.get_auth_header():
                 r = requests.post(f"{HUB_API_ROOT}/v1/auth", headers=header)

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/hub/google/__init__.py

@@ -5,8 +5,6 @@ import statistics
 import time
 from typing import List, Optional, Tuple
 
-import requests
-
 
 class GCPRegions:
     """
@@ -101,6 +99,8 @@ class GCPRegions:
             >>> region, mean, std, min_lat, max_lat = GCPRegions._ping_region("us-central1", attempts=3)
             >>> print(f"Region {region} has mean latency: {mean:.2f}ms")
         """
+        import requests  # scoped as slow import
+
         url = f"https://{region}-docker.pkg.dev"
         latencies = []
         for _ in range(attempts):

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/hub/session.py

@@ -8,8 +8,6 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 from urllib.parse import parse_qs, urlparse
 
-import requests
-
 from ultralytics import __version__
 from ultralytics.hub.utils import HELP_MSG, HUB_WEB_ROOT, PREFIX
 from ultralytics.utils import IS_COLAB, LOGGER, SETTINGS, TQDM, checks, emojis
@@ -341,7 +339,7 @@ class HUBTrainingSession:
         }
         return status_code in retry_codes
 
-    def _get_failure_message(self, response: requests.Response, retry: int, timeout: int) -> str:
+    def _get_failure_message(self, response, retry: int, timeout: int) -> str:
         """
         Generate a retry message based on the response status code.
 
@@ -419,14 +417,14 @@ class HUBTrainingSession:
         )
 
     @staticmethod
-    def _show_upload_progress(content_length: int, response: requests.Response) -> None:
+    def _show_upload_progress(content_length: int, response) -> None:
         """Display a progress bar to track the upload progress of a file download."""
         with TQDM(total=content_length, unit="B", unit_scale=True, unit_divisor=1024) as pbar:
             for data in response.iter_content(chunk_size=1024):
                 pbar.update(len(data))
 
     @staticmethod
-    def _iterate_content(response: requests.Response) -> None:
+    def _iterate_content(response) -> None:
         """Process the streamed HTTP response data."""
         for _ in response.iter_content(chunk_size=1024):
             pass  # Do nothing with data chunks

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/hub/utils.py

@@ -5,9 +5,7 @@ import random
 import threading
 import time
 from pathlib import Path
-from typing import Any, Optional
-
-import requests
+from typing import Any
 
 from ultralytics import __version__
 from ultralytics.utils import (
@@ -78,7 +76,7 @@ def request_with_credentials(url: str) -> Any:
     return output.eval_js("_hub_tmp")
 
 
-def requests_with_progress(method: str, url: str, **kwargs) -> requests.Response:
+def requests_with_progress(method: str, url: str, **kwargs):
     """
     Make an HTTP request using the specified method and URL, with an optional progress bar.
 
@@ -95,6 +93,8 @@ def requests_with_progress(method: str, url: str, **kwargs) -> requests.Response
           content length.
         - If 'progress' is a number then progress bar will display assuming content length = progress.
     """
+    import requests  # scoped as slow import
+
     progress = kwargs.pop("progress", False)
     if not progress:
         return requests.request(method, url, **kwargs)
@@ -120,7 +120,7 @@ def smart_request(
     verbose: bool = True,
     progress: bool = False,
     **kwargs,
-) -> Optional[requests.Response]:
+):
     """
     Make an HTTP request using the 'requests' library, with exponential backoff retries up to a specified timeout.
 

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/models/yolo/detect/predict.py

@@ -2,7 +2,7 @@
 
 from ultralytics.engine.predictor import BasePredictor
 from ultralytics.engine.results import Results
-from ultralytics.utils import ops
+from ultralytics.utils import nms, ops
 
 
 class DetectionPredictor(BasePredictor):
@@ -53,7 +53,7 @@ class DetectionPredictor(BasePredictor):
             >>> processed_results = predictor.postprocess(preds, img, orig_imgs)
         """
         save_feats = getattr(self, "_feats", None) is not None
-        preds = ops.non_max_suppression(
+        preds = nms.non_max_suppression(
             preds,
             self.args.conf,
             self.args.iou,

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/models/yolo/detect/val.py

@@ -9,7 +9,7 @@ import torch
 
 from ultralytics.data import build_dataloader, build_yolo_dataset, converter
 from ultralytics.engine.validator import BaseValidator
-from ultralytics.utils import LOGGER, ops
+from ultralytics.utils import LOGGER, nms, ops
 from ultralytics.utils.checks import check_requirements
 from ultralytics.utils.metrics import ConfusionMatrix, DetMetrics, box_iou
 from ultralytics.utils.plotting import plot_images
@@ -115,7 +115,7 @@ class DetectionValidator(BaseValidator):
             (List[Dict[str, torch.Tensor]]): Processed predictions after NMS, where each dict contains
                 'bboxes', 'conf', 'cls', and 'extra' tensors.
         """
-        outputs = ops.non_max_suppression(
+        outputs = nms.non_max_suppression(
             preds,
             self.args.conf,
             self.args.iou,

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/models/yolo/obb/val.py

@@ -9,6 +9,7 @@ import torch
 from ultralytics.models.yolo.detect import DetectionValidator
 from ultralytics.utils import LOGGER, ops
 from ultralytics.utils.metrics import OBBMetrics, batch_probiou
+from ultralytics.utils.nms import TorchNMS
 
 
 class OBBValidator(DetectionValidator):
@@ -281,7 +282,7 @@ class OBBValidator(DetectionValidator):
                 b = bbox[:, :5].clone()
                 b[:, :2] += c
                 # 0.3 could get results close to the ones from official merging script, even slightly better.
-                i = ops.nms_rotated(b, scores, 0.3)
+                i = TorchNMS.fast_nms(b, scores, 0.3, iou_func=batch_probiou)
                 bbox = bbox[i]
 
                 b = ops.xywhr2xyxyxyxy(bbox[:, :5]).view(-1, 8)

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/nn/autobackend.py

@@ -127,14 +127,14 @@ class AutoBackend(nn.Module):
         _model_type: Determine the model type from file path.
 
     Examples:
-        >>> model = AutoBackend(weights="yolo11n.pt", device="cuda")
+        >>> model = AutoBackend(model="yolo11n.pt", device="cuda")
         >>> results = model(img)
     """
 
     @torch.no_grad()
     def __init__(
         self,
-        weights: Union[str, List[str], torch.nn.Module] = "yolo11n.pt",
+        model: Union[str, List[str], torch.nn.Module] = "yolo11n.pt",
         device: torch.device = torch.device("cpu"),
         dnn: bool = False,
         data: Optional[Union[str, Path]] = None,
@@ -146,7 +146,7 @@ class AutoBackend(nn.Module):
         Initialize the AutoBackend for inference.
 
         Args:
-            weights (str | List[str] | torch.nn.Module): Path to the model weights file or a module instance.
+            model (str | List[str] | torch.nn.Module): Path to the model weights file or a module instance.
             device (torch.device): Device to run the model on.
             dnn (bool): Use OpenCV DNN module for ONNX inference.
             data (str | Path, optional): Path to the additional data.yaml file containing class names.
@@ -155,8 +155,8 @@ class AutoBackend(nn.Module):
             verbose (bool): Enable verbose logging.
         """
         super().__init__()
-        w = str(weights[0] if isinstance(weights, list) else weights)
-        nn_module = isinstance(weights, torch.nn.Module)
+        w = str(model[0] if isinstance(model, list) else model)
+        nn_module = isinstance(model, torch.nn.Module)
         (
             pt,
             jit,
@@ -180,7 +180,7 @@ class AutoBackend(nn.Module):
         nhwc = coreml or saved_model or pb or tflite or edgetpu or rknn  # BHWC formats (vs torch BCWH)
         stride, ch = 32, 3  # default stride and channels
         end2end, dynamic = False, False
-        model, metadata, task = None, None, None
+        metadata, task = None, None
 
         # Set device
         cuda = isinstance(device, torch.device) and torch.cuda.is_available() and device.type != "cpu"  # use CUDA
@@ -192,36 +192,32 @@ class AutoBackend(nn.Module):
         if not (pt or triton or nn_module):
             w = attempt_download_asset(w)
 
-        # In-memory PyTorch model
-        if nn_module:
-            if fuse:
-                if IS_JETSON and is_jetson(jetpack=5):
-                    # Jetson Jetpack5 requires device before fuse https://github.com/ultralytics/ultralytics/pull/21028
-                    weights = weights.to(device)
-                weights = weights.fuse(verbose=verbose)
-            model = weights.to(device)
-            if hasattr(model, "kpt_shape"):
-                kpt_shape = model.kpt_shape  # pose-only
-            stride = max(int(model.stride.max()), 32)  # model stride
-            names = model.module.names if hasattr(model, "module") else model.names  # get class names
-            model.half() if fp16 else model.float()
-            ch = model.yaml.get("channels", 3)
-            self.model = model  # explicitly assign for to(), cpu(), cuda(), half()
-            pt = True
-
-        # PyTorch
-        elif pt:
-            from ultralytics.nn.tasks import attempt_load_weights
+        # PyTorch (in-memory or file)
+        if nn_module or pt:
+            if nn_module:
+                pt = True
+                if fuse:
+                    if IS_JETSON and is_jetson(jetpack=5):
+                        # Jetson Jetpack5 requires device before fuse https://github.com/ultralytics/ultralytics/pull/21028
+                        model = model.to(device)
+                    model = model.fuse(verbose=verbose)
+                model = model.to(device)
+            else:  # pt file
+                from ultralytics.nn.tasks import attempt_load_weights
+
+                model = attempt_load_weights(
+                    model if isinstance(model, list) else w, device=device, inplace=True, fuse=fuse
+                )
 
-            model = attempt_load_weights(
-                weights if isinstance(weights, list) else w, device=device, inplace=True, fuse=fuse
-            )
+            # Common PyTorch model processing
             if hasattr(model, "kpt_shape"):
                 kpt_shape = model.kpt_shape  # pose-only
             stride = max(int(model.stride.max()), 32)  # model stride
             names = model.module.names if hasattr(model, "module") else model.names  # get class names
             model.half() if fp16 else model.float()
             ch = model.yaml.get("channels", 3)
+            for p in model.parameters():
+                p.requires_grad = False
             self.model = model  # explicitly assign for to(), cpu(), cuda(), half()
 
         # TorchScript
@@ -407,6 +403,7 @@ class AutoBackend(nn.Module):
 
         # CoreML
         elif coreml:
+            check_requirements("coremltools>=8.0")
             LOGGER.info(f"Loading {w} for CoreML inference...")
             import coremltools as ct
 
@@ -601,18 +598,13 @@ class AutoBackend(nn.Module):
             dynamic = metadata.get("args", {}).get("dynamic", dynamic)
             ch = metadata.get("channels", 3)
         elif not (pt or triton or nn_module):
-            LOGGER.warning(f"Metadata not found for 'model={weights}'")
+            LOGGER.warning(f"Metadata not found for 'model={w}'")
 
         # Check names
         if "names" not in locals():  # names missing
             names = default_class_names(data)
         names = check_class_names(names)
 
-        # Disable gradients
-        if pt:
-            for p in model.parameters():
-                p.requires_grad = False
-
         self.__dict__.update(locals())  # assign all variables to self
 
     def forward(
@@ -858,8 +850,6 @@ class AutoBackend(nn.Module):
         Args:
             imgsz (tuple): The shape of the dummy input tensor in the format (batch_size, channels, height, width)
         """
-        import torchvision  # noqa (import here so torchvision import time not recorded in postprocess time)
-
         warmup_types = self.pt, self.jit, self.onnx, self.engine, self.saved_model, self.pb, self.triton, self.nn_module
         if any(warmup_types) and (self.device.type != "cpu" or self.triton):
             im = torch.empty(*imgsz, dtype=torch.half if self.fp16 else torch.float, device=self.device)  # input
@@ -878,7 +868,7 @@ class AutoBackend(nn.Module):
             (List[bool]): List of booleans indicating the model type.
 
         Examples:
-            >>> model = AutoBackend(weights="path/to/model.onnx")
+            >>> model = AutoBackend(model="path/to/model.onnx")
             >>> model_type = model._model_type()  # returns "onnx"
         """
         from ultralytics.engine.exporter import export_formats

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/nn/modules/__init__.py

@@ -7,14 +7,14 @@ blocks, attention mechanisms, transformer components, and detection/segmentation
 
 Examples:
     Visualize a module with Netron
-    >>> from ultralytics.nn.modules import *
+    >>> from ultralytics.nn.modules import Conv
     >>> import torch
-    >>> import os
+    >>> import subprocess
     >>> x = torch.ones(1, 128, 40, 40)
     >>> m = Conv(128, 128)
     >>> f = f"{m._get_name()}.onnx"
     >>> torch.onnx.export(m, x, f)
-    >>> os.system(f"onnxslim {f} {f} && open {f}")  # pip install onnxslim
+    >>> subprocess.run(f"onnxslim {f} {f} && open {f}", shell=True, check=True)  # pip install onnxslim
 """
 
 from .block import (

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/nn/modules/head.py

@@ -10,6 +10,7 @@ import torch.nn as nn
 import torch.nn.functional as F
 from torch.nn.init import constant_, xavier_uniform_
 
+from ultralytics.utils import NOT_MACOS14
 from ultralytics.utils.tal import TORCH_1_10, dist2bbox, dist2rbox, make_anchors
 from ultralytics.utils.torch_utils import fuse_conv_and_bn, smart_inference_mode
 
@@ -408,7 +409,10 @@ class Pose(Detect):
         else:
             y = kpts.clone()
             if ndim == 3:
-                y[:, 2::ndim] = y[:, 2::ndim].sigmoid()  # sigmoid (WARNING: inplace .sigmoid_() Apple MPS bug)
+                if NOT_MACOS14:
+                    y[:, 2::ndim].sigmoid_()
+                else:  # Apple macOS14 MPS bug https://github.com/ultralytics/ultralytics/pull/21878
+                    y[:, 2::ndim] = y[:, 2::ndim].sigmoid()
             y[:, 0::ndim] = (y[:, 0::ndim] * 2.0 + (self.anchors[0] - 0.5)) * self.strides
             y[:, 1::ndim] = (y[:, 1::ndim] * 2.0 + (self.anchors[1] - 0.5)) * self.strides
             return y

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/utils/__init__.py

@@ -8,6 +8,7 @@ import logging
 import os
 import platform
 import re
+import socket
 import subprocess
 import sys
 import threading
@@ -44,6 +45,7 @@ VERBOSE = str(os.getenv("YOLO_VERBOSE", True)).lower() == "true"  # global verbo
 LOGGING_NAME = "ultralytics"
 MACOS, LINUX, WINDOWS = (platform.system() == x for x in ["Darwin", "Linux", "Windows"])  # environment booleans
 MACOS_VERSION = platform.mac_ver()[0] if MACOS else None
+NOT_MACOS14 = not (MACOS and MACOS_VERSION.startswith("14."))
 ARM64 = platform.machine() in {"arm64", "aarch64"}  # ARM64 booleans
 PYTHON_VERSION = platform.python_version()
 TORCH_VERSION = torch.__version__
@@ -752,20 +754,21 @@ def is_jetson(jetpack=None) -> bool:
 
 def is_online() -> bool:
     """
-    Check internet connectivity by attempting to connect to a known online host.
+    Fast online check using DNS (v4/v6) resolution (Cloudflare + Google).
 
     Returns:
         (bool): True if connection is successful, False otherwise.
     """
-    try:
-        assert str(os.getenv("YOLO_OFFLINE", "")).lower() != "true"  # check if ENV var YOLO_OFFLINE="True"
-        import socket
+    if str(os.getenv("YOLO_OFFLINE", "")).lower() == "true":
+        return False
 
-        for dns in ("1.1.1.1", "8.8.8.8"):  # check Cloudflare and Google DNS
-            socket.create_connection(address=(dns, 80), timeout=2.0).close()
+    for host in ("one.one.one.one", "dns.google"):
+        try:
+            socket.getaddrinfo(host, 0, socket.AF_UNSPEC, 0, 0, socket.AI_ADDRCONFIG)
             return True
-    except Exception:
-        return False
+        except OSError:
+            continue
+    return False
 
 
 def is_pip_package(filepath: str = __name__) -> bool:
@@ -842,6 +845,7 @@ def is_git_dir():
     return GIT_DIR is not None
 
 
+@lru_cache(maxsize=1)
 def get_git_origin_url():
     """
     Retrieve the origin URL of a git repository.
@@ -851,12 +855,14 @@ def get_git_origin_url():
     """
     if IS_GIT_DIR:
         try:
-            origin = subprocess.check_output(["git", "config", "--get", "remote.origin.url"])
-            return origin.decode().strip()
+            return subprocess.check_output(
+                ["git", "config", "--get", "remote.origin.url"], stderr=subprocess.DEVNULL, text=True
+            ).strip()
         except subprocess.CalledProcessError:
             return None
 
 
+@lru_cache(maxsize=1)
 def get_git_branch():
     """
     Return the current git branch name. If not in a git repository, return None.
@@ -866,8 +872,24 @@ def get_git_branch():
     """
     if IS_GIT_DIR:
         try:
-            origin = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
-            return origin.decode().strip()
+            return subprocess.check_output(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"], stderr=subprocess.DEVNULL, text=True
+            ).strip()
+        except subprocess.CalledProcessError:
+            return None
+
+
+@lru_cache(maxsize=1)
+def get_git_commit():
+    """
+    Return the current git commit hash. If not in a git repository, return None.
+
+    Returns:
+        (str | None): The current git commit hash or None if not a git directory.
+    """
+    if IS_GIT_DIR:
+        try:
+            return subprocess.check_output(["git", "rev-parse", "HEAD"], stderr=subprocess.DEVNULL, text=True).strip()
         except subprocess.CalledProcessError:
             return None
 

{dgenerate_ultralytics_headless-8.3.189 → dgenerate_ultralytics_headless-8.3.190}/ultralytics/utils/callbacks/platform.py

@@ -1,12 +1,13 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 from ultralytics.utils import RANK, SETTINGS
-from ultralytics.utils.logger import DEFAULT_LOG_PATH, ConsoleLogger, SystemLogger
 
 
 def on_pretrain_routine_start(trainer):
     """Initialize and start console logging immediately at the very beginning."""
     if RANK in {-1, 0}:
+        from ultralytics.utils.logger import DEFAULT_LOG_PATH, ConsoleLogger, SystemLogger
+
         trainer.system_logger = SystemLogger()
         trainer.console_logger = ConsoleLogger(DEFAULT_LOG_PATH)
         trainer.console_logger.start_capture()