dgenerate-ultralytics-headless 8.3.150__tar.gz → 8.3.151__tar.gz

{dgenerate_ultralytics_headless-8.3.150 → dgenerate_ultralytics_headless-8.3.151}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.150
+Version: 8.3.151
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{dgenerate_ultralytics_headless-8.3.150 → dgenerate_ultralytics_headless-8.3.151}/dgenerate_ultralytics_headless.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.150
+Version: 8.3.151
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{dgenerate_ultralytics_headless-8.3.150 → dgenerate_ultralytics_headless-8.3.151}/ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-__version__ = "8.3.150"
+__version__ = "8.3.151"
 
 import os
 

{dgenerate_ultralytics_headless-8.3.150 → dgenerate_ultralytics_headless-8.3.151}/ultralytics/solutions/trackzone.py

@@ -44,6 +44,7 @@ class TrackZone(BaseSolution):
         super().__init__(**kwargs)
         default_region = [(75, 75), (565, 75), (565, 285), (75, 285)]
         self.region = cv2.convexHull(np.array(self.region or default_region, dtype=np.int32))
+        self.mask = None
 
     def process(self, im0):
         """
@@ -66,10 +67,10 @@ class TrackZone(BaseSolution):
         """
         annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
 
-        # Create a mask for the region and extract tracks from the masked image
-        mask = np.zeros_like(im0[:, :, 0])
-        mask = cv2.fillPoly(mask, [self.region], 255)
-        masked_frame = cv2.bitwise_and(im0, im0, mask=mask)
+        if self.mask is None:  # Create a mask for the region
+            self.mask = np.zeros_like(im0[:, :, 0])
+            cv2.fillPoly(self.mask, [self.region], 255)
+        masked_frame = cv2.bitwise_and(im0, im0, mask=self.mask)
         self.extract_tracks(masked_frame)
 
         # Draw the region boundary

{dgenerate_ultralytics_headless-8.3.150 → dgenerate_ultralytics_headless-8.3.151}/ultralytics/trackers/track.py

@@ -92,8 +92,6 @@ def on_predict_postprocess_end(predictor: object, persist: bool = False) -> None
             predictor.vid_path[i if is_stream else 0] = vid_path
 
         det = (result.obb if is_obb else result.boxes).cpu().numpy()
-        if len(det) == 0:
-            continue
         tracks = tracker.update(det, result.orig_img, getattr(result, "feats", None))
         if len(tracks) == 0:
             continue

{dgenerate_ultralytics_headless-8.3.150 → dgenerate_ultralytics_headless-8.3.151}/ultralytics/utils/metrics.py

@@ -515,7 +515,7 @@ class ConfusionMatrix(DataExportMixin):
             decimals (int): Number of decimal places to round the output values to.
 
         Returns:
-            List[Dict[str, float]]: A list of dictionaries, each representing one predicted class with corresponding values for all actual classes.
+            (List[Dict[str, float]]): A list of dictionaries, each representing one predicted class with corresponding values for all actual classes.
 
         Examples:
             >>> results = model.val(data="coco8.yaml", plots=True)
@@ -1039,12 +1039,27 @@ class DetMetrics(SimpleClass, DataExportMixin):
         """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results
 
-    def summary(self, **kwargs) -> List[Dict[str, Union[str, float]]]:
-        """Return per-class detection metrics with shared scalar values included."""
+    def summary(self, normalize: bool = True, decimals: int = 5) -> List[Dict[str, Union[str, float]]]:
+        """
+        Generate a summarized representation of per-class detection metrics as a list of dictionaries. Includes shared
+        scalar metrics (mAP, mAP50, mAP75) alongside precision, recall, and F1-score for each class.
+
+        Args:
+           normalize (bool): For Detect metrics, everything is normalized  by default [0-1].
+           decimals (int): Number of decimal places to round the metrics values to.
+
+        Returns:
+           (List[Dict[str, Union[str, float]]]): A list of dictionaries, each representing one class with corresponding metric values.
+
+        Examples:
+           >>> results = model.val(data="coco8.yaml")
+           >>> detection_summary = results.summary()
+           >>> print(detection_summary)
+        """
         scalars = {
-            "box-map": self.box.map,
-            "box-map50": self.box.map50,
-            "box-map75": self.box.map75,
+            "box-map": round(self.box.map, decimals),
+            "box-map50": round(self.box.map50, decimals),
+            "box-map75": round(self.box.map75, decimals),
         }
         per_class = {
             "box-p": self.box.p,
@@ -1052,11 +1067,7 @@ class DetMetrics(SimpleClass, DataExportMixin):
             "box-f1": self.box.f1,
         }
         return [
-            {
-                "class_name": self.names[i] if hasattr(self, "names") and i in self.names else str(i),
-                **{k: v[i] for k, v in per_class.items()},
-                **scalars,
-            }
+            {"class_name": self.names[i], **{k: round(v[i], decimals) for k, v in per_class.items()}, **scalars}
             for i in range(len(next(iter(per_class.values()), [])))
         ]
 
@@ -1200,15 +1211,30 @@ class SegmentMetrics(SimpleClass, DataExportMixin):
         """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results + self.seg.curves_results
 
-    def summary(self, **kwargs) -> List[Dict[str, Union[str, float]]]:
-        """Return per-class segmentation metrics with shared scalar values included (box + mask)."""
+    def summary(self, normalize: bool = True, decimals: int = 5) -> List[Dict[str, Union[str, float]]]:
+        """
+        Generate a summarized representation of per-class segmentation metrics as a list of dictionaries. Includes both
+        box and mask scalar metrics (mAP, mAP50, mAP75) alongside precision, recall, and F1-score for each class.
+
+        Args:
+            normalize (bool): For Segment metrics, everything is normalized  by default [0-1].
+            decimals (int): Number of decimal places to round the metrics values to.
+
+        Returns:
+            (List[Dict[str, Union[str, float]]]): A list of dictionaries, each representing one class with corresponding metric values.
+
+        Examples:
+            >>> results = model.val(data="coco8-seg.yaml")
+            >>> seg_summary = results.summary(decimals=4)
+            >>> print(seg_summary)
+        """
         scalars = {
-            "box-map": self.box.map,
-            "box-map50": self.box.map50,
-            "box-map75": self.box.map75,
-            "mask-map": self.seg.map,
-            "mask-map50": self.seg.map50,
-            "mask-map75": self.seg.map75,
+            "box-map": round(self.box.map, decimals),
+            "box-map50": round(self.box.map50, decimals),
+            "box-map75": round(self.box.map75, decimals),
+            "mask-map": round(self.seg.map, decimals),
+            "mask-map50": round(self.seg.map50, decimals),
+            "mask-map75": round(self.seg.map75, decimals),
         }
         per_class = {
             "box-p": self.box.p,
@@ -1219,7 +1245,7 @@ class SegmentMetrics(SimpleClass, DataExportMixin):
             "mask-f1": self.seg.f1,
         }
         return [
-            {"class_name": self.names[i], **{k: v[i] for k, v in per_class.items()}, **scalars}
+            {"class_name": self.names[i], **{k: round(v[i], decimals) for k, v in per_class.items()}, **scalars}
             for i in range(len(next(iter(per_class.values()), [])))
         ]
 
@@ -1363,15 +1389,30 @@ class PoseMetrics(SegmentMetrics):
         """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results + self.pose.curves_results
 
-    def summary(self, **kwargs) -> List[Dict[str, Union[str, float]]]:
-        """Return per-class pose metrics with shared scalar values included (box + pose)."""
+    def summary(self, normalize: bool = True, decimals: int = 5) -> List[Dict[str, Union[str, float]]]:
+        """
+        Generate a summarized representation of per-class pose metrics as a list of dictionaries. Includes both box and
+        pose scalar metrics (mAP, mAP50, mAP75) alongside precision, recall, and F1-score for each class.
+
+        Args:
+            normalize (bool): For Pose metrics, everything is normalized  by default [0-1].
+            decimals (int): Number of decimal places to round the metrics values to.
+
+        Returns:
+            (List[Dict[str, Union[str, float]]]): A list of dictionaries, each representing one class with corresponding metric values.
+
+        Examples:
+            >>> results = model.val(data="coco8-pose.yaml")
+            >>> pose_summary = results.summary(decimals=4)
+            >>> print(pose_summary)
+        """
         scalars = {
-            "box-map": self.box.map,
-            "box-map50": self.box.map50,
-            "box-map75": self.box.map75,
-            "pose-map": self.pose.map,
-            "pose-map50": self.pose.map50,
-            "pose-map75": self.pose.map75,
+            "box-map": round(self.box.map, decimals),
+            "box-map50": round(self.box.map50, decimals),
+            "box-map75": round(self.box.map75, decimals),
+            "pose-map": round(self.pose.map, decimals),
+            "pose-map50": round(self.pose.map50, decimals),
+            "pose-map75": round(self.pose.map75, decimals),
         }
         per_class = {
             "box-p": self.box.p,
@@ -1382,7 +1423,7 @@ class PoseMetrics(SegmentMetrics):
             "pose-f1": self.pose.f1,
         }
         return [
-            {"class_name": self.names[i], **{k: v[i] for k, v in per_class.items()}, **scalars}
+            {"class_name": self.names[i], **{k: round(v[i], decimals) for k, v in per_class.items()}, **scalars}
             for i in range(len(next(iter(per_class.values()), [])))
         ]
 
@@ -1443,9 +1484,23 @@ class ClassifyMetrics(SimpleClass, DataExportMixin):
         """Return a list of curves for accessing specific metrics curves."""
         return []
 
-    def summary(self, **kwargs) -> List[Dict[str, float]]:
-        """Return a single-row summary for classification metrics (top1/top5)."""
-        return [{"classify-top1": self.top1, "classify-top5": self.top5}]
+    def summary(self, normalize: bool = True, decimals: int = 5) -> List[Dict[str, float]]:
+        """
+        Generate a single-row summary of classification metrics (Top-1 and Top-5 accuracy).
+
+        Args:
+            normalize (bool): For Classify metrics, everything is normalized  by default [0-1].
+            decimals (int): Number of decimal places to round the metrics values to.
+
+        Returns:
+            (List[Dict[str, float]]): A list with one dictionary containing Top-1 and Top-5 classification accuracy.
+
+        Examples:
+            >>> results = model.val(data="imagenet10")
+            >>> classify_summary = results.summary(decimals=4)
+            >>> print(classify_summary)
+        """
+        return [{"classify-top1": round(self.top1, decimals), "classify-top5": round(self.top5, decimals)}]
 
 
 class OBBMetrics(SimpleClass, DataExportMixin):
@@ -1547,15 +1602,30 @@ class OBBMetrics(SimpleClass, DataExportMixin):
         """Return a list of curves for accessing specific metrics curves."""
         return []
 
-    def summary(self, **kwargs) -> List[Dict[str, Union[str, float]]]:
-        """Return per-class detection metrics with shared scalar values included."""
+    def summary(self, normalize: bool = True, decimals: int = 5) -> List[Dict[str, Union[str, float]]]:
+        """
+        Generate a summarized representation of per-class detection metrics as a list of dictionaries. Includes shared
+        scalar metrics (mAP, mAP50, mAP75) along with precision, recall, and F1-score for each class.
+
+        Args:
+            normalize (bool): For OBB metrics, everything is normalized  by default [0-1].
+            decimals (int): Number of decimal places to round the metrics values to.
+
+        Returns:
+            (List[Dict[str, Union[str, float]]]): A list of dictionaries, each representing one class with detection metrics.
+
+        Examples:
+            >>> results = model.val(data="dota8.yaml")
+            >>> detection_summary = results.summary(decimals=4)
+            >>> print(detection_summary)
+        """
         scalars = {
-            "box-map": self.box.map,
-            "box-map50": self.box.map50,
-            "box-map75": self.box.map75,
+            "box-map": round(self.box.map, decimals),
+            "box-map50": round(self.box.map50, decimals),
+            "box-map75": round(self.box.map75, decimals),
         }
         per_class = {"box-p": self.box.p, "box-r": self.box.r, "box-f1": self.box.f1}
         return [
-            {"class_name": self.names[i], **{k: v[i] for k, v in per_class.items()}, **scalars}
+            {"class_name": self.names[i], **{k: round(v[i], decimals) for k, v in per_class.items()}, **scalars}
             for i in range(len(next(iter(per_class.values()), [])))
         ]