dgenerate-ultralytics-headless 8.3.137__py3-none-any.whl → 8.3.224__py3-none-any.whl

ultralytics/utils/cpu.py

@@ -0,0 +1,89 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+import platform
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+class CPUInfo:
+    """Provide cross-platform CPU brand and model information.
+
+    Query platform-specific sources to retrieve a human-readable CPU descriptor and normalize it for consistent
+    presentation across macOS, Linux, and Windows. If platform-specific probing fails, generic platform identifiers are
+    used to ensure a stable string is always returned.
+
+    Methods:
+        name: Return the normalized CPU name using platform-specific sources with robust fallbacks.
+        _clean: Normalize and prettify common vendor brand strings and frequency patterns.
+        __str__: Return the normalized CPU name for string contexts.
+
+    Examples:
+        >>> CPUInfo.name()
+        'Apple M4 Pro'
+        >>> str(CPUInfo())
+        'Intel Core i7-9750H 2.60GHz'
+    """
+
+    @staticmethod
+    def name() -> str:
+        """Return a normalized CPU model string from platform-specific sources."""
+        try:
+            if sys.platform == "darwin":
+                # Query macOS sysctl for the CPU brand string
+                s = subprocess.run(
+                    ["sysctl", "-n", "machdep.cpu.brand_string"], capture_output=True, text=True
+                ).stdout.strip()
+                if s:
+                    return CPUInfo._clean(s)
+            elif sys.platform.startswith("linux"):
+                # Parse /proc/cpuinfo for the first "model name" entry
+                p = Path("/proc/cpuinfo")
+                if p.exists():
+                    for line in p.read_text(errors="ignore").splitlines():
+                        if "model name" in line:
+                            return CPUInfo._clean(line.split(":", 1)[1])
+            elif sys.platform.startswith("win"):
+                try:
+                    import winreg as wr
+
+                    with wr.OpenKey(wr.HKEY_LOCAL_MACHINE, r"HARDWARE\DESCRIPTION\System\CentralProcessor\0") as k:
+                        val, _ = wr.QueryValueEx(k, "ProcessorNameString")
+                        if val:
+                            return CPUInfo._clean(val)
+                except Exception:
+                    # Fall through to generic platform fallbacks on Windows registry access failure
+                    pass
+            # Generic platform fallbacks
+            s = platform.processor() or getattr(platform.uname(), "processor", "") or platform.machine()
+            return CPUInfo._clean(s or "Unknown CPU")
+        except Exception:
+            # Ensure a string is always returned even on unexpected failures
+            s = platform.processor() or platform.machine() or ""
+            return CPUInfo._clean(s or "Unknown CPU")
+
+    @staticmethod
+    def _clean(s: str) -> str:
+        """Normalize and prettify a raw CPU descriptor string."""
+        s = re.sub(r"\s+", " ", s.strip())
+        s = s.replace("(TM)", "").replace("(tm)", "").replace("(R)", "").replace("(r)", "").strip()
+        # Normalize common Intel pattern to 'Model Freq'
+        m = re.search(r"(Intel.*?i\d[\w-]*) CPU @ ([\d.]+GHz)", s, re.I)
+        if m:
+            return f"{m.group(1)} {m.group(2)}"
+        # Normalize common AMD Ryzen pattern to 'Model Freq'
+        m = re.search(r"(AMD.*?Ryzen.*?[\w-]*) CPU @ ([\d.]+GHz)", s, re.I)
+        if m:
+            return f"{m.group(1)} {m.group(2)}"
+        return s
+
+    def __str__(self) -> str:
+        """Return the normalized CPU name."""
+        return self.name()
+
+
+if __name__ == "__main__":
+    print(CPUInfo.name())

ultralytics/utils/dist.py

@@ -10,8 +10,7 @@ from .torch_utils import TORCH_1_9
 
 
 def find_free_network_port() -> int:
-    """
-    Find a free port on localhost.
+    """Find a free port on localhost.
 
     It is useful in single-node training when we don't want to connect to a real main node but have to set the
     `MASTER_PORT` environment variable.
@@ -27,15 +26,14 @@ def find_free_network_port() -> int:
 
 
 def generate_ddp_file(trainer):
-    """
-    Generate a DDP (Distributed Data Parallel) file for multi-GPU training.
+    """Generate a DDP (Distributed Data Parallel) file for multi-GPU training.
 
-    This function creates a temporary Python file that enables distributed training across multiple GPUs.
-    The file contains the necessary configuration to initialize the trainer in a distributed environment.
+    This function creates a temporary Python file that enables distributed training across multiple GPUs. The file
+    contains the necessary configuration to initialize the trainer in a distributed environment.
 
     Args:
-        trainer (object): The trainer object containing training configuration and arguments.
-                         Must have args attribute and be a class instance.
+        trainer (ultralytics.engine.trainer.BaseTrainer): The trainer containing training configuration and arguments.
+            Must have args attribute and be a class instance.
 
     Returns:
         (str): Path to the generated temporary DDP file.
@@ -76,16 +74,14 @@ if __name__ == "__main__":
     return file.name
 
 
-def generate_ddp_command(world_size, trainer):
-    """
-    Generate command for distributed training.
+def generate_ddp_command(trainer):
+    """Generate command for distributed training.
 
     Args:
-        world_size (int): Number of processes to spawn for distributed training.
-        trainer (object): The trainer object containing configuration for distributed training.
+        trainer (ultralytics.engine.trainer.BaseTrainer): The trainer containing configuration for distributed training.
 
     Returns:
-        cmd (List[str]): The command to execute for distributed training.
+        cmd (list[str]): The command to execute for distributed training.
         file (str): Path to the temporary file created for DDP training.
     """
     import __main__  # noqa local import to avoid https://github.com/Lightning-AI/pytorch-lightning/issues/15218
@@ -95,19 +91,27 @@ def generate_ddp_command(world_size, trainer):
     file = generate_ddp_file(trainer)
     dist_cmd = "torch.distributed.run" if TORCH_1_9 else "torch.distributed.launch"
     port = find_free_network_port()
-    cmd = [sys.executable, "-m", dist_cmd, "--nproc_per_node", f"{world_size}", "--master_port", f"{port}", file]
+    cmd = [
+        sys.executable,
+        "-m",
+        dist_cmd,
+        "--nproc_per_node",
+        f"{trainer.world_size}",
+        "--master_port",
+        f"{port}",
+        file,
+    ]
     return cmd, file
 
 
 def ddp_cleanup(trainer, file):
-    """
-    Delete temporary file if created during distributed data parallel (DDP) training.
+    """Delete temporary file if created during distributed data parallel (DDP) training.
 
-    This function checks if the provided file contains the trainer's ID in its name, indicating it was created
-    as a temporary file for DDP training, and deletes it if so.
+    This function checks if the provided file contains the trainer's ID in its name, indicating it was created as a
+    temporary file for DDP training, and deletes it if so.
 
     Args:
-        trainer (object): The trainer object used for distributed training.
+        trainer (ultralytics.engine.trainer.BaseTrainer): The trainer used for distributed training.
         file (str): Path to the file that might need to be deleted.
 
     Examples: