ultralytics 8.3.123__py3-none-any.whl → 8.3.125__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,7 +48,11 @@ class Analytics(BaseSolution):
         """Initialize Analytics class with various chart types for visual data representation."""
         super().__init__(**kwargs)
 
-        self.type = self.CFG["analytics_type"]  # extract type of analytics
+        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"
 
@@ -61,7 +62,7 @@ class Analytics(BaseSolution):
         self.title = "Ultralytics Solutions"  # window name
         self.max_points = 45  # maximum points to be drawn on window
         self.fontsize = 25  # text font size for display
-        figsize = (12.8, 7.2)  # Set output image size 1280 * 720
+        figsize = self.CFG["figsize"]  # set output image size i.e (12.8, 7.2) -> w = 1280, h = 720
         self.color_cycle = cycle(["#DD00BA", "#042AFF", "#FF4447", "#7D24FF", "#BD00FF"])
 
         self.total_counts = 0  # count variable for storing total counts i.e. for line
@@ -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/solutions/config.py

@@ -0,0 +1,104 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+
+import cv2
+
+
+@dataclass
+class SolutionConfig:
+    """
+    Manages configuration parameters for Ultralytics Vision AI solutions.
+
+    The SolutionConfig class serves as a centralized configuration container for all the
+    Ultralytics solution modules: https://docs.ultralytics.com/solutions/#solutions.
+    It leverages Python `dataclass` for clear, type-safe, and maintainable parameter definitions.
+
+    Attributes:
+        source (Optional[str]): Path to the input source (video, RTSP, etc.). Only usable with Solutions CLI.
+        model (Optional[str]): Path to the Ultralytics YOLO model to be used for inference.
+        classes (Optional[List[int]]): List of class indices to filter detections.
+        show_conf (bool): Whether to show confidence scores on the visual output.
+        show_labels (bool): Whether to display class labels on visual output.
+        region (Optional[List[Tuple[int, int]]]): Polygonal region or line for object counting.
+        colormap (Optional[int]): OpenCV colormap constant for visual overlays (e.g., cv2.COLORMAP_JET).
+        show_in (bool): Whether to display count number for objects entering the region.
+        show_out (bool): Whether to display count number for objects leaving the region.
+        up_angle (float): Upper angle threshold used in pose-based workouts monitoring.
+        down_angle (int): Lower angle threshold used in pose-based workouts monitoring.
+        kpts (List[int]): Keypoint indices to monitor, e.g., for pose analytics.
+        analytics_type (str): Type of analytics to perform ("line", "area", "bar", "pie", etc.).
+        figsize (Optional[Tuple[int, int]]): Size of the matplotlib figure used for analytical plots (width, height).
+        blur_ratio (float): Ratio used to blur objects in the video frames (0.0 to 1.0).
+        vision_point (Tuple[int, int]): Reference point for directional tracking or perspective drawing.
+        crop_dir (str): Directory path to save cropped detection images.
+        json_file (str): Path to a JSON file containing data for parking areas.
+        line_width (int): Width for visual display i.e. bounding boxes, keypoints, counts.
+        records (int): Number of detection records to send email alerts.
+        fps (float): Frame rate (Frames Per Second) for speed estimation calculation.
+        max_hist (int): Maximum number of historical points or states stored per tracked object for speed estimation.
+        meter_per_pixel (float): Scale for real-world measurement, used in speed or distance calculations.
+        max_speed (int): Maximum speed limit (e.g., km/h or mph) used in visual alerts or constraints.
+        show (bool): Whether to display the visual output on screen.
+        iou (float): Intersection-over-Union threshold for detection filtering.
+        conf (float): Confidence threshold for keeping predictions.
+        device (Optional[str]): Device to run inference on (e.g., 'cpu', '0' for CUDA GPU).
+        max_det (int): Maximum number of detections allowed per video frame.
+        half (bool): Whether to use FP16 precision (requires a supported CUDA device).
+        tracker (str): Path to tracking configuration YAML file (e.g., 'botsort.yaml').
+        verbose (bool): Enable verbose logging output for debugging or diagnostics.
+
+    Methods:
+        update: Update the configuration with user-defined keyword arguments and raise error on invalid keys.
+
+    Examples:
+        >>> from ultralytics.solutions.config import SolutionConfig
+        >>> cfg = SolutionConfig(model="yolo11n.pt", region=[(0, 0), (100, 0), (100, 100), (0, 100)])
+        >>> cfg.update(show=False, conf=0.3)
+        >>> print(cfg.model)
+    """
+
+    source: Optional[str] = None
+    model: Optional[str] = None
+    classes: Optional[List[int]] = None
+    show_conf: bool = True
+    show_labels: bool = True
+    region: Optional[List[Tuple[int, int]]] = None
+    colormap: Optional[int] = cv2.COLORMAP_DEEPGREEN
+    show_in: bool = True
+    show_out: bool = True
+    up_angle: float = 145.0
+    down_angle: int = 90
+    kpts: List[int] = field(default_factory=lambda: [6, 8, 10])
+    analytics_type: str = "line"
+    figsize: Optional[Tuple[int, int]] = (12.8, 7.2)
+    blur_ratio: float = 0.5
+    vision_point: Tuple[int, int] = (20, 20)
+    crop_dir: str = "cropped-detections"
+    json_file: str = None
+    line_width: int = 2
+    records: int = 5
+    fps: float = 30.0
+    max_hist: int = 5
+    meter_per_pixel: float = 0.05
+    max_speed: int = 120
+    show: bool = False
+    iou: float = 0.7
+    conf: float = 0.25
+    device: Optional[str] = None
+    max_det: int = 300
+    half: bool = False
+    tracker: str = "botsort.yaml"
+    verbose: bool = True
+
+    def update(self, **kwargs):
+        """Update configuration parameters with new values provided as keyword arguments."""
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+            else:
+                raise ValueError(
+                    f"❌ {key} is not a valid solution argument, available arguments here: https://docs.ultralytics.com/solutions/#solutions-arguments"
+                )
+        return self

ultralytics/solutions/heatmap.py

@@ -45,7 +45,7 @@ class Heatmap(ObjectCounter):
             self.initialize_region()
 
         # Store colormap
-        self.colormap = cv2.COLORMAP_PARULA if self.CFG["colormap"] is None else self.CFG["colormap"]
+        self.colormap = self.CFG["colormap"]
         self.heatmap = None
 
     def heatmap_effect(self, box):

ultralytics/solutions/object_blurrer.py

@@ -41,7 +41,7 @@ class ObjectBlurrer(BaseSolution):
                 blur_ratio (float): Intensity of the blur effect (0.1-1.0, default=0.5).
         """
         super().__init__(**kwargs)
-        blur_ratio = kwargs.get("blur_ratio", 0.5)
+        blur_ratio = self.CFG["blur_ratio"]
         if blur_ratio < 0.1:
             LOGGER.warning("blur ratio cannot be less than 0.1, updating it to default value 0.5")
             blur_ratio = 0.5

ultralytics/solutions/object_cropper.py

@@ -40,7 +40,7 @@ class ObjectCropper(BaseSolution):
         """
         super().__init__(**kwargs)
 
-        self.crop_dir = kwargs.get("crop_dir", "cropped-detections")  # Directory for storing cropped detections
+        self.crop_dir = self.CFG["crop_dir"]  # Directory for storing cropped detections
         if not os.path.exists(self.crop_dir):
             os.mkdir(self.crop_dir)  # Create directory if it does not exist
         if self.CFG["show"]:
@@ -49,7 +49,7 @@ class ObjectCropper(BaseSolution):
             )
         self.crop_idx = 0  # Initialize counter for total cropped objects
         self.iou = self.CFG["iou"]
-        self.conf = self.CFG["conf"] if self.CFG["conf"] is not None else 0.25
+        self.conf = self.CFG["conf"]
 
     def process(self, im0):
         """

ultralytics/solutions/parking_management.py

@@ -201,9 +201,9 @@ class ParkingManagement(BaseSolution):
         """Initialize the parking management system with a YOLO model and visualization settings."""
         super().__init__(**kwargs)
 
-        self.json_file = self.CFG["json_file"]  # Load JSON data
+        self.json_file = self.CFG["json_file"]  # Load parking regions JSON data
         if self.json_file is None:
-            LOGGER.warning("❌ json_file argument missing. Parking region details required.")
+            LOGGER.warning("json_file argument missing. Parking region details required.")
             raise ValueError("❌ Json file path can not be empty")
 
         with open(self.json_file) as f:

ultralytics/solutions/security_alarm.py

@@ -143,7 +143,7 @@ class SecurityAlarm(BaseSolution):
             annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
 
         total_det = len(self.clss)
-        if total_det > self.records and not self.email_sent:  # Only send email if not sent before
+        if total_det >= self.records and not self.email_sent:  # Only send email if not sent before
             self.send_email(im0, total_det)
             self.email_sent = True
 

ultralytics/solutions/solutions.py

@@ -7,7 +7,8 @@ import cv2
 import numpy as np
 
 from ultralytics import YOLO
-from ultralytics.utils import ASSETS_URL, DEFAULT_CFG_DICT, DEFAULT_SOL_DICT, LOGGER
+from ultralytics.solutions.config import SolutionConfig
+from ultralytics.utils import ASSETS_URL, LOGGER
 from ultralytics.utils.checks import check_imshow, check_requirements
 from ultralytics.utils.plotting import Annotator
 
@@ -72,15 +73,11 @@ class BaseSolution:
         self.r_s = None
 
         self.LOGGER = LOGGER  # Store logger object to be used in multiple solution classes
-
-        # Load config and update with args
-        DEFAULT_SOL_DICT.update(kwargs)
-        DEFAULT_CFG_DICT.update(kwargs)
-        self.CFG = {**DEFAULT_SOL_DICT, **DEFAULT_CFG_DICT}
-        self.LOGGER.info(f"Ultralytics Solutions: ✅ {DEFAULT_SOL_DICT}")
+        self.CFG = vars(SolutionConfig().update(**kwargs))
+        self.LOGGER.info(f"Ultralytics Solutions: ✅ {self.CFG}")
 
         self.region = self.CFG["region"]  # Store region data for other classes usage
-        self.line_width = self.CFG["line_width"] if self.CFG["line_width"] not in (None, 0) else 2  # Store line_width
+        self.line_width = self.CFG["line_width"]
 
         # Load Model and store additional information (classes, show_conf, show_label)
         if self.CFG["model"] is None:
@@ -178,7 +175,7 @@ class BaseSolution:
     def initialize_region(self):
         """Initialize the counting region and line segment based on configuration settings."""
         if self.region is None:
-            self.region = [(20, 400), (1080, 400), (1080, 360), (20, 360)]
+            self.region = [(10, 200), (540, 200), (540, 180), (10, 180)]
         self.r_s = (
             self.Polygon(self.region) if len(self.region) >= 3 else self.LineString(self.region)
         )  # region or line

ultralytics/solutions/speed_estimation.py

@@ -44,15 +44,15 @@ class SpeedEstimator(BaseSolution):
         """
         super().__init__(**kwargs)
 
-        self.fps = kwargs.get("fps", 30)  # assumed video FPS
+        self.fps = self.CFG["fps"]  # assumed video FPS
         self.frame_count = 0  # global frame count
         self.trk_frame_ids = {}  # Track ID → first frame index
         self.spd = {}  # Final speed per object (km/h), once locked
         self.trk_hist = {}  # Track ID → deque of (time, position)
         self.locked_ids = set()  # Track IDs whose speed has been finalized
-        self.max_hist = kwargs.get("max_hist", 5)  # Required frame history before computing speed
-        self.meter_per_pixel = kwargs.get("meter_per_pixel", 0.05)  # Scene scale, depends on camera details
-        self.max_speed = kwargs.get("max_speed", 120)  # max_speed adjustment
+        self.max_hist = self.CFG["max_hist"]  # Required frame history before computing speed
+        self.meter_per_pixel = self.CFG["meter_per_pixel"]  # Scene scale, depends on camera details
+        self.max_speed = self.CFG["max_speed"]  # max_speed adjustment
 
     def process(self, im0):
         """

ultralytics/solutions/trackzone.py

@@ -42,7 +42,7 @@ class TrackZone(BaseSolution):
             **kwargs (Any): Additional keyword arguments passed to the parent class.
         """
         super().__init__(**kwargs)
-        default_region = [(150, 150), (1130, 150), (1130, 570), (150, 570)]
+        default_region = [(75, 75), (565, 75), (565, 285), (75, 285)]
         self.region = cv2.convexHull(np.array(self.region or default_region, dtype=np.int32))
 
     def process(self, im0):

ultralytics/solutions/vision_eye.py

@@ -34,7 +34,7 @@ class VisionEye(BaseSolution):
         """
         super().__init__(**kwargs)
         # Set the vision point where the system will view objects and draw tracks
-        self.vision_point = kwargs.get("vision_point", (30, 30))
+        self.vision_point = self.CFG["vision_point"]
 
     def process(self, im0):
         """

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

@@ -12,7 +12,6 @@ import subprocess
 import sys
 import threading
 import time
-import uuid
 import warnings
 from pathlib import Path
 from threading import Lock
@@ -21,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
@@ -41,7 +38,6 @@ ROOT = FILE.parents[1]  # YOLO
 ASSETS = ROOT / "assets"  # default images
 ASSETS_URL = "https://github.com/ultralytics/assets/releases/download/v0.0.0"  # assets GitHub URL
 DEFAULT_CFG_PATH = ROOT / "cfg/default.yaml"
-DEFAULT_SOL_CFG_PATH = ROOT / "cfg/solutions/default.yaml"  # Ultralytics solutions yaml path
 NUM_THREADS = min(8, max(1, os.cpu_count() - 1))  # number of YOLO multiprocessing threads
 AUTOINSTALL = str(os.getenv("YOLO_AUTOINSTALL", True)).lower() == "true"  # global auto-install mode
 VERBOSE = str(os.getenv("YOLO_VERBOSE", True)).lower() == "true"  # global verbose mode
@@ -332,6 +328,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:
@@ -470,85 +468,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)
-DEFAULT_SOL_DICT = yaml_load(DEFAULT_SOL_CFG_PATH)  # Ultralytics solutions configuration
-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)
 
@@ -1226,6 +1281,7 @@ class SettingsManager(JSONDict):
     def __init__(self, file=SETTINGS_FILE, version="0.0.6"):
         """Initializes the SettingsManager with default settings and loads user settings."""
         import hashlib
+        import uuid
 
         from ultralytics.utils.torch_utils import torch_distributed_zero_first
 

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 = []

ultralytics/utils/checks.py

@@ -16,7 +16,6 @@ from typing import Optional
 
 import cv2
 import numpy as np
-import requests
 import torch
 
 from ultralytics.utils import (
@@ -261,6 +260,8 @@ def check_latest_pypi_version(package_name="ultralytics"):
     Returns:
         (str): The latest version of the package.
     """
+    import requests  # slow import
+
     try:
         requests.packages.urllib3.disable_warnings()  # Disable the InsecureRequestWarning
         response = requests.get(f"https://pypi.org/pypi/{package_name}/json", timeout=3)
@@ -304,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
@@ -453,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):