ultralytics 8.3.124__py3-none-any.whl → 8.3.126__py3-none-any.whl

ultralytics/solutions/analytics.py

@@ -3,10 +3,7 @@
 from itertools import cycle
 
 import cv2
-import matplotlib.pyplot as plt
 import numpy as np
-from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
-from matplotlib.figure import Figure
 
 from ultralytics.solutions.solutions import BaseSolution, SolutionResults  # Import a parent class
 
@@ -32,7 +29,7 @@ class Analytics(BaseSolution):
         clswise_count (Dict[str, int]): Dictionary for class-wise object counts.
         fig (Figure): Matplotlib figure object for the chart.
         ax (Axes): Matplotlib axes object for the chart.
-        canvas (FigureCanvas): Canvas for rendering the chart.
+        canvas (FigureCanvasAgg): Canvas for rendering the chart.
         lines (dict): Dictionary to store line objects for area charts.
         color_mapping (Dict[str, str]): Dictionary mapping class labels to colors for consistent visualization.
 
@@ -51,6 +48,10 @@ class Analytics(BaseSolution):
         """Initialize Analytics class with various chart types for visual data representation."""
         super().__init__(**kwargs)
 
+        import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+        from matplotlib.backends.backend_agg import FigureCanvasAgg
+        from matplotlib.figure import Figure
+
         self.type = self.CFG["analytics_type"]  # type of analytics i.e "line", "pie", "bar" or "area" charts.
         self.x_label = "Classes" if self.type in {"bar", "pie"} else "Frame#"
         self.y_label = "Total Counts"
@@ -71,14 +72,14 @@ class Analytics(BaseSolution):
         if self.type in {"line", "area"}:
             self.lines = {}
             self.fig = Figure(facecolor=self.bg_color, figsize=figsize)
-            self.canvas = FigureCanvas(self.fig)  # Set common axis properties
+            self.canvas = FigureCanvasAgg(self.fig)  # Set common axis properties
             self.ax = self.fig.add_subplot(111, facecolor=self.bg_color)
             if self.type == "line":
                 (self.line,) = self.ax.plot([], [], color="cyan", linewidth=self.line_width)
         elif self.type in {"bar", "pie"}:
             # Initialize bar or pie plot
             self.fig, self.ax = plt.subplots(figsize=figsize, facecolor=self.bg_color)
-            self.canvas = FigureCanvas(self.fig)  # Set common axis properties
+            self.canvas = FigureCanvasAgg(self.fig)  # Set common axis properties
             self.ax.set_facecolor(self.bg_color)
             self.color_mapping = {}
 

ultralytics/trackers/track.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 import torch
 
-from ultralytics.utils import IterableSimpleNamespace, yaml_load
+from ultralytics.utils import YAML, IterableSimpleNamespace
 from ultralytics.utils.checks import check_yaml
 
 from .bot_sort import BOTSORT
@@ -39,7 +39,7 @@ def on_predict_start(predictor: object, persist: bool = False) -> None:
         return
 
     tracker = check_yaml(predictor.args.tracker)
-    cfg = IterableSimpleNamespace(**yaml_load(tracker))
+    cfg = IterableSimpleNamespace(**YAML.load(tracker))
 
     if cfg.tracker_type not in {"bytetrack", "botsort"}:
         raise AssertionError(f"Only 'bytetrack' and 'botsort' are supported for now, but got '{cfg.tracker_type}'")

ultralytics/utils/__init__.py

@@ -20,11 +20,9 @@ from typing import Union
 from urllib.parse import unquote
 
 import cv2
-import matplotlib.pyplot as plt
 import numpy as np
 import torch
 import tqdm
-import yaml
 
 from ultralytics import __version__
 from ultralytics.utils.patches import imread, imshow, imwrite, torch_load, torch_save  # for patches
@@ -184,6 +182,10 @@ class TQDM(rich.tqdm if TQDM_RICH else tqdm.tqdm):
         kwargs.setdefault("bar_format", TQDM_BAR_FORMAT)  # override default value if passed
         super().__init__(*args, **kwargs)
 
+    def __iter__(self):
+        """Return self as iterator to satisfy Iterable interface."""
+        return super().__iter__()
+
 
 class SimpleClass:
     """
@@ -330,6 +332,8 @@ def plt_settings(rcparams=None, backend="Agg"):
 
         def wrapper(*args, **kwargs):
             """Sets rc parameters and backend, calls the original function, and restores the settings."""
+            import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+
             original_backend = plt.get_backend()
             switch = backend.lower() != original_backend.lower()
             if switch:
@@ -468,84 +472,142 @@ class ThreadingLocked:
         return decorated
 
 
-def yaml_save(file="data.yaml", data=None, header=""):
+class YAML:
     """
-    Save YAML data to a file.
+    YAML utility class for efficient file operations with automatic C-implementation detection.
 
-    Args:
-        file (str, optional): File name. Default is 'data.yaml'.
-        data (dict): Data to save in YAML format.
-        header (str, optional): YAML header to add.
+    This class provides optimized YAML loading and saving operations using PyYAML's fastest available implementation
+    (C-based when possible). It implements a singleton pattern with lazy initialization, allowing direct class method
+    usage without explicit instantiation. The class handles file path creation, validation, and character encoding
+    issues automatically.
 
-    Returns:
-        (None): Data is saved to the specified file.
+    The implementation prioritizes performance through:
+        - Automatic C-based loader/dumper selection when available
+        - Singleton pattern to reuse the same instance
+        - Lazy initialization to defer import costs until needed
+        - Fallback mechanisms for handling problematic YAML content
+
+    Attributes:
+        _instance: Internal singleton instance storage.
+        yaml: Reference to the PyYAML module.
+        SafeLoader: Best available YAML loader (CSafeLoader if available).
+        SafeDumper: Best available YAML dumper (CSafeDumper if available).
+
+    Examples:
+        >>> data = YAML.load("config.yaml")
+        >>> data["new_value"] = 123
+        >>> YAML.save("updated_config.yaml", data)
+        >>> YAML.print(data)
     """
-    if data is None:
-        data = {}
-    file = Path(file)
-    if not file.parent.exists():
-        # Create parent directories if they don't exist
+
+    _instance = None
+
+    @classmethod
+    def _get_instance(cls):
+        """Initialize singleton instance on first use."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def __init__(self):
+        """Initialize with optimal YAML implementation (C-based when available)."""
+        import yaml
+
+        self.yaml = yaml
+        # Use C-based implementation if available for better performance
+        try:
+            self.SafeLoader = yaml.CSafeLoader
+            self.SafeDumper = yaml.CSafeDumper
+        except (AttributeError, ImportError):
+            self.SafeLoader = yaml.SafeLoader
+            self.SafeDumper = yaml.SafeDumper
+
+    @classmethod
+    def save(cls, file="data.yaml", data=None, header=""):
+        """
+        Save Python object as YAML file.
+
+        Args:
+            file (str | Path): Path to save YAML file.
+            data (dict | None): Dict or compatible object to save.
+            header (str): Optional string to add at file beginning.
+        """
+        instance = cls._get_instance()
+        if data is None:
+            data = {}
+
+        # Create parent directories if needed
+        file = Path(file)
         file.parent.mkdir(parents=True, exist_ok=True)
 
-    # Convert Path objects to strings
-    valid_types = int, float, str, bool, list, tuple, dict, type(None)
-    for k, v in data.items():
-        if not isinstance(v, valid_types):
-            data[k] = str(v)
+        # Convert non-serializable objects to strings
+        valid_types = int, float, str, bool, list, tuple, dict, type(None)
+        for k, v in data.items():
+            if not isinstance(v, valid_types):
+                data[k] = str(v)
 
-    # Dump data to file in YAML format
-    with open(file, "w", errors="ignore", encoding="utf-8") as f:
-        if header:
-            f.write(header)
-        yaml.safe_dump(data, f, sort_keys=False, allow_unicode=True)
+        # Write YAML file
+        with open(file, "w", errors="ignore", encoding="utf-8") as f:
+            if header:
+                f.write(header)
+            instance.yaml.dump(data, f, sort_keys=False, allow_unicode=True, Dumper=instance.SafeDumper)
 
+    @classmethod
+    def load(cls, file="data.yaml", append_filename=False):
+        """
+        Load YAML file to Python object with robust error handling.
 
-def yaml_load(file="data.yaml", append_filename=False):
-    """
-    Load YAML data from a file.
+        Args:
+            file (str | Path): Path to YAML file.
+            append_filename (bool): Whether to add filename to returned dict.
 
-    Args:
-        file (str, optional): File name. Default is 'data.yaml'.
-        append_filename (bool): Add the YAML filename to the YAML dictionary. Default is False.
+        Returns:
+            (dict): Loaded YAML content.
+        """
+        instance = cls._get_instance()
+        assert str(file).endswith((".yaml", ".yml")), f"Not a YAML file: {file}"
 
-    Returns:
-        (dict): YAML data and file name.
-    """
-    assert Path(file).suffix in {".yaml", ".yml"}, f"Attempting to load non-YAML file {file} with yaml_load()"
-    with open(file, errors="ignore", encoding="utf-8") as f:
-        s = f.read()  # string
+        # Read file content
+        with open(file, errors="ignore", encoding="utf-8") as f:
+            s = f.read()
 
-        # Remove special characters
-        if not s.isprintable():
+        # Try loading YAML with fallback for problematic characters
+        try:
+            data = instance.yaml.load(s, Loader=instance.SafeLoader) or {}
+        except Exception:
+            # Remove problematic characters and retry
             s = re.sub(r"[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD\U00010000-\U0010ffff]+", "", s)
+            data = instance.yaml.load(s, Loader=instance.SafeLoader) or {}
+
+        # Check for accidental user-error None strings (should be 'null' in YAML)
+        if "None" in data.values():
+            data = {k: None if v == "None" else v for k, v in data.items()}
 
-        # Add YAML filename to dict and return
-        data = yaml.safe_load(s) or {}  # always return a dict (yaml.safe_load() may return None for empty files)
         if append_filename:
             data["yaml_file"] = str(file)
         return data
 
+    @classmethod
+    def print(cls, yaml_file):
+        """
+        Pretty print YAML file or object to console.
 
-def yaml_print(yaml_file: Union[str, Path, dict]) -> None:
-    """
-    Pretty prints a YAML file or a YAML-formatted dictionary.
+        Args:
+            yaml_file (str | Path | dict): Path to YAML file or dict to print.
+        """
+        instance = cls._get_instance()
 
-    Args:
-        yaml_file: The file path of the YAML file or a YAML-formatted dictionary.
+        # Load file if path provided
+        yaml_dict = cls.load(yaml_file) if isinstance(yaml_file, (str, Path)) else yaml_file
 
-    Returns:
-        (None)
-    """
-    yaml_dict = yaml_load(yaml_file) if isinstance(yaml_file, (str, Path)) else yaml_file
-    dump = yaml.dump(yaml_dict, sort_keys=False, allow_unicode=True, width=float("inf"))
-    LOGGER.info(f"Printing '{colorstr('bold', 'black', yaml_file)}'\n\n{dump}")
+        # Use -1 for unlimited width in C implementation
+        dump = instance.yaml.dump(yaml_dict, sort_keys=False, allow_unicode=True, width=-1, Dumper=instance.SafeDumper)
+
+        LOGGER.info(f"Printing '{colorstr('bold', 'black', yaml_file)}'\n\n{dump}")
 
 
 # Default configuration
-DEFAULT_CFG_DICT = yaml_load(DEFAULT_CFG_PATH)
-for k, v in DEFAULT_CFG_DICT.items():
-    if isinstance(v, str) and v.lower() == "none":
-        DEFAULT_CFG_DICT[k] = None
+DEFAULT_CFG_DICT = YAML.load(DEFAULT_CFG_PATH)
 DEFAULT_CFG_KEYS = DEFAULT_CFG_DICT.keys()
 DEFAULT_CFG = IterableSimpleNamespace(**DEFAULT_CFG_DICT)
 

ultralytics/utils/autodevice.py

@@ -0,0 +1,175 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+
+from ultralytics.utils import LOGGER
+from ultralytics.utils.checks import check_requirements
+
+
+class GPUInfo:
+    """
+    Manages NVIDIA GPU information via pynvml with robust error handling.
+
+    Provides methods to query detailed GPU statistics (utilization, memory, temp, power) and select the most idle
+    GPUs based on configurable criteria. It safely handles the absence or initialization failure of the pynvml
+    library by logging warnings and disabling related features, preventing application crashes.
+
+    Includes fallback logic using `torch.cuda` for basic device counting if NVML is unavailable during GPU
+    selection. Manages NVML initialization and shutdown internally.
+
+    Attributes:
+        pynvml (module | None): The `pynvml` module if successfully imported and initialized, otherwise `None`.
+        nvml_available (bool): Indicates if `pynvml` is ready for use. True if import and `nvmlInit()` succeeded,
+            False otherwise.
+        gpu_stats (list[dict]): A list of dictionaries, each holding stats for one GPU. Populated on initialization
+            and by `refresh_stats()`. Keys include: 'index', 'name', 'utilization' (%), 'memory_used' (MiB),
+            'memory_total' (MiB), 'memory_free' (MiB), 'temperature' (C), 'power_draw' (W),
+            'power_limit' (W or 'N/A'). Empty if NVML is unavailable or queries fail.
+    """
+
+    def __init__(self):
+        """Initializes GPUInfo, attempting to import and initialize pynvml."""
+        self.pynvml = None
+        self.nvml_available = False
+        self.gpu_stats = []
+
+        try:
+            check_requirements("pynvml>=12.0.0")
+            self.pynvml = __import__("pynvml")
+            self.pynvml.nvmlInit()
+            self.nvml_available = True
+            self.refresh_stats()
+        except Exception as e:
+            LOGGER.warning(f"Failed to initialize pynvml, GPU stats disabled: {e}")
+
+    def __del__(self):
+        """Ensures NVML is shut down when the object is garbage collected."""
+        self.shutdown()
+
+    def shutdown(self):
+        """Shuts down NVML if it was initialized."""
+        if self.nvml_available and self.pynvml:
+            try:
+                self.pynvml.nvmlShutdown()
+            except Exception:
+                pass
+            self.nvml_available = False
+
+    def refresh_stats(self):
+        """Refreshes the internal gpu_stats list by querying NVML."""
+        self.gpu_stats = []
+        if not self.nvml_available or not self.pynvml:
+            return
+
+        try:
+            device_count = self.pynvml.nvmlDeviceGetCount()
+            for i in range(device_count):
+                self.gpu_stats.append(self._get_device_stats(i))
+        except Exception as e:
+            LOGGER.warning(f"Error during device query: {e}")
+            self.gpu_stats = []
+
+    def _get_device_stats(self, index):
+        """Gets stats for a single GPU device."""
+        handle = self.pynvml.nvmlDeviceGetHandleByIndex(index)
+        memory = self.pynvml.nvmlDeviceGetMemoryInfo(handle)
+        util = self.pynvml.nvmlDeviceGetUtilizationRates(handle)
+
+        def safe_get(func, *args, default=-1, divisor=1):
+            try:
+                val = func(*args)
+                return val // divisor if divisor != 1 and isinstance(val, (int, float)) else val
+            except Exception:
+                return default
+
+        temp_type = getattr(self.pynvml, "NVML_TEMPERATURE_GPU", -1)
+
+        return {
+            "index": index,
+            "name": self.pynvml.nvmlDeviceGetName(handle),
+            "utilization": util.gpu if util else -1,
+            "memory_used": memory.used >> 20 if memory else -1,
+            "memory_total": memory.total >> 20 if memory else -1,
+            "memory_free": memory.free >> 20 if memory else -1,
+            "temperature": safe_get(self.pynvml.nvmlDeviceGetTemperature, handle, temp_type),
+            "power_draw": safe_get(self.pynvml.nvmlDeviceGetPowerUsage, handle, divisor=1000),
+            "power_limit": safe_get(self.pynvml.nvmlDeviceGetEnforcedPowerLimit, handle, divisor=1000),
+        }
+
+    def print_status(self):
+        """Prints GPU status in a compact table format using current stats."""
+        self.refresh_stats()
+        if not self.gpu_stats:
+            LOGGER.warning("No GPU stats available.")
+            return
+
+        stats = self.gpu_stats
+        name_len = max(len(gpu.get("name", "N/A")) for gpu in stats)
+        hdr = f"{'Idx':<3} {'Name':<{name_len}} {'Util':>6} {'Mem (MiB)':>15} {'Temp':>5} {'Pwr (W)':>10}"
+        LOGGER.info(f"\n--- GPU Status ---\n{hdr}\n{'-' * len(hdr)}")
+
+        for gpu in stats:
+            u = f"{gpu['utilization']:>5}%" if gpu["utilization"] >= 0 else " N/A "
+            m = f"{gpu['memory_used']:>6}/{gpu['memory_total']:<6}" if gpu["memory_used"] >= 0 else " N/A / N/A "
+            t = f"{gpu['temperature']}C" if gpu["temperature"] >= 0 else " N/A "
+            p = f"{gpu['power_draw']:>3}/{gpu['power_limit']:<3}" if gpu["power_draw"] >= 0 else " N/A "
+
+            LOGGER.info(f"{gpu.get('index'):<3d} {gpu.get('name', 'N/A'):<{name_len}} {u:>6} {m:>15} {t:>5} {p:>10}")
+
+        LOGGER.info(f"{'-' * len(hdr)}\n")
+
+    def select_idle_gpu(self, count=1, min_memory_mb=0):
+        """
+        Selects the 'count' most idle GPUs based on utilization and free memory.
+
+        Args:
+            count (int): The number of idle GPUs to select. Defaults to 1.
+            min_memory_mb (int): Minimum free memory required (MiB). Defaults to 0.
+
+        Returns:
+            (list[int]): Indices of the selected GPUs, sorted by idleness.
+
+        Notes:
+             Returns fewer than 'count' if not enough qualify or exist.
+             Returns basic CUDA indices if NVML fails. Empty list if no GPUs found.
+        """
+        LOGGER.info(f"Searching for {count} idle GPUs with >= {min_memory_mb} MiB free memory...")
+
+        if count <= 0:
+            return []
+
+        self.refresh_stats()
+        if not self.gpu_stats:
+            LOGGER.warning("NVML stats unavailable.")
+            return []
+
+        # Filter and sort eligible GPUs
+        eligible_gpus = [
+            gpu
+            for gpu in self.gpu_stats
+            if gpu.get("memory_free", -1) >= min_memory_mb and gpu.get("utilization", -1) != -1
+        ]
+        eligible_gpus.sort(key=lambda x: (x.get("utilization", 101), -x.get("memory_free", 0)))
+
+        # Select top 'count' indices
+        selected = [gpu["index"] for gpu in eligible_gpus[:count]]
+
+        if selected:
+            LOGGER.info(f"Selected idle CUDA devices {selected}")
+        else:
+            LOGGER.warning(f"No GPUs met criteria (Util != -1, Free Mem >= {min_memory_mb} MiB).")
+
+        return selected
+
+
+if __name__ == "__main__":
+    required_free_mem = 2048  # Require 2GB free VRAM
+    num_gpus_to_select = 1
+
+    gpu_info = GPUInfo()
+    gpu_info.print_status()
+
+    selected = gpu_info.select_idle_gpu(count=num_gpus_to_select, min_memory_mb=required_free_mem)
+    if selected:
+        print(f"\n==> Using selected GPU indices: {selected}")
+        devices = [f"cuda:{idx}" for idx in selected]
+        print(f"    Target devices: {devices}")

ultralytics/utils/benchmarks.py

@@ -36,12 +36,11 @@ from pathlib import Path
 
 import numpy as np
 import torch.cuda
-import yaml
 
 from ultralytics import YOLO, YOLOWorld
 from ultralytics.cfg import TASK2DATA, TASK2METRIC
 from ultralytics.engine.exporter import export_formats
-from ultralytics.utils import ARM64, ASSETS, LINUX, LOGGER, MACOS, TQDM, WEIGHTS_DIR
+from ultralytics.utils import ARM64, ASSETS, LINUX, LOGGER, MACOS, TQDM, WEIGHTS_DIR, YAML
 from ultralytics.utils.checks import IS_PYTHON_3_13, check_imgsz, check_requirements, check_yolo, is_rockchip
 from ultralytics.utils.downloads import safe_download
 from ultralytics.utils.files import file_size
@@ -283,12 +282,10 @@ class RF100Benchmark:
     @staticmethod
     def fix_yaml(path):
         """Fix the train and validation paths in a given YAML file."""
-        with open(path, encoding="utf-8") as file:
-            yaml_data = yaml.safe_load(file)
+        yaml_data = YAML.load(path)
         yaml_data["train"] = "train/images"
         yaml_data["val"] = "valid/images"
-        with open(path, "w", encoding="utf-8") as file:
-            yaml.safe_dump(yaml_data, file)
+        YAML.dump(yaml_data, path)
 
     def evaluate(self, yaml_path, val_log_file, eval_log_file, list_ind):
         """
@@ -309,8 +306,7 @@ class RF100Benchmark:
             >>> benchmark.evaluate("path/to/data.yaml", "path/to/val_log.txt", "path/to/eval_log.txt", 0)
         """
         skip_symbols = ["🚀", "⚠️", "💡", "❌"]
-        with open(yaml_path, encoding="utf-8") as stream:
-            class_names = yaml.safe_load(stream)["names"]
+        class_names = YAML.load(yaml_path)["names"]
         with open(val_log_file, encoding="utf-8") as f:
             lines = f.readlines()
             eval_lines = []
@@ -403,7 +399,7 @@ class ProfileModels:
             imgsz (int): Size of the image used during profiling.
             half (bool): Flag to indicate whether to use FP16 half-precision for TensorRT profiling.
             trt (bool): Flag to indicate whether to profile using TensorRT.
-            device (torch.device | None): Device used for profiling. If None, it is determined automatically.
+            device (torch.device | str | None): Device used for profiling. If None, it is determined automatically.
 
         Notes:
             FP16 'half' argument option removed for ONNX as slower on CPU than FP32.
@@ -421,7 +417,7 @@ class ProfileModels:
         self.imgsz = imgsz
         self.half = half
         self.trt = trt  # run TensorRT profiling
-        self.device = device or torch.device(0 if torch.cuda.is_available() else "cpu")
+        self.device = device if isinstance(device, torch.device) else select_device(device)
 
     def run(self):
         """

ultralytics/utils/checks.py

@@ -305,7 +305,7 @@ def check_font(font="Arial.ttf"):
     Returns:
         (Path): Resolved font file path.
     """
-    from matplotlib import font_manager
+    from matplotlib import font_manager  # scope for faster 'import ultralytics'
 
     # Check USER_CONFIG_DIR
     name = Path(font).name
@@ -454,7 +454,7 @@ def check_suffix(file="yolo11n.pt", suffix=".pt", msg=""):
     """
     if file and suffix:
         if isinstance(suffix, str):
-            suffix = (suffix,)
+            suffix = {suffix}
         for f in file if isinstance(file, (list, tuple)) else [file]:
             s = Path(f).suffix.lower().strip()  # file suffix
             if len(s):
@@ -608,7 +608,7 @@ def check_yolo(verbose=True, device=""):
 
     Args:
         verbose (bool): Whether to print verbose information.
-        device (str): Device to use for YOLO.
+        device (str | torch.device): Device to use for YOLO.
     """
     import psutil
 
@@ -810,7 +810,7 @@ def print_args(args: Optional[dict] = None, show_file=True, show_func=False):
     except ValueError:
         file = Path(file).stem
     s = (f"{file}: " if show_file else "") + (f"{func}: " if show_func else "")
-    LOGGER.info(colorstr(s) + ", ".join(f"{k}={strip_auth(v)}" for k, v in args.items()))
+    LOGGER.info(colorstr(s) + ", ".join(f"{k}={strip_auth(v)}" for k, v in sorted(args.items())))
 
 
 def cuda_device_count() -> int:

ultralytics/utils/metrics.py

@@ -5,7 +5,6 @@ import math
 import warnings
 from pathlib import Path
 
-import matplotlib.pyplot as plt
 import numpy as np
 import torch
 
@@ -418,7 +417,8 @@ class ConfusionMatrix:
             names (tuple): Names of classes, used as labels on the plot.
             on_plot (func): An optional callback to pass plots path and data when they are rendered.
         """
-        import seaborn  # scope for faster 'import ultralytics'
+        import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+        import seaborn
 
         array = self.matrix / ((self.matrix.sum(0).reshape(1, -1) + 1e-9) if normalize else 1)  # normalize columns
         array[array < 0.005] = np.nan  # don't annotate (would appear as 0.00)
@@ -479,6 +479,8 @@ def plot_pr_curve(px, py, ap, save_dir=Path("pr_curve.png"), names={}, on_plot=N
         names (dict, optional): Dictionary mapping class indices to class names.
         on_plot (callable, optional): Function to call after plot is saved.
     """
+    import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+
     fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
     py = np.stack(py, axis=1)
 
@@ -515,6 +517,8 @@ def plot_mc_curve(px, py, save_dir=Path("mc_curve.png"), names={}, xlabel="Confi
         ylabel (str, optional): Y-axis label.
         on_plot (callable, optional): Function to call after plot is saved.
     """
+    import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+
     fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
 
     if 0 < len(names) < 21:  # display per-class legend if < 21 classes

ultralytics/utils/plotting.py

@@ -6,7 +6,6 @@ from pathlib import Path
 from typing import Callable, Dict, List, Optional, Union
 
 import cv2
-import matplotlib.pyplot as plt
 import numpy as np
 import torch
 from PIL import Image, ImageDraw, ImageFont
@@ -534,8 +533,9 @@ def plot_labels(boxes, cls, names=(), save_dir=Path(""), on_plot=None):
         save_dir (Path, optional): Directory to save the plot.
         on_plot (Callable, optional): Function to call after plot is saved.
     """
-    import pandas  # scope for faster 'import ultralytics'
-    import seaborn  # scope for faster 'import ultralytics'
+    import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+    import pandas
+    import seaborn
 
     # Filter matplotlib>=3.7.2 warning and Seaborn use_inf and is_categorical FutureWarnings
     warnings.filterwarnings("ignore", category=UserWarning, message="The figure layout has changed to tight")
@@ -819,7 +819,8 @@ def plot_results(file="path/to/results.csv", dir="", segment=False, pose=False,
         >>> from ultralytics.utils.plotting import plot_results
         >>> plot_results("path/to/results.csv", segment=True)
     """
-    import pandas as pd  # scope for faster 'import ultralytics'
+    import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+    import pandas as pd
     from scipy.ndimage import gaussian_filter1d
 
     save_dir = Path(file).parent if file else Path(dir)
@@ -878,6 +879,8 @@ def plt_color_scatter(v, f, bins=20, cmap="viridis", alpha=0.8, edgecolors="none
         >>> f = np.random.rand(100)
         >>> plt_color_scatter(v, f)
     """
+    import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+
     # Calculate 2D histogram and corresponding colors
     hist, xedges, yedges = np.histogram2d(v, f, bins=bins)
     colors = [
@@ -903,7 +906,8 @@ def plot_tune_results(csv_file="tune_results.csv"):
     Examples:
         >>> plot_tune_results("path/to/tune_results.csv")
     """
-    import pandas as pd  # scope for faster 'import ultralytics'
+    import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+    import pandas as pd
     from scipy.ndimage import gaussian_filter1d
 
     def _save_one_file(file):
@@ -980,6 +984,8 @@ def feature_visualization(x, module_type, stage, n=32, save_dir=Path("runs/detec
         n (int, optional): Maximum number of feature maps to plot.
         save_dir (Path, optional): Directory to save results.
     """
+    import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'
+
     for m in {"Detect", "Segment", "Pose", "Classify", "OBB", "RTDETRDecoder"}:  # all model heads
         if m in module_type:
             return