ultralytics 8.2.101__tar.gz → 8.2.103__tar.gz

{ultralytics-8.2.101/ultralytics.egg-info → ultralytics-8.2.103}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.101
+Version: 8.2.103
 Summary: Ultralytics YOLO for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Ayush Chaurasia
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>

{ultralytics-8.2.101 → ultralytics-8.2.103}/ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-__version__ = "8.2.101"
+__version__ = "8.2.103"
 
 
 import os

ultralytics-8.2.103/ultralytics/cfg/datasets/hand-keypoints.yaml

@@ -0,0 +1,25 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Hand Keypoints dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/pose/hand-keypoints/
+# Example usage: yolo train data=hand-keypoints.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── hand-keypoints  ← downloads here (369 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/hand-keypoints # dataset root dir
+train: train # train images (relative to 'path') 210 images
+val: val # val images (relative to 'path') 53 images
+
+# Keypoints
+kpt_shape: [21, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx:
+  [0, 1, 2, 4, 3, 10, 11, 12, 13, 14, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 20]
+
+# Classes
+names:
+  0: hand
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/hand-keypoints.zip

{ultralytics-8.2.101 → ultralytics-8.2.103}/ultralytics/models/sam/modules/sam.py

@@ -645,9 +645,7 @@ class SAM2Model(torch.nn.Module):
         # The case of `self.num_maskmem == 0` below is primarily used for reproducing SAM on images.
         # In this case, we skip the fusion with any memory.
         if self.num_maskmem == 0:  # Disable memory and skip fusion
-            pix_feat = current_vision_feats[-1].permute(1, 2, 0).view(B, C, H, W)
-            return pix_feat
-
+            return current_vision_feats[-1].permute(1, 2, 0).view(B, C, H, W)
         num_obj_ptr_tokens = 0
         # Step 1: condition the visual features of the current frame on previous memories
         if not is_init_cond_frame:

{ultralytics-8.2.101 → ultralytics-8.2.103}/ultralytics/solutions/object_counter.py

@@ -176,22 +176,24 @@ class ObjectCounter:
 
                 # Count objects using line
                 elif len(self.reg_pts) == 2:
-                    if prev_position is not None and track_id not in self.count_ids:
-                        # Check if the object's movement segment intersects the counting line
-                        if LineString([(prev_position[0], prev_position[1]), (box[0], box[1])]).intersects(
+                    if (
+                        prev_position is not None
+                        and track_id not in self.count_ids
+                        and LineString([(prev_position[0], prev_position[1]), (box[0], box[1])]).intersects(
                             self.counting_line_segment
-                        ):
-                            self.count_ids.append(track_id)
-
-                            # Determine the direction of movement (IN or OUT)
-                            dx = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0])
-                            dy = (box[1] - prev_position[1]) * (self.counting_region.centroid.y - prev_position[1])
-                            if dx > 0 and dy > 0:
-                                self.in_counts += 1
-                                self.class_wise_count[self.names[cls]]["IN"] += 1
-                            else:
-                                self.out_counts += 1
-                                self.class_wise_count[self.names[cls]]["OUT"] += 1
+                        )
+                    ):
+                        self.count_ids.append(track_id)
+
+                        # Determine the direction of movement (IN or OUT)
+                        dx = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0])
+                        dy = (box[1] - prev_position[1]) * (self.counting_region.centroid.y - prev_position[1])
+                        if dx > 0 and dy > 0:
+                            self.in_counts += 1
+                            self.class_wise_count[self.names[cls]]["IN"] += 1
+                        else:
+                            self.out_counts += 1
+                            self.class_wise_count[self.names[cls]]["OUT"] += 1
 
         labels_dict = {}
 

{ultralytics-8.2.101 → ultralytics-8.2.103}/ultralytics/solutions/parking_management.py

@@ -128,14 +128,13 @@ class ParkingPtsSelection:
 
         rg_data = []  # regions data
         for box in self.rg_data:
-            rs_box = []  # rescaled box list
-            for x, y in box:
-                rs_box.append(
-                    (
-                        int(x * self.imgw / self.canvas.winfo_width()),  # width scaling
-                        int(y * self.imgh / self.canvas.winfo_height()),
-                    )
-                )  # height scaling
+            rs_box = [
+                (
+                    int(x * self.imgw / self.canvas.winfo_width()),  # width scaling
+                    int(y * self.imgh / self.canvas.winfo_height()),  # height scaling
+                )
+                for x, y in box
+            ]
             rg_data.append({"points": rs_box})
         with open("bounding_boxes.json", "w") as f:
             json.dump(rg_data, f, indent=4)

{ultralytics-8.2.101 → ultralytics-8.2.103}/ultralytics/utils/__init__.py

@@ -111,7 +111,6 @@ torch.set_printoptions(linewidth=320, precision=4, profile="default")
 np.set_printoptions(linewidth=320, formatter={"float_kind": "{:11.5g}".format})  # format short g, %precision=5
 cv2.setNumThreads(0)  # prevent OpenCV from multithreading (incompatible with PyTorch DataLoader)
 os.environ["NUMEXPR_MAX_THREADS"] = str(NUM_THREADS)  # NumExpr max threads
-os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"  # for deterministic training
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"  # suppress verbose TF compiler warnings in Colab
 os.environ["TORCH_CPP_LOG_LEVEL"] = "ERROR"  # suppress "NNPACK.cpp could not initialize NNPACK" warnings
 os.environ["KINETO_LOG_LEVEL"] = "5"  # suppress verbose PyTorch profiler output when computing FLOPs
@@ -1092,10 +1091,17 @@ class JSONDict(dict):
         try:
             self.file_path.parent.mkdir(parents=True, exist_ok=True)
             with open(self.file_path, "w") as f:
-                json.dump(dict(self), f, indent=2)
+                json.dump(dict(self), f, indent=2, default=self._json_default)
         except Exception as e:
             print(f"Error writing to {self.file_path}: {e}")
 
+    @staticmethod
+    def _json_default(obj):
+        """Handle JSON serialization of Path objects."""
+        if isinstance(obj, Path):
+            return str(obj)
+        raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
+
     def __setitem__(self, key, value):
         """Store a key-value pair and persist to disk."""
         with self.lock:
@@ -1110,7 +1116,7 @@ class JSONDict(dict):
 
     def __str__(self):
         """Return a pretty-printed JSON string representation of the dictionary."""
-        return f'JSONDict("{self.file_path}"):\n{json.dumps(dict(self), indent=2, ensure_ascii=False)}'
+        return f'JSONDict("{self.file_path}"):\n{json.dumps(dict(self), indent=2, ensure_ascii=False, default=self._json_default)}'
 
     def update(self, *args, **kwargs):
         """Update the dictionary and persist changes."""

{ultralytics-8.2.101 → ultralytics-8.2.103}/ultralytics/utils/benchmarks.py

@@ -43,36 +43,40 @@ from ultralytics.utils import ARM64, ASSETS, IS_JETSON, IS_RASPBERRYPI, LINUX, L
 from ultralytics.utils.checks import IS_PYTHON_3_12, check_requirements, check_yolo
 from ultralytics.utils.downloads import safe_download
 from ultralytics.utils.files import file_size
-from ultralytics.utils.torch_utils import select_device
+from ultralytics.utils.torch_utils import get_cpu_info, select_device
 
 
 def benchmark(
-    model=WEIGHTS_DIR / "yolov8n.pt", data=None, imgsz=160, half=False, int8=False, device="cpu", verbose=False
+    model=WEIGHTS_DIR / "yolov8n.pt",
+    data=None,
+    imgsz=160,
+    half=False,
+    int8=False,
+    device="cpu",
+    verbose=False,
+    eps=1e-3,
 ):
     """
     Benchmark a YOLO model across different formats for speed and accuracy.
 
     Args:
-        model (str | Path | optional): Path to the model file or directory. Default is
-            Path(SETTINGS['weights_dir']) / 'yolov8n.pt'.
-        data (str, optional): Dataset to evaluate on, inherited from TASK2DATA if not passed. Default is None.
-        imgsz (int, optional): Image size for the benchmark. Default is 160.
-        half (bool, optional): Use half-precision for the model if True. Default is False.
-        int8 (bool, optional): Use int8-precision for the model if True. Default is False.
-        device (str, optional): Device to run the benchmark on, either 'cpu' or 'cuda'. Default is 'cpu'.
-        verbose (bool | float | optional): If True or a float, assert benchmarks pass with given metric.
-            Default is False.
+        model (str | Path): Path to the model file or directory.
+        data (str | None): Dataset to evaluate on, inherited from TASK2DATA if not passed.
+        imgsz (int): Image size for the benchmark.
+        half (bool): Use half-precision for the model if True.
+        int8 (bool): Use int8-precision for the model if True.
+        device (str): Device to run the benchmark on, either 'cpu' or 'cuda'.
+        verbose (bool | float): If True or a float, assert benchmarks pass with given metric.
+        eps (float): Epsilon value for divide by zero prevention.
 
     Returns:
-        df (pandas.DataFrame): A pandas DataFrame with benchmark results for each format, including file size,
-            metric, and inference time.
+        (pandas.DataFrame): A pandas DataFrame with benchmark results for each format, including file size, metric,
+            and inference time.
 
-    Example:
-        ```python
-        from ultralytics.utils.benchmarks import benchmark
-
-        benchmark(model="yolov8n.pt", imgsz=640)
-        ```
+    Examples:
+        Benchmark a YOLO model with default settings:
+        >>> from ultralytics.utils.benchmarks import benchmark
+        >>> benchmark(model="yolov8n.pt", imgsz=640)
     """
     import pandas as pd  # scope for faster 'import ultralytics'
 
@@ -106,6 +110,7 @@ def benchmark(
             if i in {11}:  # Paddle
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 Paddle exports not supported yet"
                 assert not is_end2end, "End-to-end models not supported by PaddlePaddle yet"
+                assert LINUX or MACOS, "Windows Paddle exports not supported yet"
             if i in {12}:  # NCNN
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 NCNN exports not supported yet"
             if "cpu" in device.type:
@@ -138,7 +143,7 @@ def benchmark(
                 data=data, batch=1, imgsz=imgsz, plots=False, device=device, half=half, int8=int8, verbose=False
             )
             metric, speed = results.results_dict[key], results.speed["inference"]
-            fps = round((1000 / speed), 2)  # frames per second
+            fps = round(1000 / (speed + eps), 2)  # frames per second
             y.append([name, "✅", round(file_size(filename), 1), round(metric, 4), round(speed, 2), fps])
         except Exception as e:
             if verbose:
@@ -165,10 +170,10 @@ def benchmark(
 
 
 class RF100Benchmark:
-    """Benchmark YOLO model performance across formats for speed and accuracy."""
+    """Benchmark YOLO model performance across various formats for speed and accuracy."""
 
     def __init__(self):
-        """Function for initialization of RF100Benchmark."""
+        """Initialize the RF100Benchmark class for benchmarking YOLO model performance across various formats."""
         self.ds_names = []
         self.ds_cfg_list = []
         self.rf = None
@@ -180,6 +185,11 @@ class RF100Benchmark:
 
         Args:
             api_key (str): The API key.
+
+        Examples:
+            Set the Roboflow API key for accessing datasets:
+            >>> benchmark = RF100Benchmark()
+            >>> benchmark.set_key("your_roboflow_api_key")
         """
         check_requirements("roboflow")
         from roboflow import Roboflow
@@ -188,10 +198,15 @@ class RF100Benchmark:
 
     def parse_dataset(self, ds_link_txt="datasets_links.txt"):
         """
-        Parse dataset links and downloads datasets.
+        Parse dataset links and download datasets.
 
         Args:
-            ds_link_txt (str): Path to dataset_links file.
+            ds_link_txt (str): Path to the file containing dataset links.
+
+        Examples:
+            >>> benchmark = RF100Benchmark()
+            >>> benchmark.set_key("api_key")
+            >>> benchmark.parse_dataset("datasets_links.txt")
         """
         (shutil.rmtree("rf-100"), os.mkdir("rf-100")) if os.path.exists("rf-100") else os.mkdir("rf-100")
         os.chdir("rf-100")
@@ -217,10 +232,13 @@ class RF100Benchmark:
     @staticmethod
     def fix_yaml(path):
         """
-        Function to fix YAML train and val path.
+        Fixes the train and validation paths in a given YAML file.
 
         Args:
-            path (str): YAML file path.
+            path (str): Path to the YAML file to be fixed.
+
+        Examples:
+            >>> RF100Benchmark.fix_yaml("path/to/data.yaml")
         """
         with open(path) as file:
             yaml_data = yaml.safe_load(file)
@@ -231,13 +249,21 @@ class RF100Benchmark:
 
     def evaluate(self, yaml_path, val_log_file, eval_log_file, list_ind):
         """
-        Model evaluation on validation results.
+        Evaluate model performance on validation results.
 
         Args:
-            yaml_path (str): YAML file path.
-            val_log_file (str): val_log_file path.
-            eval_log_file (str): eval_log_file path.
-            list_ind (int): Index for current dataset.
+            yaml_path (str): Path to the YAML configuration file.
+            val_log_file (str): Path to the validation log file.
+            eval_log_file (str): Path to the evaluation log file.
+            list_ind (int): Index of the current dataset in the list.
+
+        Returns:
+            (float): The mean average precision (mAP) value for the evaluated model.
+
+        Examples:
+            Evaluate a model on a specific dataset
+            >>> benchmark = RF100Benchmark()
+            >>> benchmark.evaluate("path/to/data.yaml", "path/to/val_log.txt", "path/to/eval_log.txt", 0)
         """
         skip_symbols = ["🚀", "⚠️", "💡", "❌"]
         with open(yaml_path) as stream:
@@ -285,21 +311,23 @@ class ProfileModels:
     This class profiles the performance of different models, returning results such as model speed and FLOPs.
 
     Attributes:
-        paths (list): Paths of the models to profile.
-        num_timed_runs (int): Number of timed runs for the profiling. Default is 100.
-        num_warmup_runs (int): Number of warmup runs before profiling. Default is 10.
-        min_time (float): Minimum number of seconds to profile for. Default is 60.
-        imgsz (int): Image size used in the models. Default is 640.
+        paths (List[str]): Paths of the models to profile.
+        num_timed_runs (int): Number of timed runs for the profiling.
+        num_warmup_runs (int): Number of warmup runs before profiling.
+        min_time (float): Minimum number of seconds to profile for.
+        imgsz (int): Image size used in the models.
+        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): Device used for profiling.
 
     Methods:
-        profile(): Profiles the models and prints the result.
+        profile: Profiles the models and prints the result.
 
-    Example:
-        ```python
-        from ultralytics.utils.benchmarks import ProfileModels
-
-        ProfileModels(["yolov8n.yaml", "yolov8s.yaml"], imgsz=640).profile()
-        ```
+    Examples:
+        Profile models and print results
+        >>> from ultralytics.utils.benchmarks import ProfileModels
+        >>> profiler = ProfileModels(["yolov8n.yaml", "yolov8s.yaml"], imgsz=640)
+        >>> profiler.profile()
     """
 
     def __init__(
@@ -317,17 +345,23 @@ class ProfileModels:
         Initialize the ProfileModels class for profiling models.
 
         Args:
-            paths (list): List of paths of the models to be profiled.
-            num_timed_runs (int, optional): Number of timed runs for the profiling. Default is 100.
-            num_warmup_runs (int, optional): Number of warmup runs before the actual profiling starts. Default is 10.
-            min_time (float, optional): Minimum time in seconds for profiling a model. Default is 60.
-            imgsz (int, optional): Size of the image used during profiling. Default is 640.
-            half (bool, optional): Flag to indicate whether to use FP16 half-precision for TensorRT profiling.
-            trt (bool, optional): Flag to indicate whether to profile using TensorRT. Default is True.
-            device (torch.device, optional): Device used for profiling. If None, it is determined automatically.
+            paths (List[str]): List of paths of the models to be profiled.
+            num_timed_runs (int): Number of timed runs for the profiling.
+            num_warmup_runs (int): Number of warmup runs before the actual profiling starts.
+            min_time (float): Minimum time in seconds for profiling a model.
+            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.
 
         Notes:
-            FP16 'half' argument option removed for ONNX as slower on CPU than FP32
+            FP16 'half' argument option removed for ONNX as slower on CPU than FP32.
+
+        Examples:
+            Initialize and profile models
+            >>> from ultralytics.utils.benchmarks import ProfileModels
+            >>> profiler = ProfileModels(["yolov8n.yaml", "yolov8s.yaml"], imgsz=640)
+            >>> profiler.profile()
         """
         self.paths = paths
         self.num_timed_runs = num_timed_runs
@@ -339,7 +373,7 @@ class ProfileModels:
         self.device = device or torch.device(0 if torch.cuda.is_available() else "cpu")
 
     def profile(self):
-        """Logs the benchmarking results of a model, checks metrics against floor and returns the results."""
+        """Profiles YOLO models for speed and accuracy across various formats including ONNX and TensorRT."""
         files = self.get_files()
 
         if not files:
@@ -404,7 +438,7 @@ class ProfileModels:
 
     @staticmethod
     def iterative_sigma_clipping(data, sigma=2, max_iters=3):
-        """Applies an iterative sigma clipping algorithm to the given data times number of iterations."""
+        """Applies iterative sigma clipping to data to remove outliers based on specified sigma and iteration count."""
         data = np.array(data)
         for _ in range(max_iters):
             mean, std = np.mean(data), np.std(data)
@@ -415,7 +449,7 @@ class ProfileModels:
         return data
 
     def profile_tensorrt_model(self, engine_file: str, eps: float = 1e-3):
-        """Profiles the TensorRT model, measuring average run time and standard deviation among runs."""
+        """Profiles YOLO model performance with TensorRT, measuring average run time and standard deviation."""
         if not self.trt or not Path(engine_file).is_file():
             return 0.0, 0.0
 
@@ -499,7 +533,7 @@ class ProfileModels:
         return np.mean(run_times), np.std(run_times)
 
     def generate_table_row(self, model_name, t_onnx, t_engine, model_info):
-        """Generates a formatted string for a table row that includes model performance and metric details."""
+        """Generates a table row string with model performance metrics including inference times and model details."""
         layers, params, gradients, flops = model_info
         return (
             f"| {model_name:18s} | {self.imgsz} | - | {t_onnx[0]:.2f} ± {t_onnx[1]:.2f} ms | {t_engine[0]:.2f} ± "
@@ -508,7 +542,7 @@ class ProfileModels:
 
     @staticmethod
     def generate_results_dict(model_name, t_onnx, t_engine, model_info):
-        """Generates a dictionary of model details including name, parameters, GFLOPS and speed metrics."""
+        """Generates a dictionary of profiling results including model name, parameters, GFLOPs, and speed metrics."""
         layers, params, gradients, flops = model_info
         return {
             "model/name": model_name,
@@ -520,16 +554,19 @@ class ProfileModels:
 
     @staticmethod
     def print_table(table_rows):
-        """Formats and prints a comparison table for different models with given statistics and performance data."""
+        """Prints a formatted table of model profiling results, including speed and accuracy metrics."""
         gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "GPU"
-        header = (
-            f"| Model | size<br><sup>(pixels) | mAP<sup>val<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | "
-            f"Speed<br><sup>{gpu} TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |"
-        )
-        separator = (
-            "|-------------|---------------------|--------------------|------------------------------|"
-            "-----------------------------------|------------------|-----------------|"
-        )
+        headers = [
+            "Model",
+            "size<br><sup>(pixels)",
+            "mAP<sup>val<br>50-95",
+            f"Speed<br><sup>CPU ({get_cpu_info()}) ONNX<br>(ms)",
+            f"Speed<br><sup>{gpu} TensorRT<br>(ms)",
+            "params<br><sup>(M)",
+            "FLOPs<br><sup>(B)",
+        ]
+        header = "|" + "|".join(f" {h} " for h in headers) + "|"
+        separator = "|" + "|".join("-" * (len(h) + 2) for h in headers) + "|"
 
         print(f"\n\n{header}")
         print(separator)

{ultralytics-8.2.101 → ultralytics-8.2.103/ultralytics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.101
+Version: 8.2.103
 Summary: Ultralytics YOLO for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Ayush Chaurasia
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>

{ultralytics-8.2.101 → ultralytics-8.2.103}/ultralytics.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ ultralytics/cfg/datasets/coco8-seg.yaml
 ultralytics/cfg/datasets/coco8.yaml
 ultralytics/cfg/datasets/crack-seg.yaml
 ultralytics/cfg/datasets/dota8.yaml
+ultralytics/cfg/datasets/hand-keypoints.yaml
 ultralytics/cfg/datasets/lvis.yaml
 ultralytics/cfg/datasets/open-images-v7.yaml
 ultralytics/cfg/datasets/package-seg.yaml