dgenerate-ultralytics-headless 8.3.145__py3-none-any.whl → 8.3.146__py3-none-any.whl

ultralytics/models/yolo/obb/val.py

@@ -1,7 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 from pathlib import Path
-from typing import Dict, List, Tuple, Union
+from typing import Any, Dict, List, Tuple, Union
 
 import torch
 
@@ -40,7 +40,7 @@ class OBBValidator(DetectionValidator):
         >>> validator(model=args["model"])
     """
 
-    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
+    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None) -> None:
         """
         Initialize OBBValidator and set task to 'obb', metrics to OBBMetrics.
 
@@ -58,8 +58,13 @@ class OBBValidator(DetectionValidator):
         self.args.task = "obb"
         self.metrics = OBBMetrics(save_dir=self.save_dir, plot=True)
 
-    def init_metrics(self, model):
-        """Initialize evaluation metrics for YOLO."""
+    def init_metrics(self, model: torch.nn.Module) -> None:
+        """
+        Initialize evaluation metrics for YOLO obb validation.
+
+        Args:
+            model (torch.nn.Module): Model to validate.
+        """
         super().init_metrics(model)
         val = self.data.get(self.args.split, "")  # validation path
         self.is_dota = isinstance(val, str) and "DOTA" in val  # check if dataset is DOTA format
@@ -94,7 +99,7 @@ class OBBValidator(DetectionValidator):
 
         Args:
             si (int): Batch index to process.
-            batch (dict): Dictionary containing batch data with keys:
+            batch (Dict[str, Any]): Dictionary containing batch data with keys:
                 - batch_idx: Tensor of batch indices
                 - cls: Tensor of class labels
                 - bboxes: Tensor of bounding boxes
@@ -103,7 +108,7 @@ class OBBValidator(DetectionValidator):
                 - ratio_pad: Ratio and padding information
 
         Returns:
-            (dict): Prepared batch data with scaled bounding boxes and metadata.
+            (Dict[str, Any]): Prepared batch data with scaled bounding boxes and metadata.
         """
         idx = batch["batch_idx"] == si
         cls = batch["cls"][idx].squeeze(-1)
@@ -116,7 +121,7 @@ class OBBValidator(DetectionValidator):
             ops.scale_boxes(imgsz, bbox, ori_shape, ratio_pad=ratio_pad, xywh=True)  # native-space labels
         return {"cls": cls, "bbox": bbox, "ori_shape": ori_shape, "imgsz": imgsz, "ratio_pad": ratio_pad}
 
-    def _prepare_pred(self, pred: torch.Tensor, pbatch: Dict) -> torch.Tensor:
+    def _prepare_pred(self, pred: torch.Tensor, pbatch: Dict[str, Any]) -> torch.Tensor:
         """
         Prepare predictions by scaling bounding boxes to original image dimensions.
 
@@ -125,7 +130,7 @@ class OBBValidator(DetectionValidator):
 
         Args:
             pred (torch.Tensor): Prediction tensor containing bounding box coordinates and other information.
-            pbatch (dict): Dictionary containing batch information with keys:
+            pbatch (Dict[str, Any]): Dictionary containing batch information with keys:
                 - imgsz (tuple): Model input image size.
                 - ori_shape (tuple): Original image shape.
                 - ratio_pad (tuple): Ratio and padding information for scaling.
@@ -139,13 +144,13 @@ class OBBValidator(DetectionValidator):
         )  # native-space pred
         return predn
 
-    def plot_predictions(self, batch: Dict, preds: List[torch.Tensor], ni: int):
+    def plot_predictions(self, batch: Dict[str, Any], preds: List[torch.Tensor], ni: int) -> None:
         """
         Plot predicted bounding boxes on input images and save the result.
 
         Args:
-            batch (dict): Batch data containing images, file paths, and other metadata.
-            preds (list): List of prediction tensors for each image in the batch.
+            batch (Dict[str, Any]): Batch data containing images, file paths, and other metadata.
+            preds (List[torch.Tensor]): List of prediction tensors for each image in the batch.
             ni (int): Batch index used for naming the output file.
 
         Examples:
@@ -163,7 +168,7 @@ class OBBValidator(DetectionValidator):
             on_plot=self.on_plot,
         )  # pred
 
-    def pred_to_json(self, predn: torch.Tensor, filename: Union[str, Path]):
+    def pred_to_json(self, predn: torch.Tensor, filename: Union[str, Path]) -> None:
         """
         Convert YOLO predictions to COCO JSON format with rotated bounding box information.
 
@@ -192,7 +197,9 @@ class OBBValidator(DetectionValidator):
                 }
             )
 
-    def save_one_txt(self, predn: torch.Tensor, save_conf: bool, shape: Tuple[int, int], file: Union[Path, str]):
+    def save_one_txt(
+        self, predn: torch.Tensor, save_conf: bool, shape: Tuple[int, int], file: Union[Path, str]
+    ) -> None:
         """
         Save YOLO OBB detections to a text file in normalized coordinates.
 
@@ -200,7 +207,7 @@ class OBBValidator(DetectionValidator):
             predn (torch.Tensor): Predicted detections with shape (N, 7) containing bounding boxes, confidence scores,
                 class predictions, and angles in format (x, y, w, h, conf, cls, angle).
             save_conf (bool): Whether to save confidence scores in the text file.
-            shape (tuple): Original image shape in format (height, width).
+            shape (Tuple[int, int]): Original image shape in format (height, width).
             file (Path | str): Output file path to save detections.
 
         Examples:
@@ -222,15 +229,15 @@ class OBBValidator(DetectionValidator):
             obb=obb,
         ).save_txt(file, save_conf=save_conf)
 
-    def eval_json(self, stats: Dict) -> Dict:
+    def eval_json(self, stats: Dict[str, Any]) -> Dict[str, Any]:
         """
         Evaluate YOLO output in JSON format and save predictions in DOTA format.
 
         Args:
-            stats (dict): Performance statistics dictionary.
+            stats (Dict[str, Any]): Performance statistics dictionary.
 
         Returns:
-            (dict): Updated performance statistics.
+            (Dict[str, Any]): Updated performance statistics.
         """
         if self.args.save_json and self.is_dota and len(self.jdict):
             import json

ultralytics/models/yolo/pose/val.py

@@ -49,7 +49,7 @@ class PoseValidator(DetectionValidator):
         >>> validator()
     """
 
-    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
+    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None) -> None:
         """
         Initialize a PoseValidator object for pose estimation validation.
 
@@ -107,8 +107,13 @@ class PoseValidator(DetectionValidator):
             "mAP50-95)",
         )
 
-    def init_metrics(self, model):
-        """Initialize pose estimation metrics for YOLO model."""
+    def init_metrics(self, model: torch.nn.Module) -> None:
+        """
+        Initialize evaluation metrics for YOLO pose validation.
+
+        Args:
+            model (torch.nn.Module): Model to validate.
+        """
         super().init_metrics(model)
         self.kpt_shape = self.data["kpt_shape"]
         is_pose = self.kpt_shape == [17, 3]
@@ -122,10 +127,10 @@ class PoseValidator(DetectionValidator):
 
         Args:
             si (int): Batch index.
-            batch (dict): Dictionary containing batch data with keys like 'keypoints', 'batch_idx', etc.
+            batch (Dict[str, Any]): Dictionary containing batch data with keys like 'keypoints', 'batch_idx', etc.
 
         Returns:
-            (dict): Prepared batch with keypoints scaled to original image dimensions.
+            (Dict[str, Any]): Prepared batch with keypoints scaled to original image dimensions.
 
         Notes:
             This method extends the parent class's _prepare_batch method by adding keypoint processing.
@@ -151,7 +156,7 @@ class PoseValidator(DetectionValidator):
 
         Args:
             pred (torch.Tensor): Raw prediction tensor from the model.
-            pbatch (dict): Processed batch dictionary containing image information including:
+            pbatch (Dict[str, Any]): Processed batch dictionary containing image information including:
                 - imgsz: Image size used for inference
                 - ori_shape: Original image shape
                 - ratio_pad: Ratio and padding information for coordinate scaling
@@ -166,7 +171,7 @@ class PoseValidator(DetectionValidator):
         ops.scale_coords(pbatch["imgsz"], pred_kpts, pbatch["ori_shape"], ratio_pad=pbatch["ratio_pad"])
         return predn, pred_kpts
 
-    def update_metrics(self, preds: List[torch.Tensor], batch: Dict[str, Any]):
+    def update_metrics(self, preds: List[torch.Tensor], batch: Dict[str, Any]) -> None:
         """
         Update metrics with new predictions and ground truth data.
 
@@ -175,7 +180,7 @@ class PoseValidator(DetectionValidator):
 
         Args:
             preds (List[torch.Tensor]): List of prediction tensors from the model.
-            batch (dict): Batch data containing images and ground truth annotations.
+            batch (Dict[str, Any]): Batch data containing images and ground truth annotations.
         """
         for si, pred in enumerate(preds):
             self.seen += 1
@@ -266,12 +271,12 @@ class PoseValidator(DetectionValidator):
 
         return self.match_predictions(detections[:, 5], gt_cls, iou)
 
-    def plot_val_samples(self, batch: Dict[str, Any], ni: int):
+    def plot_val_samples(self, batch: Dict[str, Any], ni: int) -> None:
         """
         Plot and save validation set samples with ground truth bounding boxes and keypoints.
 
         Args:
-            batch (dict): Dictionary containing batch data with keys:
+            batch (Dict[str, Any]): Dictionary containing batch data with keys:
                 - img (torch.Tensor): Batch of images
                 - batch_idx (torch.Tensor): Batch indices for each image
                 - cls (torch.Tensor): Class labels
@@ -292,12 +297,12 @@ class PoseValidator(DetectionValidator):
             on_plot=self.on_plot,
         )
 
-    def plot_predictions(self, batch: Dict[str, Any], preds: List[torch.Tensor], ni: int):
+    def plot_predictions(self, batch: Dict[str, Any], preds: List[torch.Tensor], ni: int) -> None:
         """
         Plot and save model predictions with bounding boxes and keypoints.
 
         Args:
-            batch (dict): Dictionary containing batch data including images, file paths, and other metadata.
+            batch (Dict[str, Any]): Dictionary containing batch data including images, file paths, and other metadata.
             preds (List[torch.Tensor]): List of prediction tensors from the model, each containing bounding boxes,
                 confidence scores, class predictions, and keypoints.
             ni (int): Batch index used for naming the output file.
@@ -323,7 +328,7 @@ class PoseValidator(DetectionValidator):
         save_conf: bool,
         shape: Tuple[int, int],
         file: Path,
-    ):
+    ) -> None:
         """
         Save YOLO pose detections to a text file in normalized coordinates.
 
@@ -349,7 +354,7 @@ class PoseValidator(DetectionValidator):
             keypoints=pred_kpts,
         ).save_txt(file, save_conf=save_conf)
 
-    def pred_to_json(self, predn: torch.Tensor, filename: str):
+    def pred_to_json(self, predn: torch.Tensor, filename: str) -> None:
         """
         Convert YOLO predictions to COCO JSON format.
 

ultralytics/models/yolo/segment/val.py

@@ -2,6 +2,7 @@
 
 from multiprocessing.pool import ThreadPool
 from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
 import torch
@@ -35,7 +36,7 @@ class SegmentationValidator(DetectionValidator):
         >>> validator()
     """
 
-    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
+    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None) -> None:
         """
         Initialize SegmentationValidator and set task to 'segment', metrics to SegmentMetrics.
 
@@ -52,13 +53,21 @@ class SegmentationValidator(DetectionValidator):
         self.args.task = "segment"
         self.metrics = SegmentMetrics(save_dir=self.save_dir)
 
-    def preprocess(self, batch):
-        """Preprocess batch by converting masks to float and sending to device."""
+    def preprocess(self, batch: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Preprocess batch of images for YOLO segmentation validation.
+
+        Args:
+            batch (Dict[str, Any]): Batch containing images and annotations.
+
+        Returns:
+            (Dict[str, Any]): Preprocessed batch.
+        """
         batch = super().preprocess(batch)
         batch["masks"] = batch["masks"].to(self.device).float()
         return batch
 
-    def init_metrics(self, model):
+    def init_metrics(self, model: torch.nn.Module) -> None:
         """
         Initialize metrics and select mask processing function based on save_json flag.
 
@@ -73,7 +82,7 @@ class SegmentationValidator(DetectionValidator):
         self.process = ops.process_mask_native if self.args.save_json or self.args.save_txt else ops.process_mask
         self.stats = dict(tp_m=[], tp=[], conf=[], pred_cls=[], target_cls=[], target_img=[])
 
-    def get_desc(self):
+    def get_desc(self) -> str:
         """Return a formatted description of evaluation metrics."""
         return ("%22s" + "%11s" * 10) % (
             "Class",
@@ -89,44 +98,46 @@ class SegmentationValidator(DetectionValidator):
             "mAP50-95)",
         )
 
-    def postprocess(self, preds):
+    def postprocess(self, preds: List[torch.Tensor]) -> Tuple[List[torch.Tensor], torch.Tensor]:
         """
         Post-process YOLO predictions and return output detections with proto.
 
         Args:
-            preds (list): Raw predictions from the model.
+            preds (List[torch.Tensor]): Raw predictions from the model.
 
         Returns:
-            p (torch.Tensor): Processed detection predictions.
+            p (List[torch.Tensor]): Processed detection predictions.
             proto (torch.Tensor): Prototype masks for segmentation.
         """
         p = super().postprocess(preds[0])
         proto = preds[1][-1] if len(preds[1]) == 3 else preds[1]  # second output is len 3 if pt, but only 1 if exported
         return p, proto
 
-    def _prepare_batch(self, si, batch):
+    def _prepare_batch(self, si: int, batch: Dict[str, Any]) -> Dict[str, Any]:
         """
         Prepare a batch for training or inference by processing images and targets.
 
         Args:
             si (int): Batch index.
-            batch (dict): Batch data containing images and targets.
+            batch (Dict[str, Any]): Batch data containing images and annotations.
 
         Returns:
-            (dict): Prepared batch with processed images and targets.
+            (Dict[str, Any]): Prepared batch with processed annotations.
         """
         prepared_batch = super()._prepare_batch(si, batch)
         midx = [si] if self.args.overlap_mask else batch["batch_idx"] == si
         prepared_batch["masks"] = batch["masks"][midx]
         return prepared_batch
 
-    def _prepare_pred(self, pred, pbatch, proto):
+    def _prepare_pred(
+        self, pred: torch.Tensor, pbatch: Dict[str, Any], proto: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """
         Prepare predictions for evaluation by processing bounding boxes and masks.
 
         Args:
             pred (torch.Tensor): Raw predictions from the model.
-            pbatch (dict): Prepared batch data.
+            pbatch (Dict[str, Any]): Prepared batch information.
             proto (torch.Tensor): Prototype masks for segmentation.
 
         Returns:
@@ -137,13 +148,13 @@ class SegmentationValidator(DetectionValidator):
         pred_masks = self.process(proto, pred[:, 6:], pred[:, :4], shape=pbatch["imgsz"])
         return predn, pred_masks
 
-    def update_metrics(self, preds, batch):
+    def update_metrics(self, preds: Tuple[List[torch.Tensor], torch.Tensor], batch: Dict[str, Any]) -> None:
         """
         Update metrics with the current batch predictions and targets.
 
         Args:
-            preds (list): Predictions from the model.
-            batch (dict): Batch data containing images and targets.
+            preds (Tuple[List[torch.Tensor], torch.Tensor]): List of predictions from the model.
+            batch (Dict[str, Any]): Batch data containing ground truth.
         """
         for si, (pred, proto) in enumerate(zip(preds[0], preds[1])):
             self.seen += 1
@@ -214,21 +225,16 @@ class SegmentationValidator(DetectionValidator):
                     self.save_dir / "labels" / f"{Path(batch['im_file'][si]).stem}.txt",
                 )
 
-    def finalize_metrics(self, *args, **kwargs):
-        """
-        Finalize evaluation metrics by setting the speed attribute in the metrics object.
-
-        This method is called at the end of validation to set the processing speed for the metrics calculations.
-        It transfers the validator's speed measurement to the metrics object for reporting.
-
-        Args:
-            *args (Any): Variable length argument list.
-            **kwargs (Any): Arbitrary keyword arguments.
-        """
-        self.metrics.speed = self.speed
-        self.metrics.confusion_matrix = self.confusion_matrix
-
-    def _process_batch(self, detections, gt_bboxes, gt_cls, pred_masks=None, gt_masks=None, overlap=False, masks=False):
+    def _process_batch(
+        self,
+        detections: torch.Tensor,
+        gt_bboxes: torch.Tensor,
+        gt_cls: torch.Tensor,
+        pred_masks: Optional[torch.Tensor] = None,
+        gt_masks: Optional[torch.Tensor] = None,
+        overlap: Optional[bool] = False,
+        masks: Optional[bool] = False,
+    ) -> torch.Tensor:
         """
         Compute correct prediction matrix for a batch based on bounding boxes and optional masks.
 
@@ -241,8 +247,8 @@ class SegmentationValidator(DetectionValidator):
             pred_masks (torch.Tensor, optional): Tensor representing predicted masks, if available. The shape should
                 match the ground truth masks.
             gt_masks (torch.Tensor, optional): Tensor of shape (M, H, W) representing ground truth masks, if available.
-            overlap (bool): Flag indicating if overlapping masks should be considered.
-            masks (bool): Flag indicating if the batch contains mask data.
+            overlap (bool, optional): Flag indicating if overlapping masks should be considered.
+            masks (bool, optional): Flag indicating if the batch contains mask data.
 
         Returns:
             (torch.Tensor): A correct prediction matrix of shape (N, 10), where 10 represents different IoU levels.
@@ -272,12 +278,12 @@ class SegmentationValidator(DetectionValidator):
 
         return self.match_predictions(detections[:, 5], gt_cls, iou)
 
-    def plot_val_samples(self, batch, ni):
+    def plot_val_samples(self, batch: Dict[str, Any], ni: int) -> None:
         """
         Plot validation samples with bounding box labels and masks.
 
         Args:
-            batch (dict): Batch data containing images and targets.
+            batch (Dict[str, Any]): Batch containing images and annotations.
             ni (int): Batch index.
         """
         plot_images(
@@ -292,13 +298,13 @@ class SegmentationValidator(DetectionValidator):
             on_plot=self.on_plot,
         )
 
-    def plot_predictions(self, batch, preds, ni):
+    def plot_predictions(self, batch: Dict[str, Any], preds: List[torch.Tensor], ni: int) -> None:
         """
         Plot batch predictions with masks and bounding boxes.
 
         Args:
-            batch (dict): Batch data containing images.
-            preds (list): Predictions from the model.
+            batch (Dict[str, Any]): Batch containing images and annotations.
+            preds (List[torch.Tensor]): List of predictions from the model.
             ni (int): Batch index.
         """
         plot_images(
@@ -312,15 +318,17 @@ class SegmentationValidator(DetectionValidator):
         )  # pred
         self.plot_masks.clear()
 
-    def save_one_txt(self, predn, pred_masks, save_conf, shape, file):
+    def save_one_txt(
+        self, predn: torch.Tensor, pred_masks: torch.Tensor, save_conf: bool, shape: Tuple[int, int], file: Path
+    ) -> None:
         """
         Save YOLO detections to a txt file in normalized coordinates in a specific format.
 
         Args:
-            predn (torch.Tensor): Predictions in the format [x1, y1, x2, y2, conf, cls].
+            predn (torch.Tensor): Predictions in the format (x1, y1, x2, y2, conf, class).
             pred_masks (torch.Tensor): Predicted masks.
             save_conf (bool): Whether to save confidence scores.
-            shape (tuple): Original image shape.
+            shape (Tuple[int, int]): Shape of the original image.
             file (Path): File path to save the detections.
         """
         from ultralytics.engine.results import Results
@@ -333,7 +341,7 @@ class SegmentationValidator(DetectionValidator):
             masks=pred_masks,
         ).save_txt(file, save_conf=save_conf)
 
-    def pred_to_json(self, predn, filename, pred_masks):
+    def pred_to_json(self, predn: torch.Tensor, filename: str, pred_masks: torch.Tensor) -> None:
         """
         Save one JSON result for COCO evaluation.
 
@@ -371,8 +379,8 @@ class SegmentationValidator(DetectionValidator):
                 }
             )
 
-    def eval_json(self, stats):
-        """Return COCO-style object detection evaluation metrics."""
+    def eval_json(self, stats: Dict[str, Any]) -> Dict[str, Any]:
+        """Return COCO-style instance segmentation evaluation metrics."""
         if self.args.save_json and (self.is_lvis or self.is_coco) and len(self.jdict):
             pred_json = self.save_dir / "predictions.json"  # predictions
 

ultralytics/solutions/analytics.py

@@ -68,6 +68,8 @@ class Analytics(BaseSolution):
 
         self.total_counts = 0  # count variable for storing total counts i.e. for line
         self.clswise_count = {}  # dictionary for class-wise counts
+        self.update_every = kwargs.get("update_every", 30)  # Only update graph every 30 frames by default
+        self.last_plot_im = None  # Cache of the last rendered chart
 
         # Ensure line and area chart
         if self.type in {"line", "area"}:
@@ -111,16 +113,21 @@ class Analytics(BaseSolution):
         if self.type == "line":
             for _ in self.boxes:
                 self.total_counts += 1
-            plot_im = self.update_graph(frame_number=frame_number)
+            update_required = frame_number % self.update_every == 0 or self.last_plot_im is None
+            if update_required:
+                self.last_plot_im = self.update_graph(frame_number=frame_number)
+            plot_im = self.last_plot_im
             self.total_counts = 0
         elif self.type in {"pie", "bar", "area"}:
-            self.clswise_count = {}
-            for cls in self.clss:
-                if self.names[int(cls)] in self.clswise_count:
-                    self.clswise_count[self.names[int(cls)]] += 1
-                else:
-                    self.clswise_count[self.names[int(cls)]] = 1
-            plot_im = self.update_graph(frame_number=frame_number, count_dict=self.clswise_count, plot=self.type)
+            from collections import Counter
+
+            self.clswise_count = Counter(self.names[int(cls)] for cls in self.clss)
+            update_required = frame_number % self.update_every == 0 or self.last_plot_im is None
+            if update_required:
+                self.last_plot_im = self.update_graph(
+                    frame_number=frame_number, count_dict=self.clswise_count, plot=self.type
+                )
+            plot_im = self.last_plot_im
         else:
             raise ModuleNotFoundError(f"{self.type} chart is not supported ❌")
 
@@ -187,7 +194,7 @@ class Analytics(BaseSolution):
                 self.ax.clear()
                 for key, y_data in y_data_dict.items():
                     color = next(color_cycle)
-                    self.ax.fill_between(x_data, y_data, color=color, alpha=0.7)
+                    self.ax.fill_between(x_data, y_data, color=color, alpha=0.55)
                     self.ax.plot(
                         x_data,
                         y_data,
@@ -235,6 +242,7 @@ class Analytics(BaseSolution):
 
         # Common plot settings
         self.ax.set_facecolor("#f0f0f0")  # Set to light gray or any other color you like
+        self.ax.grid(True, linestyle="--", linewidth=0.5, alpha=0.5)  # Display grid for more data insights
         self.ax.set_title(self.title, color=self.fg_color, fontsize=self.fontsize)
         self.ax.set_xlabel(self.x_label, color=self.fg_color, fontsize=self.fontsize - 3)
         self.ax.set_ylabel(self.y_label, color=self.fg_color, fontsize=self.fontsize - 3)

ultralytics/solutions/object_counter.py

@@ -79,8 +79,7 @@ class ObjectCounter(BaseSolution):
             return
 
         if len(self.region) == 2:  # Linear region (defined as a line segment)
-            line = self.LineString(self.region)  # Check if the line intersects the trajectory of the object
-            if line.intersects(self.LineString([prev_position, current_centroid])):
+            if self.r_s.intersects(self.LineString([prev_position, current_centroid])):
                 # Determine orientation of the region (vertical or horizontal)
                 if abs(self.region[0][0] - self.region[1][0]) < abs(self.region[0][1] - self.region[1][1]):
                     # Vertical region: Compare x-coordinates to determine direction
@@ -100,8 +99,7 @@ class ObjectCounter(BaseSolution):
                 self.counted_ids.append(track_id)
 
         elif len(self.region) > 2:  # Polygonal region
-            polygon = self.Polygon(self.region)
-            if polygon.contains(self.Point(current_centroid)):
+            if self.r_s.contains(self.Point(current_centroid)):
                 # Determine motion direction for vertical or horizontal polygons
                 region_width = max(p[0] for p in self.region) - min(p[0] for p in self.region)
                 region_height = max(p[1] for p in self.region) - min(p[1] for p in self.region)

ultralytics/trackers/bot_sort.py

@@ -260,11 +260,13 @@ class ReID:
         from ultralytics import YOLO
 
         self.model = YOLO(model)
-        self.model(embed=[len(self.model.model.model) - 2 if ".pt" in model else -1], verbose=False)  # initialize
+        self.model(embed=[len(self.model.model.model) - 2 if ".pt" in model else -1], verbose=False, save=False)  # init
 
     def __call__(self, img: np.ndarray, dets: np.ndarray) -> List[np.ndarray]:
         """Extract embeddings for detected objects."""
-        feats = self.model([save_one_box(det, img, save=False) for det in xywh2xyxy(torch.from_numpy(dets[:, :4]))])
+        feats = self.model.predictor(
+            [save_one_box(det, img, save=False) for det in xywh2xyxy(torch.from_numpy(dets[:, :4]))]
+        )
         if len(feats) != dets.shape[0] and feats[0].shape[0] == dets.shape[0]:
             feats = feats[0]  # batched prediction with non-PyTorch backend
         return [f.cpu().numpy() for f in feats]

ultralytics/utils/__init__.py

@@ -841,8 +841,7 @@ def is_docker() -> bool:
         (bool): True if the script is running inside a Docker container, False otherwise.
     """
     try:
-        with open("/proc/self/cgroup") as f:
-            return "docker" in f.read()
+        return os.path.exists("/.dockerenv")
     except Exception:
         return False
 

ultralytics/utils/benchmarks.py

@@ -106,41 +106,41 @@ def benchmark(
     if format_arg:
         formats = frozenset(export_formats()["Argument"])
         assert format in formats, f"Expected format to be one of {formats}, but got '{format_arg}'."
-    for i, (name, format, suffix, cpu, gpu, _) in enumerate(zip(*export_formats().values())):
+    for name, format, suffix, cpu, gpu, _ in zip(*export_formats().values()):
         emoji, filename = "❌", None  # export defaults
         try:
             if format_arg and format_arg != format:
                 continue
 
             # Checks
-            if i == 7:  # TF GraphDef
+            if format == "pb":
                 assert model.task != "obb", "TensorFlow GraphDef not supported for OBB task"
-            elif i == 9:  # Edge TPU
+            elif format == "edgetpu":
                 assert LINUX and not ARM64, "Edge TPU export only supported on non-aarch64 Linux"
-            elif i in {5, 10}:  # CoreML and TF.js
+            elif format in {"coreml", "tfjs"}:
                 assert MACOS or (LINUX and not ARM64), (
                     "CoreML and TF.js export only supported on macOS and non-aarch64 Linux"
                 )
-            if i in {5}:  # CoreML
+            if format == "coreml":
                 assert not IS_PYTHON_3_13, "CoreML not supported on Python 3.13"
-            if i in {6, 7, 8, 9, 10}:  # TF SavedModel, TF GraphDef, and TFLite, TF EdgeTPU and TF.js
+            if format in {"saved_model", "pb", "tflite", "edgetpu", "tfjs"}:
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 TensorFlow exports not supported by onnx2tf yet"
                 # assert not IS_PYTHON_MINIMUM_3_12, "TFLite exports not supported on Python>=3.12 yet"
-            if i == 11:  # Paddle
+            if format == "paddle":
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 Paddle exports not supported yet"
                 assert model.task != "obb", "Paddle OBB bug https://github.com/PaddlePaddle/Paddle/issues/72024"
                 assert not is_end2end, "End-to-end models not supported by PaddlePaddle yet"
                 assert (LINUX and not IS_JETSON) or MACOS, "Windows and Jetson Paddle exports not supported yet"
-            if i == 12:  # MNN
+            if format == "mnn":
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 MNN exports not supported yet"
-            if i == 13:  # NCNN
+            if format == "ncnn":
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 NCNN exports not supported yet"
-            if i == 14:  # IMX
+            if format == "imx":
                 assert not is_end2end
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 IMX exports not supported"
                 assert model.task == "detect", "IMX only supported for detection task"
                 assert "C2f" in model.__str__(), "IMX only supported for YOLOv8"  # TODO: enable for YOLO11
-            if i == 15:  # RKNN
+            if format == "rknn":
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 RKNN exports not supported yet"
                 assert not is_end2end, "End-to-end models not supported by RKNN yet"
                 assert LINUX, "RKNN only supported on Linux"
@@ -163,10 +163,10 @@ def benchmark(
             emoji = "❎"  # indicates export succeeded
 
             # Predict
-            assert model.task != "pose" or i != 7, "GraphDef Pose inference is not supported"
-            assert i not in {9, 10}, "inference not supported"  # Edge TPU and TF.js are unsupported
-            assert i != 5 or platform.system() == "Darwin", "inference only supported on macOS>=10.13"  # CoreML
-            if i in {13}:
+            assert model.task != "pose" or format != "pb", "GraphDef Pose inference is not supported"
+            assert format not in {"edgetpu", "tfjs"}, "inference not supported"
+            assert format != "coreml" or platform.system() == "Darwin", "inference only supported on macOS>=10.13"
+            if format == "ncnn":
                 assert not is_end2end, "End-to-end torch.topk operation is not supported for NCNN prediction yet"
             exported_model.predict(ASSETS / "bus.jpg", imgsz=imgsz, device=device, half=half, verbose=False)