ultralytics 8.3.89__py3-none-any.whl → 8.3.91__py3-none-any.whl

ultralytics/utils/metrics.py

@@ -25,7 +25,7 @@ def bbox_ioa(box1, box2, iou=False, eps=1e-7):
         box1 (np.ndarray): A numpy array of shape (n, 4) representing n bounding boxes.
         box2 (np.ndarray): A numpy array of shape (m, 4) representing m bounding boxes.
         iou (bool): Calculate the standard IoU if True else return inter_area/box2_area.
-        eps (float, optional): A small value to avoid division by zero. Defaults to 1e-7.
+        eps (float, optional): A small value to avoid division by zero.
 
     Returns:
         (np.ndarray): A numpy array of shape (n, m) representing the intersection over box2 area.
@@ -57,7 +57,7 @@ def box_iou(box1, box2, eps=1e-7):
     Args:
         box1 (torch.Tensor): A tensor of shape (N, 4) representing N bounding boxes.
         box2 (torch.Tensor): A tensor of shape (M, 4) representing M bounding boxes.
-        eps (float, optional): A small value to avoid division by zero. Defaults to 1e-7.
+        eps (float, optional): A small value to avoid division by zero.
 
     Returns:
         (torch.Tensor): An NxM tensor containing the pairwise IoU values for every element in box1 and box2.
@@ -73,7 +73,7 @@ def box_iou(box1, box2, eps=1e-7):
 
 def bbox_iou(box1, box2, xywh=True, GIoU=False, DIoU=False, CIoU=False, eps=1e-7):
     """
-    Calculates 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).
@@ -84,11 +84,11 @@ def bbox_iou(box1, box2, xywh=True, GIoU=False, DIoU=False, CIoU=False, eps=1e-7
         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. Defaults to True.
-        GIoU (bool, optional): If True, calculate Generalized IoU. Defaults to False.
-        DIoU (bool, optional): If True, calculate Distance IoU. Defaults to False.
-        CIoU (bool, optional): If True, calculate Complete IoU. Defaults to False.
-        eps (float, optional): A small value to avoid division by zero. Defaults to 1e-7.
+                               (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.
+        eps (float, optional): A small value to avoid division by zero.
 
     Returns:
         (torch.Tensor): IoU, GIoU, DIoU, or CIoU values depending on the specified flags.
@@ -143,7 +143,7 @@ def mask_iou(mask1, mask2, eps=1e-7):
                         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. Defaults to 1e-7.
+        eps (float, optional): A small value to avoid division by zero.
 
     Returns:
         (torch.Tensor): A tensor of shape (N, M) representing masks IoU.
@@ -162,7 +162,7 @@ def kpt_iou(kpt1, kpt2, area, sigma, eps=1e-7):
         kpt2 (torch.Tensor): A tensor of shape (M, 17, 3) representing predicted keypoints.
         area (torch.Tensor): A tensor of shape (N,) representing areas from ground truth.
         sigma (list): A list containing 17 values representing keypoint scales.
-        eps (float, optional): A small value to avoid division by zero. Defaults to 1e-7.
+        eps (float, optional): A small value to avoid division by zero.
 
     Returns:
         (torch.Tensor): A tensor of shape (N, M) representing keypoint similarities.
@@ -177,7 +177,7 @@ def kpt_iou(kpt1, kpt2, area, sigma, eps=1e-7):
 
 def _get_covariance_matrix(boxes):
     """
-    Generating covariance matrix from obbs.
+    Generate covariance matrix from oriented bounding boxes.
 
     Args:
         boxes (torch.Tensor): A tensor of shape (N, 5) representing rotated bounding boxes, with xywhr format.
@@ -199,20 +199,18 @@ def probiou(obb1, obb2, CIoU=False, eps=1e-7):
     """
     Calculate probabilistic IoU between oriented bounding boxes.
 
-    Implements the algorithm from https://arxiv.org/pdf/2106.06072v1.pdf.
-
     Args:
         obb1 (torch.Tensor): Ground truth OBBs, shape (N, 5), format xywhr.
         obb2 (torch.Tensor): Predicted OBBs, shape (N, 5), format xywhr.
-        CIoU (bool, optional): If True, calculate CIoU. Defaults to False.
-        eps (float, optional): Small value to avoid division by zero. Defaults to 1e-7.
+        CIoU (bool, optional): If True, calculate CIoU.
+        eps (float, optional): Small value to avoid division by zero.
 
     Returns:
         (torch.Tensor): OBB similarities, shape (N,).
 
-    Note:
-        OBB format: [center_x, center_y, width, height, rotation_angle].
-        If CIoU is True, returns CIoU instead of IoU.
+    Notes:
+        - OBB format: [center_x, center_y, width, height, rotation_angle].
+        - Implements the algorithm from https://arxiv.org/pdf/2106.06072v1.pdf.
     """
     x1, y1 = obb1[..., :2].split(1, dim=-1)
     x2, y2 = obb2[..., :2].split(1, dim=-1)
@@ -243,15 +241,18 @@ def probiou(obb1, obb2, CIoU=False, eps=1e-7):
 
 def batch_probiou(obb1, obb2, eps=1e-7):
     """
-    Calculate the prob IoU between oriented bounding boxes, https://arxiv.org/pdf/2106.06072v1.pdf.
+    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.
         obb2 (torch.Tensor | np.ndarray): A tensor of shape (M, 5) representing predicted obbs, with xywhr format.
-        eps (float, optional): A small value to avoid division by zero. Defaults to 1e-7.
+        eps (float, optional): A small value to avoid division by zero.
 
     Returns:
         (torch.Tensor): A tensor of shape (N, M) representing obb similarities.
+
+    References:
+        https://arxiv.org/pdf/2106.06072v1.pdf
     """
     obb1 = torch.from_numpy(obb1) if isinstance(obb1, np.ndarray) else obb1
     obb2 = torch.from_numpy(obb2) if isinstance(obb2, np.ndarray) else obb2
@@ -277,16 +278,16 @@ def batch_probiou(obb1, obb2, eps=1e-7):
 
 def smooth_bce(eps=0.1):
     """
-    Computes smoothed positive and negative Binary Cross-Entropy targets.
-
-    This function calculates positive and negative label smoothing BCE targets based on a given epsilon value.
-    For implementation details, refer to https://github.com/ultralytics/yolov3/issues/238#issuecomment-598028441.
+    Compute smoothed positive and negative Binary Cross-Entropy targets.
 
     Args:
-        eps (float, optional): The epsilon value for label smoothing. Defaults to 0.1.
+        eps (float, optional): The epsilon value for label smoothing.
 
     Returns:
         (tuple): A tuple containing the positive and negative label smoothing BCE targets.
+
+    References:
+        https://github.com/ultralytics/yolov3/issues/238#issuecomment-598028441
     """
     return 1.0 - 0.5 * eps, 0.5 * eps
 
@@ -304,7 +305,15 @@ class ConfusionMatrix:
     """
 
     def __init__(self, nc, conf=0.25, iou_thres=0.45, task="detect"):
-        """Initialize attributes for the YOLO model."""
+        """
+        Initialize a ConfusionMatrix instance.
+
+        Args:
+            nc (int): Number of classes.
+            conf (float, optional): Confidence threshold for detections.
+            iou_thres (float, optional): IoU threshold for matching detections to ground truth.
+            task (str, optional): Type of task, either 'detect' or 'classify'.
+        """
         self.task = task
         self.matrix = np.zeros((nc + 1, nc + 1)) if self.task == "detect" else np.zeros((nc, nc))
         self.nc = nc  # number of classes
@@ -382,11 +391,16 @@ class ConfusionMatrix:
                 self.matrix[dc, self.nc] += 1  # predicted background
 
     def matrix(self):
-        """Returns the confusion matrix."""
+        """Return the confusion matrix."""
         return self.matrix
 
     def tp_fp(self):
-        """Returns true positives and false positives."""
+        """
+        Return true positives and false positives.
+
+        Returns:
+            (tuple): True positives and false positives.
+        """
         tp = self.matrix.diagonal()  # true positives
         fp = self.matrix.sum(1) - tp  # false positives
         # fn = self.matrix.sum(0) - tp  # false negatives (missed detections)
@@ -454,7 +468,17 @@ def smooth(y, f=0.05):
 
 @plt_settings()
 def plot_pr_curve(px, py, ap, save_dir=Path("pr_curve.png"), names={}, on_plot=None):
-    """Plots a precision-recall curve."""
+    """
+    Plot precision-recall curve.
+
+    Args:
+        px (np.ndarray): X values for the PR curve.
+        py (np.ndarray): Y values for the PR curve.
+        ap (np.ndarray): Average precision values.
+        save_dir (Path, optional): Path to save the plot.
+        names (dict, optional): Dictionary mapping class indices to class names.
+        on_plot (callable, optional): Function to call after plot is saved.
+    """
     fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
     py = np.stack(py, axis=1)
 
@@ -479,7 +503,18 @@ def plot_pr_curve(px, py, ap, save_dir=Path("pr_curve.png"), names={}, on_plot=N
 
 @plt_settings()
 def plot_mc_curve(px, py, save_dir=Path("mc_curve.png"), names={}, xlabel="Confidence", ylabel="Metric", on_plot=None):
-    """Plots a metric-confidence curve."""
+    """
+    Plot metric-confidence curve.
+
+    Args:
+        px (np.ndarray): X values for the metric-confidence curve.
+        py (np.ndarray): Y values for the metric-confidence curve.
+        save_dir (Path, optional): Path to save the plot.
+        names (dict, optional): Dictionary mapping class indices to class names.
+        xlabel (str, optional): X-axis label.
+        ylabel (str, optional): Y-axis label.
+        on_plot (callable, optional): Function to call after plot is saved.
+    """
     fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
 
     if 0 < len(names) < 21:  # display per-class legend if < 21 classes
@@ -538,33 +573,33 @@ def ap_per_class(
     tp, conf, pred_cls, target_cls, plot=False, on_plot=None, save_dir=Path(), names={}, eps=1e-16, prefix=""
 ):
     """
-    Computes 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).
         conf (np.ndarray): Array of confidence scores of the detections.
         pred_cls (np.ndarray): Array of predicted classes of the detections.
         target_cls (np.ndarray): Array of true classes of the detections.
-        plot (bool, optional): Whether to plot PR curves or not. Defaults to False.
-        on_plot (func, optional): A callback to pass plots path and data when they are rendered. Defaults to None.
-        save_dir (Path, optional): Directory to save the PR curves. Defaults to an empty path.
-        names (dict, optional): Dict of class names to plot PR curves. Defaults to an empty tuple.
-        eps (float, optional): A small value to avoid division by zero. Defaults to 1e-16.
-        prefix (str, optional): A prefix string for saving the plot files. Defaults to an empty string.
+        plot (bool, optional): Whether to plot PR curves or not.
+        on_plot (func, optional): A callback to pass plots path and data when they are rendered.
+        save_dir (Path, optional): Directory to save the PR curves.
+        names (dict, optional): Dict of class names to plot PR curves.
+        eps (float, optional): A small value to avoid division by zero.
+        prefix (str, optional): A prefix string for saving the plot files.
 
     Returns:
-        tp (np.ndarray): True positive counts at threshold given by max F1 metric for each class.Shape: (nc,).
-        fp (np.ndarray): False positive counts at threshold given by max F1 metric for each class. Shape: (nc,).
-        p (np.ndarray): Precision values at threshold given by max F1 metric for each class. Shape: (nc,).
-        r (np.ndarray): Recall values at threshold given by max F1 metric for each class. Shape: (nc,).
-        f1 (np.ndarray): F1-score values at threshold given by max F1 metric for each class. Shape: (nc,).
-        ap (np.ndarray): Average precision for each class at different IoU thresholds. Shape: (nc, 10).
-        unique_classes (np.ndarray): An array of unique classes that have data. Shape: (nc,).
-        p_curve (np.ndarray): Precision curves for each class. Shape: (nc, 1000).
-        r_curve (np.ndarray): Recall curves for each class. Shape: (nc, 1000).
-        f1_curve (np.ndarray): F1-score curves for each class. Shape: (nc, 1000).
-        x (np.ndarray): X-axis values for the curves. Shape: (1000,).
-        prec_values (np.ndarray): Precision values at mAP@0.5 for each class. Shape: (nc, 1000).
+        tp (np.ndarray): True positive counts at threshold given by max F1 metric for each class.
+        fp (np.ndarray): False positive counts at threshold given by max F1 metric for each class.
+        p (np.ndarray): Precision values at threshold given by max F1 metric for each class.
+        r (np.ndarray): Recall values at threshold given by max F1 metric for each class.
+        f1 (np.ndarray): F1-score values at threshold given by max F1 metric for each class.
+        ap (np.ndarray): Average precision for each class at different IoU thresholds.
+        unique_classes (np.ndarray): An array of unique classes that have data.
+        p_curve (np.ndarray): Precision curves for each class.
+        r_curve (np.ndarray): Recall curves for each class.
+        f1_curve (np.ndarray): F1-score curves for each class.
+        x (np.ndarray): X-axis values for the curves.
+        prec_values (np.ndarray): Precision values at mAP@0.5 for each class.
     """
     # Sort by objectness
     i = np.argsort(-conf)
@@ -651,7 +686,7 @@ class Metric(SimpleClass):
     """
 
     def __init__(self) -> None:
-        """Initializes a Metric instance for computing evaluation metrics for the YOLOv8 model."""
+        """Initialize a Metric instance for computing evaluation metrics for the YOLOv8 model."""
         self.p = []  # (nc, )
         self.r = []  # (nc, )
         self.f1 = []  # (nc, )
@@ -662,7 +697,7 @@ class Metric(SimpleClass):
     @property
     def ap50(self):
         """
-        Returns 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.
@@ -672,7 +707,7 @@ class Metric(SimpleClass):
     @property
     def ap(self):
         """
-        Returns 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.
@@ -682,7 +717,7 @@ class Metric(SimpleClass):
     @property
     def mp(self):
         """
-        Returns the Mean Precision of all classes.
+        Return the Mean Precision of all classes.
 
         Returns:
             (float): The mean precision of all classes.
@@ -692,7 +727,7 @@ class Metric(SimpleClass):
     @property
     def mr(self):
         """
-        Returns the Mean Recall of all classes.
+        Return the Mean Recall of all classes.
 
         Returns:
             (float): The mean recall of all classes.
@@ -702,7 +737,7 @@ class Metric(SimpleClass):
     @property
     def map50(self):
         """
-        Returns 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.
@@ -712,7 +747,7 @@ class Metric(SimpleClass):
     @property
     def map75(self):
         """
-        Returns 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.
@@ -722,7 +757,7 @@ class Metric(SimpleClass):
     @property
     def map(self):
         """
-        Returns 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.
@@ -730,41 +765,42 @@ class Metric(SimpleClass):
         return self.all_ap.mean() if len(self.all_ap) else 0.0
 
     def mean_results(self):
-        """Mean of results, return mp, mr, map50, map."""
+        """Return mean of results, mp, mr, map50, map."""
         return [self.mp, self.mr, self.map50, self.map]
 
     def class_result(self, i):
-        """Class-aware result, return p[i], r[i], ap50[i], ap[i]."""
+        """Return class-aware result, p[i], r[i], ap50[i], ap[i]."""
         return self.p[i], self.r[i], self.ap50[i], self.ap[i]
 
     @property
     def maps(self):
-        """MAP of each class."""
+        """Return mAP of each class."""
         maps = np.zeros(self.nc) + self.map
         for i, c in enumerate(self.ap_class_index):
             maps[c] = self.ap[i]
         return maps
 
     def fitness(self):
-        """Model fitness as a weighted combination of metrics."""
+        """Return model fitness as a weighted combination of metrics."""
         w = [0.0, 0.0, 0.1, 0.9]  # weights for [P, R, mAP@0.5, mAP@0.5:0.95]
         return (np.array(self.mean_results()) * w).sum()
 
     def update(self, results):
         """
-        Updates the evaluation metrics of the model with a new set of results.
+        Update the evaluation metrics with a new set of results.
 
         Args:
-            results (tuple): A tuple containing the following evaluation metrics:
-                - p (list): Precision for each class. Shape: (nc,).
-                - r (list): Recall for each class. Shape: (nc,).
-                - f1 (list): F1 score for each class. Shape: (nc,).
-                - all_ap (list): AP scores for all classes and all IoU thresholds. Shape: (nc, 10).
-                - ap_class_index (list): Index of class for each AP score. Shape: (nc,).
-
-        Side Effects:
-            Updates the class attributes `self.p`, `self.r`, `self.f1`, `self.all_ap`, and `self.ap_class_index` based
-            on the values provided in the `results` tuple.
+            results (tuple): A tuple containing evaluation metrics:
+                - p (list): Precision for each class.
+                - r (list): Recall for each class.
+                - f1 (list): F1 score for each class.
+                - all_ap (list): AP scores for all classes and all IoU thresholds.
+                - ap_class_index (list): Index of class for each AP score.
+                - p_curve (list): Precision curve for each class.
+                - r_curve (list): Recall curve for each class.
+                - f1_curve (list): F1 curve for each class.
+                - px (list): X values for the curves.
+                - prec_values (list): Precision values for each class.
         """
         (
             self.p,
@@ -781,12 +817,12 @@ class Metric(SimpleClass):
 
     @property
     def curves(self):
-        """Returns a list of curves for accessing specific metrics curves."""
+        """Return a list of curves for accessing specific metrics curves."""
         return []
 
     @property
     def curves_results(self):
-        """Returns a list of curves for accessing specific metrics curves."""
+        """Return a list of curves for accessing specific metrics curves."""
         return [
             [self.px, self.prec_values, "Recall", "Precision"],
             [self.px, self.f1_curve, "Confidence", "F1"],
@@ -797,36 +833,26 @@ class Metric(SimpleClass):
 
 class DetMetrics(SimpleClass):
     """
-    Utility class for computing detection metrics such as precision, recall, and mean average precision (mAP) of an
-    object detection model.
-
-    Args:
-        save_dir (Path): A path to the directory where the output plots will be saved. Defaults to current directory.
-        plot (bool): A flag that indicates whether to plot precision-recall curves for each class. Defaults to False.
-        names (dict of str): A dict of strings that represents the names of the classes. Defaults to an empty tuple.
+    Utility class for computing detection metrics such as precision, recall, and mean average precision (mAP).
 
     Attributes:
         save_dir (Path): A path to the directory where the output plots will be saved.
-        plot (bool): A flag that indicates whether to plot the precision-recall curves for each class.
-        names (dict of str): A dict of strings that represents the names of the classes.
-        box (Metric): An instance of the Metric class for storing the results of the detection metrics.
-        speed (dict): A dictionary for storing the execution time of different parts of the detection process.
-
-    Methods:
-        process(tp, conf, pred_cls, target_cls): Updates the metric results with the latest batch of predictions.
-        keys: Returns a list of keys for accessing the computed detection metrics.
-        mean_results: Returns a list of mean values for the computed detection metrics.
-        class_result(i): Returns a list of values for the computed detection metrics for a specific class.
-        maps: Returns a dictionary of mean average precision (mAP) values for different IoU thresholds.
-        fitness: Computes the fitness score based on the computed detection metrics.
-        ap_class_index: Returns a list of class indices sorted by their average precision (AP) values.
-        results_dict: Returns a dictionary that maps detection metric keys to their computed values.
-        curves: TODO
-        curves_results: TODO
+        plot (bool): A flag that indicates whether to plot precision-recall curves for each class.
+        names (dict): A dictionary of class names.
+        box (Metric): An instance of the Metric class for storing detection results.
+        speed (dict): A dictionary for storing execution times of different parts of the detection process.
+        task (str): The task type, set to 'detect'.
     """
 
     def __init__(self, save_dir=Path("."), plot=False, names={}) -> None:
-        """Initialize a DetMetrics instance with a save directory, plot flag, callback function, and class names."""
+        """
+        Initialize a DetMetrics instance with a save directory, plot flag, and class names.
+
+        Args:
+            save_dir (Path, optional): Directory to save plots.
+            plot (bool, optional): Whether to plot precision-recall curves.
+            names (dict, optional): Dictionary mapping class indices to names.
+        """
         self.save_dir = save_dir
         self.plot = plot
         self.names = names
@@ -835,7 +861,16 @@ class DetMetrics(SimpleClass):
         self.task = "detect"
 
     def process(self, tp, conf, pred_cls, target_cls, on_plot=None):
-        """Process predicted results for object detection and update metrics."""
+        """
+        Process predicted results for object detection and update metrics.
+
+        Args:
+            tp (np.ndarray): True positive array.
+            conf (np.ndarray): Confidence array.
+            pred_cls (np.ndarray): Predicted class indices array.
+            target_cls (np.ndarray): Target class indices array.
+            on_plot (callable, optional): Function to call after plots are generated.
+        """
         results = ap_per_class(
             tp,
             conf,
@@ -851,7 +886,7 @@ class DetMetrics(SimpleClass):
 
     @property
     def keys(self):
-        """Returns a list of keys for accessing specific metrics."""
+        """Return a list of keys for accessing specific metrics."""
         return ["metrics/precision(B)", "metrics/recall(B)", "metrics/mAP50(B)", "metrics/mAP50-95(B)"]
 
     def mean_results(self):
@@ -864,32 +899,32 @@ class DetMetrics(SimpleClass):
 
     @property
     def maps(self):
-        """Returns mean Average Precision (mAP) scores per class."""
+        """Return mean Average Precision (mAP) scores per class."""
         return self.box.maps
 
     @property
     def fitness(self):
-        """Returns the fitness of box object."""
+        """Return the fitness of box object."""
         return self.box.fitness()
 
     @property
     def ap_class_index(self):
-        """Returns the average precision index per class."""
+        """Return the average precision index per class."""
         return self.box.ap_class_index
 
     @property
     def results_dict(self):
-        """Returns dictionary of computed performance metrics and statistics."""
+        """Return dictionary of computed performance metrics and statistics."""
         return dict(zip(self.keys + ["fitness"], self.mean_results() + [self.fitness]))
 
     @property
     def curves(self):
-        """Returns a list of curves for accessing specific metrics curves."""
+        """Return a list of curves for accessing specific metrics curves."""
         return ["Precision-Recall(B)", "F1-Confidence(B)", "Precision-Confidence(B)", "Recall-Confidence(B)"]
 
     @property
     def curves_results(self):
-        """Returns dictionary of computed performance metrics and statistics."""
+        """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results
 
 
@@ -897,31 +932,25 @@ class SegmentMetrics(SimpleClass):
     """
     Calculates and aggregates detection and segmentation metrics over a given set of classes.
 
-    Args:
-        save_dir (Path): Path to the directory where the output plots should be saved. Default is the current directory.
-        plot (bool): Whether to save the detection and segmentation plots. Default is False.
-        names (list): List of class names. Default is an empty list.
-
     Attributes:
         save_dir (Path): Path to the directory where the output plots should be saved.
         plot (bool): Whether to save the detection and segmentation plots.
-        names (list): List of class names.
+        names (dict): Dictionary of class names.
         box (Metric): An instance of the Metric class to calculate box detection metrics.
         seg (Metric): An instance of the Metric class to calculate mask segmentation metrics.
         speed (dict): Dictionary to store the time taken in different phases of inference.
-
-    Methods:
-        process(tp_m, tp_b, conf, pred_cls, target_cls): Processes metrics over the given set of predictions.
-        mean_results(): Returns the mean of the detection and segmentation metrics over all the classes.
-        class_result(i): Returns the detection and segmentation metrics of class `i`.
-        maps: Returns the mean Average Precision (mAP) scores for IoU thresholds ranging from 0.50 to 0.95.
-        fitness: Returns the fitness scores, which are a single weighted combination of metrics.
-        ap_class_index: Returns the list of indices of classes used to compute Average Precision (AP).
-        results_dict: Returns the dictionary containing all the detection and segmentation metrics and fitness score.
+        task (str): The task type, set to 'segment'.
     """
 
     def __init__(self, save_dir=Path("."), plot=False, names=()) -> None:
-        """Initialize a SegmentMetrics instance with a save directory, plot flag, callback function, and class names."""
+        """
+        Initialize a SegmentMetrics instance with a save directory, plot flag, and class names.
+
+        Args:
+            save_dir (Path, optional): Directory to save plots.
+            plot (bool, optional): Whether to plot precision-recall curves.
+            names (dict, optional): Dictionary mapping class indices to names.
+        """
         self.save_dir = save_dir
         self.plot = plot
         self.names = names
@@ -932,15 +961,15 @@ class SegmentMetrics(SimpleClass):
 
     def process(self, tp, tp_m, conf, pred_cls, target_cls, on_plot=None):
         """
-        Processes the detection and segmentation metrics over the given set of predictions.
+        Process the detection and segmentation metrics over the given set of predictions.
 
         Args:
-            tp (list): List of True Positive boxes.
-            tp_m (list): List of True Positive masks.
-            conf (list): List of confidence scores.
-            pred_cls (list): List of predicted classes.
-            target_cls (list): List of target classes.
-            on_plot (func): An optional callback to pass plots path and data when they are rendered. Defaults to None.
+            tp (np.ndarray): True positive array for boxes.
+            tp_m (np.ndarray): True positive array for masks.
+            conf (np.ndarray): Confidence array.
+            pred_cls (np.ndarray): Predicted class indices array.
+            target_cls (np.ndarray): Target class indices array.
+            on_plot (callable, optional): Function to call after plots are generated.
         """
         results_mask = ap_per_class(
             tp_m,
@@ -971,7 +1000,7 @@ class SegmentMetrics(SimpleClass):
 
     @property
     def keys(self):
-        """Returns a list of keys for accessing metrics."""
+        """Return a list of keys for accessing metrics."""
         return [
             "metrics/precision(B)",
             "metrics/recall(B)",
@@ -988,32 +1017,36 @@ class SegmentMetrics(SimpleClass):
         return self.box.mean_results() + self.seg.mean_results()
 
     def class_result(self, i):
-        """Returns classification results for a specified class index."""
+        """Return classification results for a specified class index."""
         return self.box.class_result(i) + self.seg.class_result(i)
 
     @property
     def maps(self):
-        """Returns mAP scores for object detection and semantic segmentation models."""
+        """Return mAP scores for object detection and semantic segmentation models."""
         return self.box.maps + self.seg.maps
 
     @property
     def fitness(self):
-        """Get the fitness score for both segmentation and bounding box models."""
+        """Return the fitness score for both segmentation and bounding box models."""
         return self.seg.fitness() + self.box.fitness()
 
     @property
     def ap_class_index(self):
-        """Boxes and masks have the same ap_class_index."""
+        """
+        Return the class indices.
+
+        Boxes and masks have the same ap_class_index.
+        """
         return self.box.ap_class_index
 
     @property
     def results_dict(self):
-        """Returns results of object detection model for evaluation."""
+        """Return results of object detection model for evaluation."""
         return dict(zip(self.keys + ["fitness"], self.mean_results() + [self.fitness]))
 
     @property
     def curves(self):
-        """Returns a list of curves for accessing specific metrics curves."""
+        """Return a list of curves for accessing specific metrics curves."""
         return [
             "Precision-Recall(B)",
             "F1-Confidence(B)",
@@ -1027,7 +1060,7 @@ class SegmentMetrics(SimpleClass):
 
     @property
     def curves_results(self):
-        """Returns dictionary of computed performance metrics and statistics."""
+        """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results + self.seg.curves_results
 
 
@@ -1035,18 +1068,14 @@ class PoseMetrics(SegmentMetrics):
     """
     Calculates and aggregates detection and pose metrics over a given set of classes.
 
-    Args:
-        save_dir (Path): Path to the directory where the output plots should be saved. Default is the current directory.
-        plot (bool): Whether to save the detection and segmentation plots. Default is False.
-        names (list): List of class names. Default is an empty list.
-
     Attributes:
         save_dir (Path): Path to the directory where the output plots should be saved.
-        plot (bool): Whether to save the detection and segmentation plots.
-        names (list): List of class names.
+        plot (bool): Whether to save the detection and pose plots.
+        names (dict): Dictionary of class names.
         box (Metric): An instance of the Metric class to calculate box detection metrics.
-        pose (Metric): An instance of the Metric class to calculate mask segmentation metrics.
+        pose (Metric): An instance of the Metric class to calculate pose metrics.
         speed (dict): Dictionary to store the time taken in different phases of inference.
+        task (str): The task type, set to 'pose'.
 
     Methods:
         process(tp_m, tp_b, conf, pred_cls, target_cls): Processes metrics over the given set of predictions.
@@ -1059,7 +1088,14 @@ class PoseMetrics(SegmentMetrics):
     """
 
     def __init__(self, save_dir=Path("."), plot=False, names=()) -> 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:
+            save_dir (Path, optional): Directory to save plots.
+            plot (bool, optional): Whether to plot precision-recall curves.
+            names (dict, optional): Dictionary mapping class indices to names.
+        """
         super().__init__(save_dir, plot, names)
         self.save_dir = save_dir
         self.plot = plot
@@ -1071,15 +1107,15 @@ class PoseMetrics(SegmentMetrics):
 
     def process(self, tp, tp_p, conf, pred_cls, target_cls, on_plot=None):
         """
-        Processes the detection and pose metrics over the given set of predictions.
+        Process the detection and pose metrics over the given set of predictions.
 
         Args:
-            tp (list): List of True Positive boxes.
-            tp_p (list): List of True Positive keypoints.
-            conf (list): List of confidence scores.
-            pred_cls (list): List of predicted classes.
-            target_cls (list): List of target classes.
-            on_plot (func): An optional callback to pass plots path and data when they are rendered. Defaults to None.
+            tp (np.ndarray): True positive array for boxes.
+            tp_p (np.ndarray): True positive array for keypoints.
+            conf (np.ndarray): Confidence array.
+            pred_cls (np.ndarray): Predicted class indices array.
+            target_cls (np.ndarray): Target class indices array.
+            on_plot (callable, optional): Function to call after plots are generated.
         """
         results_pose = ap_per_class(
             tp_p,
@@ -1110,7 +1146,7 @@ class PoseMetrics(SegmentMetrics):
 
     @property
     def keys(self):
-        """Returns list of evaluation metric keys."""
+        """Return list of evaluation metric keys."""
         return [
             "metrics/precision(B)",
             "metrics/recall(B)",
@@ -1132,17 +1168,17 @@ class PoseMetrics(SegmentMetrics):
 
     @property
     def maps(self):
-        """Returns the mean average precision (mAP) per class for both box and pose detections."""
+        """Return the mean average precision (mAP) per class for both box and pose detections."""
         return self.box.maps + self.pose.maps
 
     @property
     def fitness(self):
-        """Computes classification metrics and speed using the `targets` and `pred` inputs."""
+        """Return combined fitness score for pose and box detection."""
         return self.pose.fitness() + self.box.fitness()
 
     @property
     def curves(self):
-        """Returns a list of curves for accessing specific metrics curves."""
+        """Return a list of curves for accessing specific metrics curves."""
         return [
             "Precision-Recall(B)",
             "F1-Confidence(B)",
@@ -1156,7 +1192,7 @@ class PoseMetrics(SegmentMetrics):
 
     @property
     def curves_results(self):
-        """Returns dictionary of computed performance metrics and statistics."""
+        """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results + self.pose.curves_results
 
 
@@ -1167,13 +1203,8 @@ class ClassifyMetrics(SimpleClass):
     Attributes:
         top1 (float): The top-1 accuracy.
         top5 (float): The top-5 accuracy.
-        speed (Dict[str, float]): A dictionary containing the time taken for each step in the pipeline.
-        fitness (float): The fitness of the model, which is equal to top-5 accuracy.
-        results_dict (Dict[str, Union[float, str]]): A dictionary containing the classification metrics and fitness.
-        keys (List[str]): A list of keys for the results_dict.
-
-    Methods:
-        process(targets, pred): Processes the targets and predictions to compute classification metrics.
+        speed (dict): A dictionary containing the time taken for each step in the pipeline.
+        task (str): The task type, set to 'classify'.
     """
 
     def __init__(self) -> None:
@@ -1184,7 +1215,13 @@ class ClassifyMetrics(SimpleClass):
         self.task = "classify"
 
     def process(self, targets, pred):
-        """Target classes and predicted classes."""
+        """
+        Process target classes and predicted classes to compute metrics.
+
+        Args:
+            targets (torch.Tensor): Target classes.
+            pred (torch.Tensor): Predicted classes.
+        """
         pred, targets = torch.cat(pred), torch.cat(targets)
         correct = (targets[:, None] == pred).float()
         acc = torch.stack((correct[:, 0], correct.max(1).values), dim=1)  # (top1, top5) accuracy
@@ -1192,35 +1229,54 @@ class ClassifyMetrics(SimpleClass):
 
     @property
     def fitness(self):
-        """Returns mean of top-1 and top-5 accuracies as fitness score."""
+        """Return mean of top-1 and top-5 accuracies as fitness score."""
         return (self.top1 + self.top5) / 2
 
     @property
     def results_dict(self):
-        """Returns a dictionary with model's performance metrics and fitness score."""
+        """Return a dictionary with model's performance metrics and fitness score."""
         return dict(zip(self.keys + ["fitness"], [self.top1, self.top5, self.fitness]))
 
     @property
     def keys(self):
-        """Returns a list of keys for the results_dict property."""
+        """Return a list of keys for the results_dict property."""
         return ["metrics/accuracy_top1", "metrics/accuracy_top5"]
 
     @property
     def curves(self):
-        """Returns a list of curves for accessing specific metrics curves."""
+        """Return a list of curves for accessing specific metrics curves."""
         return []
 
     @property
     def curves_results(self):
-        """Returns a list of curves for accessing specific metrics curves."""
+        """Return a list of curves for accessing specific metrics curves."""
         return []
 
 
 class OBBMetrics(SimpleClass):
-    """Metrics for evaluating oriented bounding box (OBB) detection, see https://arxiv.org/pdf/2106.06072.pdf."""
+    """
+    Metrics for evaluating oriented bounding box (OBB) detection.
+
+    Attributes:
+        save_dir (Path): Path to the directory where the output plots should be saved.
+        plot (bool): Whether to save the detection plots.
+        names (dict): Dictionary of class names.
+        box (Metric): An instance of the Metric class for storing detection results.
+        speed (dict): A dictionary for storing execution times of different parts of the detection process.
+
+    References:
+        https://arxiv.org/pdf/2106.06072.pdf
+    """
 
     def __init__(self, save_dir=Path("."), plot=False, names=()) -> None:
-        """Initialize an OBBMetrics instance with directory, plotting, callback, and class names."""
+        """
+        Initialize an OBBMetrics instance with directory, plotting, and class names.
+
+        Args:
+            save_dir (Path, optional): Directory to save plots.
+            plot (bool, optional): Whether to plot precision-recall curves.
+            names (dict, optional): Dictionary mapping class indices to names.
+        """
         self.save_dir = save_dir
         self.plot = plot
         self.names = names
@@ -1228,7 +1284,16 @@ class OBBMetrics(SimpleClass):
         self.speed = {"preprocess": 0.0, "inference": 0.0, "loss": 0.0, "postprocess": 0.0}
 
     def process(self, tp, conf, pred_cls, target_cls, on_plot=None):
-        """Process predicted results for object detection and update metrics."""
+        """
+        Process predicted results for object detection and update metrics.
+
+        Args:
+            tp (np.ndarray): True positive array.
+            conf (np.ndarray): Confidence array.
+            pred_cls (np.ndarray): Predicted class indices array.
+            target_cls (np.ndarray): Target class indices array.
+            on_plot (callable, optional): Function to call after plots are generated.
+        """
         results = ap_per_class(
             tp,
             conf,
@@ -1244,7 +1309,7 @@ class OBBMetrics(SimpleClass):
 
     @property
     def keys(self):
-        """Returns a list of keys for accessing specific metrics."""
+        """Return a list of keys for accessing specific metrics."""
         return ["metrics/precision(B)", "metrics/recall(B)", "metrics/mAP50(B)", "metrics/mAP50-95(B)"]
 
     def mean_results(self):
@@ -1257,30 +1322,30 @@ class OBBMetrics(SimpleClass):
 
     @property
     def maps(self):
-        """Returns mean Average Precision (mAP) scores per class."""
+        """Return mean Average Precision (mAP) scores per class."""
         return self.box.maps
 
     @property
     def fitness(self):
-        """Returns the fitness of box object."""
+        """Return the fitness of box object."""
         return self.box.fitness()
 
     @property
     def ap_class_index(self):
-        """Returns the average precision index per class."""
+        """Return the average precision index per class."""
         return self.box.ap_class_index
 
     @property
     def results_dict(self):
-        """Returns dictionary of computed performance metrics and statistics."""
+        """Return dictionary of computed performance metrics and statistics."""
         return dict(zip(self.keys + ["fitness"], self.mean_results() + [self.fitness]))
 
     @property
     def curves(self):
-        """Returns a list of curves for accessing specific metrics curves."""
+        """Return a list of curves for accessing specific metrics curves."""
         return []
 
     @property
     def curves_results(self):
-        """Returns a list of curves for accessing specific metrics curves."""
+        """Return a list of curves for accessing specific metrics curves."""
         return []