ultralytics-opencv-headless 8.3.242__py3-none-any.whl

ultralytics/utils/cpu.py

@@ -0,0 +1,85 @@
+# 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()
+        if m := re.search(r"(Intel.*?i\d[\w-]*) CPU @ ([\d.]+GHz)", s, re.I):
+            return f"{m.group(1)} {m.group(2)}"
+        if m := re.search(r"(AMD.*?Ryzen.*?[\w-]*) CPU @ ([\d.]+GHz)", s, re.I):
+            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

@@ -0,0 +1,123 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import os
+import shutil
+import sys
+import tempfile
+
+from . import USER_CONFIG_DIR
+from .torch_utils import TORCH_1_9
+
+
+def find_free_network_port() -> int:
+    """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.
+
+    Returns:
+        (int): The available network port number.
+    """
+    import socket
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]  # port
+
+
+def generate_ddp_file(trainer):
+    """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.
+
+    Args:
+        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.
+
+    Notes:
+        The generated file is saved in the USER_CONFIG_DIR/DDP directory and includes:
+        - Trainer class import
+        - Configuration overrides from the trainer arguments
+        - Model path configuration
+        - Training initialization code
+    """
+    module, name = f"{trainer.__class__.__module__}.{trainer.__class__.__name__}".rsplit(".", 1)
+
+    content = f"""
+# Ultralytics Multi-GPU training temp file (should be automatically deleted after use)
+overrides = {vars(trainer.args)}
+
+if __name__ == "__main__":
+    from {module} import {name}
+    from ultralytics.utils import DEFAULT_CFG_DICT
+
+    cfg = DEFAULT_CFG_DICT.copy()
+    cfg.update(save_dir='')   # handle the extra key 'save_dir'
+    trainer = {name}(cfg=cfg, overrides=overrides)
+    trainer.args.model = "{getattr(trainer.hub_session, "model_url", trainer.args.model)}"
+    results = trainer.train()
+"""
+    (USER_CONFIG_DIR / "DDP").mkdir(exist_ok=True)
+    with tempfile.NamedTemporaryFile(
+        prefix="_temp_",
+        suffix=f"{id(trainer)}.py",
+        mode="w+",
+        encoding="utf-8",
+        dir=USER_CONFIG_DIR / "DDP",
+        delete=False,
+    ) as file:
+        file.write(content)
+    return file.name
+
+
+def generate_ddp_command(trainer):
+    """Generate command for distributed training.
+
+    Args:
+        trainer (ultralytics.engine.trainer.BaseTrainer): The trainer containing configuration for distributed training.
+
+    Returns:
+        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
+
+    if not trainer.resume:
+        shutil.rmtree(trainer.save_dir)  # remove the save_dir
+    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"{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.
+
+    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 (ultralytics.engine.trainer.BaseTrainer): The trainer used for distributed training.
+        file (str): Path to the file that might need to be deleted.
+
+    Examples:
+        >>> trainer = YOLOTrainer()
+        >>> file = "/tmp/ddp_temp_123456789.py"
+        >>> ddp_cleanup(trainer, file)
+    """
+    if f"{id(trainer)}.py" in file:  # if temp_file suffix in file
+        os.remove(file)