dgenerate-ultralytics-headless 8.3.214__py3-none-any.whl → 8.3.248__py3-none-any.whl

ultralytics/utils/metrics.py

@@ -15,14 +15,16 @@ import torch
 from ultralytics.utils import LOGGER, DataExportMixin, SimpleClass, TryExcept, checks, plt_settings
 
 OKS_SIGMA = (
-    np.array([0.26, 0.25, 0.25, 0.35, 0.35, 0.79, 0.79, 0.72, 0.72, 0.62, 0.62, 1.07, 1.07, 0.87, 0.87, 0.89, 0.89])
+    np.array(
+        [0.26, 0.25, 0.25, 0.35, 0.35, 0.79, 0.79, 0.72, 0.72, 0.62, 0.62, 1.07, 1.07, 0.87, 0.87, 0.89, 0.89],
+        dtype=np.float32,
+    )
     / 10.0
 )
 
 
 def bbox_ioa(box1: np.ndarray, box2: np.ndarray, iou: bool = False, eps: float = 1e-7) -> np.ndarray:
-    """
-    Calculate the intersection over box2 area given box1 and box2.
+    """Calculate the intersection over box2 area given box1 and box2.
 
     Args:
         box1 (np.ndarray): A numpy array of shape (N, 4) representing N bounding boxes in x1y1x2y2 format.
@@ -53,8 +55,7 @@ def bbox_ioa(box1: np.ndarray, box2: np.ndarray, iou: bool = False, eps: float =
 
 
 def box_iou(box1: torch.Tensor, box2: torch.Tensor, eps: float = 1e-7) -> torch.Tensor:
-    """
-    Calculate intersection-over-union (IoU) of boxes.
+    """Calculate intersection-over-union (IoU) of boxes.
 
     Args:
         box1 (torch.Tensor): A tensor of shape (N, 4) representing N bounding boxes in (x1, y1, x2, y2) format.
@@ -85,19 +86,17 @@ def bbox_iou(
     CIoU: bool = False,
     eps: float = 1e-7,
 ) -> torch.Tensor:
-    """
-    Calculate the Intersection over Union (IoU) between bounding boxes.
+    """Calculate the Intersection over Union (IoU) between bounding boxes.
 
-    This function supports various shapes for `box1` and `box2` as long as the last dimension is 4.
-    For instance, you may pass tensors shaped like (4,), (N, 4), (B, N, 4), or (B, N, 1, 4).
-    Internally, the code will split the last dimension into (x, y, w, h) if `xywh=True`,
-    or (x1, y1, x2, y2) if `xywh=False`.
+    This function supports various shapes for `box1` and `box2` as long as the last dimension is 4. For instance, you
+    may pass tensors shaped like (4,), (N, 4), (B, N, 4), or (B, N, 1, 4). Internally, the code will split the last
+    dimension into (x, y, w, h) if `xywh=True`, or (x1, y1, x2, y2) if `xywh=False`.
 
     Args:
         box1 (torch.Tensor): A tensor representing one or more bounding boxes, with the last dimension being 4.
         box2 (torch.Tensor): A tensor representing one or more bounding boxes, with the last dimension being 4.
-        xywh (bool, optional): If True, input boxes are in (x, y, w, h) format. If False, input boxes are in
-                               (x1, y1, x2, y2) format.
+        xywh (bool, optional): If True, input boxes are in (x, y, w, h) format. If False, input boxes are in (x1, y1,
+            x2, y2) format.
         GIoU (bool, optional): If True, calculate Generalized IoU.
         DIoU (bool, optional): If True, calculate Distance IoU.
         CIoU (bool, optional): If True, calculate Complete IoU.
@@ -148,14 +147,13 @@ def bbox_iou(
 
 
 def mask_iou(mask1: torch.Tensor, mask2: torch.Tensor, eps: float = 1e-7) -> torch.Tensor:
-    """
-    Calculate masks IoU.
+    """Calculate masks IoU.
 
     Args:
         mask1 (torch.Tensor): A tensor of shape (N, n) where N is the number of ground truth objects and n is the
-                        product of image width and height.
-        mask2 (torch.Tensor): A tensor of shape (M, n) where M is the number of predicted objects and n is the
-                        product of image width and height.
+            product of image width and height.
+        mask2 (torch.Tensor): A tensor of shape (M, n) where M is the number of predicted objects and n is the product
+            of image width and height.
         eps (float, optional): A small value to avoid division by zero.
 
     Returns:
@@ -169,8 +167,7 @@ def mask_iou(mask1: torch.Tensor, mask2: torch.Tensor, eps: float = 1e-7) -> tor
 def kpt_iou(
     kpt1: torch.Tensor, kpt2: torch.Tensor, area: torch.Tensor, sigma: list[float], eps: float = 1e-7
 ) -> torch.Tensor:
-    """
-    Calculate Object Keypoint Similarity (OKS).
+    """Calculate Object Keypoint Similarity (OKS).
 
     Args:
         kpt1 (torch.Tensor): A tensor of shape (N, 17, 3) representing ground truth keypoints.
@@ -191,14 +188,14 @@ def kpt_iou(
 
 
 def _get_covariance_matrix(boxes: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-    """
-    Generate covariance matrix from oriented bounding boxes.
+    """Generate covariance matrix from oriented bounding boxes.
 
     Args:
         boxes (torch.Tensor): A tensor of shape (N, 5) representing rotated bounding boxes, with xywhr format.
 
     Returns:
-        (torch.Tensor): Covariance matrices corresponding to original rotated bounding boxes.
+        (tuple[torch.Tensor, torch.Tensor, torch.Tensor]): Covariance matrix components (a, b, c) where the covariance
+            matrix is [[a, c], [c, b]], each of shape (N, 1).
     """
     # Gaussian bounding boxes, ignore the center points (the first two columns) because they are not needed here.
     gbbs = torch.cat((boxes[:, 2:4].pow(2) / 12, boxes[:, 4:]), dim=-1)
@@ -211,8 +208,7 @@ def _get_covariance_matrix(boxes: torch.Tensor) -> tuple[torch.Tensor, torch.Ten
 
 
 def probiou(obb1: torch.Tensor, obb2: torch.Tensor, CIoU: bool = False, eps: float = 1e-7) -> torch.Tensor:
-    """
-    Calculate probabilistic IoU between oriented bounding boxes.
+    """Calculate probabilistic IoU between oriented bounding boxes.
 
     Args:
         obb1 (torch.Tensor): Ground truth OBBs, shape (N, 5), format xywhr.
@@ -257,8 +253,7 @@ def probiou(obb1: torch.Tensor, obb2: torch.Tensor, CIoU: bool = False, eps: flo
 
 
 def batch_probiou(obb1: torch.Tensor | np.ndarray, obb2: torch.Tensor | np.ndarray, eps: float = 1e-7) -> torch.Tensor:
-    """
-    Calculate the probabilistic IoU between oriented bounding boxes.
+    """Calculate the probabilistic IoU between oriented bounding boxes.
 
     Args:
         obb1 (torch.Tensor | np.ndarray): A tensor of shape (N, 5) representing ground truth obbs, with xywhr format.
@@ -294,8 +289,7 @@ def batch_probiou(obb1: torch.Tensor | np.ndarray, obb2: torch.Tensor | np.ndarr
 
 
 def smooth_bce(eps: float = 0.1) -> tuple[float, float]:
-    """
-    Compute smoothed positive and negative Binary Cross-Entropy targets.
+    """Compute smoothed positive and negative Binary Cross-Entropy targets.
 
     Args:
         eps (float, optional): The epsilon value for label smoothing.
@@ -311,20 +305,18 @@ def smooth_bce(eps: float = 0.1) -> tuple[float, float]:
 
 
 class ConfusionMatrix(DataExportMixin):
-    """
-    A class for calculating and updating a confusion matrix for object detection and classification tasks.
+    """A class for calculating and updating a confusion matrix for object detection and classification tasks.
 
     Attributes:
         task (str): The type of task, either 'detect' or 'classify'.
         matrix (np.ndarray): The confusion matrix, with dimensions depending on the task.
-        nc (int): The number of category.
+        nc (int): The number of classes.
         names (list[str]): The names of the classes, used as labels on the plot.
         matches (dict): Contains the indices of ground truths and predictions categorized into TP, FP and FN.
     """
 
     def __init__(self, names: dict[int, str] = [], task: str = "detect", save_matches: bool = False):
-        """
-        Initialize a ConfusionMatrix instance.
+        """Initialize a ConfusionMatrix instance.
 
         Args:
             names (dict[int, str], optional): Names of classes, used as labels on the plot.
@@ -338,21 +330,20 @@ class ConfusionMatrix(DataExportMixin):
         self.matches = {} if save_matches else None
 
     def _append_matches(self, mtype: str, batch: dict[str, Any], idx: int) -> None:
-        """
-        Append the matches to TP, FP, FN or GT list for the last batch.
+        """Append the matches to TP, FP, FN or GT list for the last batch.
 
-        This method updates the matches dictionary by appending specific batch data
-        to the appropriate match type (True Positive, False Positive, or False Negative).
+        This method updates the matches dictionary by appending specific batch data to the appropriate match type (True
+        Positive, False Positive, or False Negative).
 
         Args:
             mtype (str): Match type identifier ('TP', 'FP', 'FN' or 'GT').
-            batch (dict[str, Any]): Batch data containing detection results with keys
-                like 'bboxes', 'cls', 'conf', 'keypoints', 'masks'.
+            batch (dict[str, Any]): Batch data containing detection results with keys like 'bboxes', 'cls', 'conf',
+                'keypoints', 'masks'.
             idx (int): Index of the specific detection to append from the batch.
 
-        Note:
-            For masks, handles both overlap and non-overlap cases. When masks.max() > 1.0,
-            it indicates overlap_mask=True with shape (1, H, W), otherwise uses direct indexing.
+        Notes:
+            For masks, handles both overlap and non-overlap cases. When masks.max() > 1.0, it indicates
+            overlap_mask=True with shape (1, H, W), otherwise uses direct indexing.
         """
         if self.matches is None:
             return
@@ -364,8 +355,7 @@ class ConfusionMatrix(DataExportMixin):
                 self.matches[mtype][k] += [v[0] == idx + 1] if v.max() > 1.0 else [v[idx]]
 
     def process_cls_preds(self, preds: list[torch.Tensor], targets: list[torch.Tensor]) -> None:
-        """
-        Update confusion matrix for classification task.
+        """Update confusion matrix for classification task.
 
         Args:
             preds (list[N, min(nc,5)]): Predicted class labels.
@@ -382,15 +372,14 @@ class ConfusionMatrix(DataExportMixin):
         conf: float = 0.25,
         iou_thres: float = 0.45,
     ) -> None:
-        """
-        Update confusion matrix for object detection task.
+        """Update confusion matrix for object detection task.
 
         Args:
-            detections (dict[str, torch.Tensor]): Dictionary containing detected bounding boxes and their associated information.
-                                       Should contain 'cls', 'conf', and 'bboxes' keys, where 'bboxes' can be
-                                       Array[N, 4] for regular boxes or Array[N, 5] for OBB with angle.
-            batch (dict[str, Any]): Batch dictionary containing ground truth data with 'bboxes' (Array[M, 4]| Array[M, 5]) and
-                'cls' (Array[M]) keys, where M is the number of ground truth objects.
+            detections (dict[str, torch.Tensor]): Dictionary containing detected bounding boxes and their associated
+                information. Should contain 'cls', 'conf', and 'bboxes' keys, where 'bboxes' can be Array[N, 4] for
+                regular boxes or Array[N, 5] for OBB with angle.
+            batch (dict[str, Any]): Batch dictionary containing ground truth data with 'bboxes' (Array[M, 4]| Array[M,
+                5]) and 'cls' (Array[M]) keys, where M is the number of ground truth objects.
             conf (float, optional): Confidence threshold for detections.
             iou_thres (float, optional): IoU threshold for matching detections to ground truth.
         """
@@ -460,8 +449,7 @@ class ConfusionMatrix(DataExportMixin):
         return self.matrix
 
     def tp_fp(self) -> tuple[np.ndarray, np.ndarray]:
-        """
-        Return true positives and false positives.
+        """Return true positives and false positives.
 
         Returns:
             tp (np.ndarray): True positives.
@@ -473,8 +461,7 @@ class ConfusionMatrix(DataExportMixin):
         return (tp, fp) if self.task == "classify" else (tp[:-1], fp[:-1])  # remove background class if task=detect
 
     def plot_matches(self, img: torch.Tensor, im_file: str, save_dir: Path) -> None:
-        """
-        Plot grid of GT, TP, FP, FN for each image.
+        """Plot grid of GT, TP, FP, FN for each image.
 
         Args:
             img (torch.Tensor): Image to plot onto.
@@ -513,8 +500,7 @@ class ConfusionMatrix(DataExportMixin):
     @TryExcept(msg="ConfusionMatrix plot failure")
     @plt_settings()
     def plot(self, normalize: bool = True, save_dir: str = "", on_plot=None):
-        """
-        Plot the confusion matrix using matplotlib and save it to a file.
+        """Plot the confusion matrix using matplotlib and save it to a file.
 
         Args:
             normalize (bool, optional): Whether to normalize the confusion matrix.
@@ -535,7 +521,7 @@ class ConfusionMatrix(DataExportMixin):
             array = array[keep_idx, :][:, keep_idx]  # slice matrix rows and cols
             n = (self.nc + k - 1) // k  # number of retained classes
         nc = nn = n if self.task == "classify" else n + 1  # adjust for background if needed
-        ticklabels = (names + ["background"]) if (0 < nn < 99) and (nn == nc) else "auto"
+        ticklabels = ([*names, "background"]) if (0 < nn < 99) and (nn == nc) else "auto"
         xy_ticks = np.arange(len(ticklabels))
         tick_fontsize = max(6, 15 - 0.1 * nc)  # Minimum size is 6
         label_fontsize = max(6, 12 - 0.1 * nc)
@@ -582,7 +568,7 @@ class ConfusionMatrix(DataExportMixin):
         fig.savefig(plot_fname, dpi=250)
         plt.close(fig)
         if on_plot:
-            on_plot(plot_fname)
+            on_plot(plot_fname, {"type": "confusion_matrix", "matrix": self.matrix.tolist()})
 
     def print(self):
         """Print the confusion matrix to the console."""
@@ -590,16 +576,17 @@ class ConfusionMatrix(DataExportMixin):
             LOGGER.info(" ".join(map(str, self.matrix[i])))
 
     def summary(self, normalize: bool = False, decimals: int = 5) -> list[dict[str, float]]:
-        """
-        Generate a summarized representation of the confusion matrix as a list of dictionaries, with optional
-        normalization. This is useful for exporting the matrix to various formats such as CSV, XML, HTML, JSON, or SQL.
+        """Generate a summarized representation of the confusion matrix as a list of dictionaries, with optional
+        normalization. This is useful for exporting the matrix to various formats such as CSV, XML, HTML, JSON,
+        or SQL.
 
         Args:
             normalize (bool): Whether to normalize the confusion matrix values.
             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)
@@ -608,7 +595,7 @@ class ConfusionMatrix(DataExportMixin):
         """
         import re
 
-        names = list(self.names.values()) if self.task == "classify" else list(self.names.values()) + ["background"]
+        names = list(self.names.values()) if self.task == "classify" else [*list(self.names.values()), "background"]
         clean_names, seen = [], set()
         for name in names:
             clean_name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
@@ -643,8 +630,7 @@ def plot_pr_curve(
     names: dict[int, str] = {},
     on_plot=None,
 ):
-    """
-    Plot precision-recall curve.
+    """Plot precision-recall curve.
 
     Args:
         px (np.ndarray): X values for the PR curve.
@@ -663,7 +649,7 @@ def plot_pr_curve(
         for i, y in enumerate(py.T):
             ax.plot(px, y, linewidth=1, label=f"{names[i]} {ap[i, 0]:.3f}")  # plot(recall, precision)
     else:
-        ax.plot(px, py, linewidth=1, color="grey")  # plot(recall, precision)
+        ax.plot(px, py, linewidth=1, color="gray")  # plot(recall, precision)
 
     ax.plot(px, py.mean(1), linewidth=3, color="blue", label=f"all classes {ap[:, 0].mean():.3f} mAP@0.5")
     ax.set_xlabel("Recall")
@@ -675,7 +661,9 @@ def plot_pr_curve(
     fig.savefig(save_dir, dpi=250)
     plt.close(fig)
     if on_plot:
-        on_plot(save_dir)
+        # Pass PR curve data for interactive plotting (class names stored at model level)
+        # Transpose py to match other curves: y[class][point] format
+        on_plot(save_dir, {"type": "pr_curve", "x": px.tolist(), "y": py.T.tolist(), "ap": ap.tolist()})
 
 
 @plt_settings()
@@ -688,8 +676,7 @@ def plot_mc_curve(
     ylabel: str = "Metric",
     on_plot=None,
 ):
-    """
-    Plot metric-confidence curve.
+    """Plot metric-confidence curve.
 
     Args:
         px (np.ndarray): X values for the metric-confidence curve.
@@ -708,7 +695,7 @@ def plot_mc_curve(
         for i, y in enumerate(py):
             ax.plot(px, y, linewidth=1, label=f"{names[i]}")  # plot(confidence, metric)
     else:
-        ax.plot(px, py.T, linewidth=1, color="grey")  # plot(confidence, metric)
+        ax.plot(px, py.T, linewidth=1, color="gray")  # plot(confidence, metric)
 
     y = smooth(py.mean(0), 0.1)
     ax.plot(px, y, linewidth=3, color="blue", label=f"all classes {y.max():.2f} at {px[y.argmax()]:.3f}")
@@ -721,12 +708,12 @@ def plot_mc_curve(
     fig.savefig(save_dir, dpi=250)
     plt.close(fig)
     if on_plot:
-        on_plot(save_dir)
+        # Pass metric-confidence curve data for interactive plotting (class names stored at model level)
+        on_plot(save_dir, {"type": f"{ylabel.lower()}_curve", "x": px.tolist(), "y": py.tolist()})
 
 
 def compute_ap(recall: list[float], precision: list[float]) -> tuple[float, np.ndarray, np.ndarray]:
-    """
-    Compute the average precision (AP) given the recall and precision curves.
+    """Compute the average precision (AP) given the recall and precision curves.
 
     Args:
         recall (list): The recall curve.
@@ -769,8 +756,7 @@ def ap_per_class(
     eps: float = 1e-16,
     prefix: str = "",
 ) -> tuple:
-    """
-    Compute the average precision per class for object detection evaluation.
+    """Compute the average precision per class for object detection evaluation.
 
     Args:
         tp (np.ndarray): Binary array indicating whether the detection is correct (True) or not (False).
@@ -855,8 +841,7 @@ def ap_per_class(
 
 
 class Metric(SimpleClass):
-    """
-    Class for computing evaluation metrics for Ultralytics YOLO models.
+    """Class for computing evaluation metrics for Ultralytics YOLO models.
 
     Attributes:
         p (list): Precision for each class. Shape: (nc,).
@@ -894,8 +879,7 @@ class Metric(SimpleClass):
 
     @property
     def ap50(self) -> np.ndarray | list:
-        """
-        Return the Average Precision (AP) at an IoU threshold of 0.5 for all classes.
+        """Return the Average Precision (AP) at an IoU threshold of 0.5 for all classes.
 
         Returns:
             (np.ndarray | list): Array of shape (nc,) with AP50 values per class, or an empty list if not available.
@@ -904,8 +888,7 @@ class Metric(SimpleClass):
 
     @property
     def ap(self) -> np.ndarray | list:
-        """
-        Return the Average Precision (AP) at an IoU threshold of 0.5-0.95 for all classes.
+        """Return the Average Precision (AP) at an IoU threshold of 0.5-0.95 for all classes.
 
         Returns:
             (np.ndarray | list): Array of shape (nc,) with AP50-95 values per class, or an empty list if not available.
@@ -914,8 +897,7 @@ class Metric(SimpleClass):
 
     @property
     def mp(self) -> float:
-        """
-        Return the Mean Precision of all classes.
+        """Return the Mean Precision of all classes.
 
         Returns:
             (float): The mean precision of all classes.
@@ -924,8 +906,7 @@ class Metric(SimpleClass):
 
     @property
     def mr(self) -> float:
-        """
-        Return the Mean Recall of all classes.
+        """Return the Mean Recall of all classes.
 
         Returns:
             (float): The mean recall of all classes.
@@ -934,8 +915,7 @@ class Metric(SimpleClass):
 
     @property
     def map50(self) -> float:
-        """
-        Return the mean Average Precision (mAP) at an IoU threshold of 0.5.
+        """Return the mean Average Precision (mAP) at an IoU threshold of 0.5.
 
         Returns:
             (float): The mAP at an IoU threshold of 0.5.
@@ -944,8 +924,7 @@ class Metric(SimpleClass):
 
     @property
     def map75(self) -> float:
-        """
-        Return the mean Average Precision (mAP) at an IoU threshold of 0.75.
+        """Return the mean Average Precision (mAP) at an IoU threshold of 0.75.
 
         Returns:
             (float): The mAP at an IoU threshold of 0.75.
@@ -954,8 +933,7 @@ class Metric(SimpleClass):
 
     @property
     def map(self) -> float:
-        """
-        Return the mean Average Precision (mAP) over IoU thresholds of 0.5 - 0.95 in steps of 0.05.
+        """Return the mean Average Precision (mAP) over IoU thresholds of 0.5 - 0.95 in steps of 0.05.
 
         Returns:
             (float): The mAP over IoU thresholds of 0.5 - 0.95 in steps of 0.05.
@@ -984,8 +962,7 @@ class Metric(SimpleClass):
         return (np.nan_to_num(np.array(self.mean_results())) * w).sum()
 
     def update(self, results: tuple):
-        """
-        Update the evaluation metrics with a new set of results.
+        """Update the evaluation metrics with a new set of results.
 
         Args:
             results (tuple): A tuple containing evaluation metrics:
@@ -1030,15 +1007,15 @@ class Metric(SimpleClass):
 
 
 class DetMetrics(SimpleClass, DataExportMixin):
-    """
-    Utility class for computing detection metrics such as precision, recall, and mean average precision (mAP).
+    """Utility class for computing detection metrics such as precision, recall, and mean average precision (mAP).
 
     Attributes:
         names (dict[int, str]): A dictionary of class names.
         box (Metric): An instance of the Metric class for storing detection results.
         speed (dict[str, float]): A dictionary for storing execution times of different parts of the detection process.
         task (str): The task type, set to 'detect'.
-        stats (dict[str, list]): A dictionary containing lists for true positives, confidence scores, predicted classes, target classes, and target images.
+        stats (dict[str, list]): A dictionary containing lists for true positives, confidence scores, predicted classes,
+            target classes, and target images.
         nt_per_class: Number of targets per class.
         nt_per_image: Number of targets per image.
 
@@ -1059,8 +1036,7 @@ class DetMetrics(SimpleClass, DataExportMixin):
     """
 
     def __init__(self, names: dict[int, str] = {}) -> None:
-        """
-        Initialize a DetMetrics instance with a save directory, plot flag, and class names.
+        """Initialize a DetMetrics instance with a save directory, plot flag, and class names.
 
         Args:
             names (dict[int, str], optional): Dictionary of class names.
@@ -1074,19 +1050,17 @@ class DetMetrics(SimpleClass, DataExportMixin):
         self.nt_per_image = None
 
     def update_stats(self, stat: dict[str, Any]) -> None:
-        """
-        Update statistics by appending new values to existing stat collections.
+        """Update statistics by appending new values to existing stat collections.
 
         Args:
-            stat (dict[str, any]): Dictionary containing new statistical values to append.
-                         Keys should match existing keys in self.stats.
+            stat (dict[str, any]): Dictionary containing new statistical values to append. Keys should match existing
+                keys in self.stats.
         """
         for k in self.stats.keys():
             self.stats[k].append(stat[k])
 
     def process(self, save_dir: Path = Path("."), plot: bool = False, on_plot=None) -> dict[str, np.ndarray]:
-        """
-        Process predicted results for object detection and update metrics.
+        """Process predicted results for object detection and update metrics.
 
         Args:
             save_dir (Path): Directory to save plots. Defaults to Path(".").
@@ -1152,8 +1126,8 @@ class DetMetrics(SimpleClass, DataExportMixin):
     @property
     def results_dict(self) -> dict[str, float]:
         """Return dictionary of computed performance metrics and statistics."""
-        keys = self.keys + ["fitness"]
-        values = ((float(x) if hasattr(x, "item") else x) for x in (self.mean_results() + [self.fitness]))
+        keys = [*self.keys, "fitness"]
+        values = ((float(x) if hasattr(x, "item") else x) for x in ([*self.mean_results(), self.fitness]))
         return dict(zip(keys, values))
 
     @property
@@ -1167,16 +1141,16 @@ class DetMetrics(SimpleClass, DataExportMixin):
         return self.box.curves_results
 
     def summary(self, normalize: bool = True, decimals: int = 5) -> list[dict[str, Any]]:
-        """
-        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.
+        """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.
+            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, Any]]): A list of dictionaries, each representing one class with corresponding metric values.
+            (list[dict[str, Any]]): A list of dictionaries, each representing one class with corresponding metric
+                values.
 
         Examples:
            >>> results = model.val(data="coco8.yaml")
@@ -1202,8 +1176,7 @@ class DetMetrics(SimpleClass, DataExportMixin):
 
 
 class SegmentMetrics(DetMetrics):
-    """
-    Calculate and aggregate detection and segmentation metrics over a given set of classes.
+    """Calculate and aggregate detection and segmentation metrics over a given set of classes.
 
     Attributes:
         names (dict[int, str]): Dictionary of class names.
@@ -1211,7 +1184,8 @@ class SegmentMetrics(DetMetrics):
         seg (Metric): An instance of the Metric class to calculate mask segmentation metrics.
         speed (dict[str, float]): A dictionary for storing execution times of different parts of the detection process.
         task (str): The task type, set to 'segment'.
-        stats (dict[str, list]): A dictionary containing lists for true positives, confidence scores, predicted classes, target classes, and target images.
+        stats (dict[str, list]): A dictionary containing lists for true positives, confidence scores, predicted classes,
+            target classes, and target images.
         nt_per_class: Number of targets per class.
         nt_per_image: Number of targets per image.
 
@@ -1228,8 +1202,7 @@ class SegmentMetrics(DetMetrics):
     """
 
     def __init__(self, names: dict[int, str] = {}) -> None:
-        """
-        Initialize a SegmentMetrics instance with a save directory, plot flag, and class names.
+        """Initialize a SegmentMetrics instance with a save directory, plot flag, and class names.
 
         Args:
             names (dict[int, str], optional): Dictionary of class names.
@@ -1240,8 +1213,7 @@ class SegmentMetrics(DetMetrics):
         self.stats["tp_m"] = []  # add additional stats for masks
 
     def process(self, save_dir: Path = Path("."), plot: bool = False, on_plot=None) -> dict[str, np.ndarray]:
-        """
-        Process the detection and segmentation metrics over the given set of predictions.
+        """Process the detection and segmentation metrics over the given set of predictions.
 
         Args:
             save_dir (Path): Directory to save plots. Defaults to Path(".").
@@ -1270,7 +1242,8 @@ class SegmentMetrics(DetMetrics):
     @property
     def keys(self) -> list[str]:
         """Return a list of keys for accessing metrics."""
-        return DetMetrics.keys.fget(self) + [
+        return [
+            *DetMetrics.keys.fget(self),
             "metrics/precision(M)",
             "metrics/recall(M)",
             "metrics/mAP50(M)",
@@ -1298,7 +1271,8 @@ class SegmentMetrics(DetMetrics):
     @property
     def curves(self) -> list[str]:
         """Return a list of curves for accessing specific metrics curves."""
-        return DetMetrics.curves.fget(self) + [
+        return [
+            *DetMetrics.curves.fget(self),
             "Precision-Recall(M)",
             "F1-Confidence(M)",
             "Precision-Confidence(M)",
@@ -1311,16 +1285,17 @@ class SegmentMetrics(DetMetrics):
         return DetMetrics.curves_results.fget(self) + self.seg.curves_results
 
     def summary(self, normalize: bool = True, decimals: int = 5) -> list[dict[str, Any]]:
-        """
-        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.
+        """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].
+            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, Any]]): A list of dictionaries, each representing one class with corresponding metric values.
+            (list[dict[str, Any]]): A list of dictionaries, each representing one class with corresponding metric
+                values.
 
         Examples:
             >>> results = model.val(data="coco8-seg.yaml")
@@ -1339,8 +1314,7 @@ class SegmentMetrics(DetMetrics):
 
 
 class PoseMetrics(DetMetrics):
-    """
-    Calculate and aggregate detection and pose metrics over a given set of classes.
+    """Calculate and aggregate detection and pose metrics over a given set of classes.
 
     Attributes:
         names (dict[int, str]): Dictionary of class names.
@@ -1348,7 +1322,8 @@ class PoseMetrics(DetMetrics):
         box (Metric): An instance of the Metric class for storing detection results.
         speed (dict[str, float]): A dictionary for storing execution times of different parts of the detection process.
         task (str): The task type, set to 'pose'.
-        stats (dict[str, list]): A dictionary containing lists for true positives, confidence scores, predicted classes, target classes, and target images.
+        stats (dict[str, list]): A dictionary containing lists for true positives, confidence scores, predicted classes,
+            target classes, and target images.
         nt_per_class: Number of targets per class.
         nt_per_image: Number of targets per image.
 
@@ -1365,8 +1340,7 @@ class PoseMetrics(DetMetrics):
     """
 
     def __init__(self, names: dict[int, str] = {}) -> None:
-        """
-        Initialize the PoseMetrics class with directory path, class names, and plotting options.
+        """Initialize the PoseMetrics class with directory path, class names, and plotting options.
 
         Args:
             names (dict[int, str], optional): Dictionary of class names.
@@ -1377,8 +1351,7 @@ class PoseMetrics(DetMetrics):
         self.stats["tp_p"] = []  # add additional stats for pose
 
     def process(self, save_dir: Path = Path("."), plot: bool = False, on_plot=None) -> dict[str, np.ndarray]:
-        """
-        Process the detection and pose metrics over the given set of predictions.
+        """Process the detection and pose metrics over the given set of predictions.
 
         Args:
             save_dir (Path): Directory to save plots. Defaults to Path(".").
@@ -1407,7 +1380,8 @@ class PoseMetrics(DetMetrics):
     @property
     def keys(self) -> list[str]:
         """Return a list of evaluation metric keys."""
-        return DetMetrics.keys.fget(self) + [
+        return [
+            *DetMetrics.keys.fget(self),
             "metrics/precision(P)",
             "metrics/recall(P)",
             "metrics/mAP50(P)",
@@ -1435,7 +1409,8 @@ class PoseMetrics(DetMetrics):
     @property
     def curves(self) -> list[str]:
         """Return a list of curves for accessing specific metrics curves."""
-        return DetMetrics.curves.fget(self) + [
+        return [
+            *DetMetrics.curves.fget(self),
             "Precision-Recall(B)",
             "F1-Confidence(B)",
             "Precision-Confidence(B)",
@@ -1452,16 +1427,16 @@ class PoseMetrics(DetMetrics):
         return DetMetrics.curves_results.fget(self) + self.pose.curves_results
 
     def summary(self, normalize: bool = True, decimals: int = 5) -> list[dict[str, Any]]:
-        """
-        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.
+        """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].
+            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, Any]]): A list of dictionaries, each representing one class with corresponding metric values.
+            (list[dict[str, Any]]): A list of dictionaries, each representing one class with corresponding metric
+                values.
 
         Examples:
             >>> results = model.val(data="coco8-pose.yaml")
@@ -1480,8 +1455,7 @@ class PoseMetrics(DetMetrics):
 
 
 class ClassifyMetrics(SimpleClass, DataExportMixin):
-    """
-    Class for computing classification metrics including top-1 and top-5 accuracy.
+    """Class for computing classification metrics including top-1 and top-5 accuracy.
 
     Attributes:
         top1 (float): The top-1 accuracy.
@@ -1507,8 +1481,7 @@ class ClassifyMetrics(SimpleClass, DataExportMixin):
         self.task = "classify"
 
     def process(self, targets: torch.Tensor, pred: torch.Tensor):
-        """
-        Process target classes and predicted classes to compute metrics.
+        """Process target classes and predicted classes to compute metrics.
 
         Args:
             targets (torch.Tensor): Target classes.
@@ -1527,7 +1500,7 @@ class ClassifyMetrics(SimpleClass, DataExportMixin):
     @property
     def results_dict(self) -> dict[str, float]:
         """Return a dictionary with model's performance metrics and fitness score."""
-        return dict(zip(self.keys + ["fitness"], [self.top1, self.top5, self.fitness]))
+        return dict(zip([*self.keys, "fitness"], [self.top1, self.top5, self.fitness]))
 
     @property
     def keys(self) -> list[str]:
@@ -1545,11 +1518,10 @@ class ClassifyMetrics(SimpleClass, DataExportMixin):
         return []
 
     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).
+        """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].
+            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:
@@ -1564,15 +1536,15 @@ class ClassifyMetrics(SimpleClass, DataExportMixin):
 
 
 class OBBMetrics(DetMetrics):
-    """
-    Metrics for evaluating oriented bounding box (OBB) detection.
+    """Metrics for evaluating oriented bounding box (OBB) detection.
 
     Attributes:
         names (dict[int, str]): Dictionary of class names.
         box (Metric): An instance of the Metric class for storing detection results.
         speed (dict[str, float]): A dictionary for storing execution times of different parts of the detection process.
         task (str): The task type, set to 'obb'.
-        stats (dict[str, list]): A dictionary containing lists for true positives, confidence scores, predicted classes, target classes, and target images.
+        stats (dict[str, list]): A dictionary containing lists for true positives, confidence scores, predicted classes,
+            target classes, and target images.
         nt_per_class: Number of targets per class.
         nt_per_image: Number of targets per image.
 
@@ -1581,8 +1553,7 @@ class OBBMetrics(DetMetrics):
     """
 
     def __init__(self, names: dict[int, str] = {}) -> None:
-        """
-        Initialize an OBBMetrics instance with directory, plotting, and class names.
+        """Initialize an OBBMetrics instance with directory, plotting, and class names.
 
         Args:
             names (dict[int, str], optional): Dictionary of class names.