valor-lite 0.33.13__py3-none-any.whl → 0.33.14__py3-none-any.whl

valor_lite/semantic_segmentation/manager.py

@@ -9,15 +9,9 @@ from valor_lite.semantic_segmentation.computation import (
     compute_intermediate_confusion_matrices,
     compute_metrics,
 )
-from valor_lite.semantic_segmentation.metric import (
-    F1,
-    Accuracy,
-    ConfusionMatrix,
-    IoU,
-    MetricType,
-    Precision,
-    Recall,
-    mIoU,
+from valor_lite.semantic_segmentation.metric import Metric, MetricType
+from valor_lite.semantic_segmentation.utilities import (
+    unpack_precision_recall_iou_into_metric_lists,
 )
 
 """
@@ -193,7 +187,6 @@ class Evaluator:
     def compute_precision_recall_iou(
         self,
         filter_: Filter | None = None,
-        as_dict: bool = False,
     ) -> dict[MetricType, list]:
         """
         Performs an evaluation and returns metrics.
@@ -202,8 +195,6 @@ class Evaluator:
         ----------
         filter_ : Filter, optional
             An optional filter object.
-        as_dict : bool, default=False
-            An option to return metrics as dictionaries.
 
         Returns
         -------
@@ -220,112 +211,22 @@ class Evaluator:
             label_metadata = filter_.label_metadata
             n_pixels = filter_.n_pixels
 
-        (
-            precision,
-            recall,
-            f1_score,
-            accuracy,
-            ious,
-            hallucination_ratios,
-            missing_prediction_ratios,
-        ) = compute_metrics(
+        results = compute_metrics(
             data=data,
             label_metadata=label_metadata,
             n_pixels=n_pixels,
         )
 
-        metrics = defaultdict(list)
-
-        metrics[MetricType.Accuracy] = [
-            Accuracy(
-                value=float(accuracy),
-            )
-        ]
-
-        metrics[MetricType.ConfusionMatrix] = [
-            ConfusionMatrix(
-                confusion_matrix={
-                    self.index_to_label[gt_label_idx]: {
-                        self.index_to_label[pd_label_idx]: {
-                            "iou": float(ious[gt_label_idx, pd_label_idx])
-                        }
-                        for pd_label_idx in range(self.n_labels)
-                        if label_metadata[pd_label_idx, 0] > 0
-                    }
-                    for gt_label_idx in range(self.n_labels)
-                    if label_metadata[gt_label_idx, 0] > 0
-                },
-                hallucinations={
-                    self.index_to_label[pd_label_idx]: {
-                        "ratio": float(hallucination_ratios[pd_label_idx])
-                    }
-                    for pd_label_idx in range(self.n_labels)
-                    if label_metadata[pd_label_idx, 0] > 0
-                },
-                missing_predictions={
-                    self.index_to_label[gt_label_idx]: {
-                        "ratio": float(missing_prediction_ratios[gt_label_idx])
-                    }
-                    for gt_label_idx in range(self.n_labels)
-                    if label_metadata[gt_label_idx, 0] > 0
-                },
-            )
-        ]
-
-        metrics[MetricType.mIoU] = [
-            mIoU(
-                value=float(ious.diagonal().mean()),
-            )
-        ]
-
-        for label_idx, label in self.index_to_label.items():
-
-            kwargs = {
-                "label": label,
-            }
-
-            # if no groundtruths exists for a label, skip it.
-            if label_metadata[label_idx, 0] == 0:
-                continue
-
-            metrics[MetricType.Precision].append(
-                Precision(
-                    value=float(precision[label_idx]),
-                    **kwargs,
-                )
-            )
-            metrics[MetricType.Recall].append(
-                Recall(
-                    value=float(recall[label_idx]),
-                    **kwargs,
-                )
-            )
-            metrics[MetricType.F1].append(
-                F1(
-                    value=float(f1_score[label_idx]),
-                    **kwargs,
-                )
-            )
-            metrics[MetricType.IoU].append(
-                IoU(
-                    value=float(ious[label_idx, label_idx]),
-                    **kwargs,
-                )
-            )
-
-        if as_dict:
-            return {
-                mtype: [metric.to_dict() for metric in mvalues]
-                for mtype, mvalues in metrics.items()
-            }
-
-        return metrics
+        return unpack_precision_recall_iou_into_metric_lists(
+            results=results,
+            label_metadata=label_metadata,
+            index_to_label=self.index_to_label,
+        )
 
     def evaluate(
         self,
         filter_: Filter | None = None,
-        as_dict: bool = False,
-    ) -> dict[MetricType, list]:
+    ) -> dict[MetricType, list[Metric]]:
         """
         Computes all available metrics.
 
@@ -333,17 +234,13 @@ class Evaluator:
         ----------
         filter_ : Filter, optional
             An optional filter object.
-        as_dict : bool, default=False
-            An option to return metrics as dictionaries.
 
         Returns
         -------
-        dict[MetricType, list]
-            A dictionary mapping metric type to lists of metrics.
+        dict[MetricType, list[Metric]]
+            Lists of metrics organized by metric type.
         """
-        return self.compute_precision_recall_iou(
-            filter_=filter_, as_dict=as_dict
-        )
+        return self.compute_precision_recall_iou(filter_=filter_)
 
 
 class DataLoader:

valor_lite/semantic_segmentation/metric.py

@@ -1,7 +1,6 @@
-from dataclasses import dataclass
 from enum import Enum
 
-from valor_lite.schemas import Metric
+from valor_lite.schemas import BaseMetric
 
 
 class MetricType(Enum):
@@ -9,270 +8,248 @@ class MetricType(Enum):
     Recall = "Recall"
     Accuracy = "Accuracy"
     F1 = "F1"
-    IoU = "IoU"
-    mIoU = "mIoU"
+    IOU = "IOU"
+    mIOU = "mIOU"
     ConfusionMatrix = "ConfusionMatrix"
 
-    @classmethod
-    def base(cls):
-        return [
-            cls.Precision,
-            cls.Recall,
-            cls.Accuracy,
-            cls.F1,
-            cls.IoU,
-            cls.mIoU,
-            cls.ConfusionMatrix,
-        ]
-
-
-@dataclass
-class _LabelValue:
-    value: float
-    label: str
-
-    def to_metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "label": self.label,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.to_metric().to_dict()
-
-
-class Precision(_LabelValue):
-    """
-    Precision metric for a specific class label.
-
-    Precision is calulated using the number of true-positive pixels divided by
-    the sum of all true-positive and false-positive pixels.
-
-    Attributes
-    ----------
-    value : float
-        The computed precision value.
-    label : str
-        The label for which the precision is calculated.
-
-    Methods
-    -------
-    to_metric()
-        Converts the instance to a generic `Metric` object.
-    to_dict()
-        Converts the instance to a dictionary representation.
-    """
-
-    pass
-
-
-class Recall(_LabelValue):
-    """
-    Recall metric for a specific class label.
-
-    Recall is calulated using the number of true-positive pixels divided by
-    the sum of all true-positive and false-negative pixels.
-
-    Attributes
-    ----------
-    value : float
-        The computed recall value.
-    label : str
-        The label for which the recall is calculated.
-
-    Methods
-    -------
-    to_metric()
-        Converts the instance to a generic `Metric` object.
-    to_dict()
-        Converts the instance to a dictionary representation.
-    """
-
-    pass
-
-
-class F1(_LabelValue):
-    """
-    F1 score for a specific class label.
-
-    Attributes
-    ----------
-    value : float
-        The computed F1 score.
-    label : str
-        The label for which the F1 score is calculated.
-
-    Methods
-    -------
-    to_metric()
-        Converts the instance to a generic `Metric` object.
-    to_dict()
-        Converts the instance to a dictionary representation.
-    """
 
-    pass
-
-
-class IoU(_LabelValue):
+class Metric(BaseMetric):
     """
-    Intersection over Union (IoU) ratio for a specific class label.
+    Semantic Segmentation Metric.
 
     Attributes
     ----------
-    value : float
-        The computed IoU ratio.
-    label : str
-        The label for which the IoU is calculated.
-
-    Methods
-    -------
-    to_metric()
-        Converts the instance to a generic `Metric` object.
-    to_dict()
-        Converts the instance to a dictionary representation.
+    type : str
+        The metric type.
+    value : int | float | dict
+        The metric value.
+    parameters : dict[str, Any]
+        A dictionary containing metric parameters.
     """
 
-    pass
-
-
-@dataclass
-class _Value:
-    value: float
-
-    def to_metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={},
+    @classmethod
+    def precision(
+        cls,
+        value: float,
+        label: str,
+    ):
+        """
+        Precision metric for a specific class label.
+
+        Precision is calulated using the number of true-positive pixels divided by
+        the sum of all true-positive and false-positive pixels.
+
+        Parameters
+        ----------
+        value : float
+            The computed precision value.
+        label : str
+            The label for which the precision is calculated.
+
+        Returns
+        -------
+        Metric
+        """
+        return cls(
+            type=MetricType.Precision.value,
+            value=value,
+            parameters={
+                "label": label,
+            },
         )
 
-    def to_dict(self) -> dict:
-        return self.to_metric().to_dict()
-
+    @classmethod
+    def recall(
+        cls,
+        value: float,
+        label: str,
+    ):
+        """
+        Recall metric for a specific class label.
+
+        Recall is calulated using the number of true-positive pixels divided by
+        the sum of all true-positive and false-negative pixels.
+
+        Parameters
+        ----------
+        value : float
+            The computed recall value.
+        label : str
+            The label for which the recall is calculated.
+
+        Returns
+        -------
+        Metric
+        """
+        return cls(
+            type=MetricType.Recall.value,
+            value=value,
+            parameters={
+                "label": label,
+            },
+        )
 
-class Accuracy(_Value):
-    """
-    Accuracy metric computed over all labels.
+    @classmethod
+    def f1_score(
+        cls,
+        value: float,
+        label: str,
+    ):
+        """
+        F1 score for a specific class label.
+
+        Parameters
+        ----------
+        value : float
+            The computed F1 score.
+        label : str
+            The label for which the F1 score is calculated.
+
+        Returns
+        -------
+        Metric
+        """
+        return cls(
+            type=MetricType.F1.value,
+            value=value,
+            parameters={
+                "label": label,
+            },
+        )
 
-    Attributes
-    ----------
-    value : float
-        The accuracy value.
-
-    Methods
-    -------
-    to_metric()
-        Converts the instance to a generic `Metric` object.
-    to_dict()
-        Converts the instance to a dictionary representation.
-    """
+    @classmethod
+    def iou(
+        cls,
+        value: float,
+        label: str,
+    ):
+        """
+        Intersection over Union (IOU) ratio for a specific class label.
+
+        Parameters
+        ----------
+        value : float
+            The computed IOU ratio.
+        label : str
+            The label for which the IOU is calculated.
+
+        Returns
+        -------
+        Metric
+        """
+        return cls(
+            type=MetricType.IOU.value,
+            value=value,
+            parameters={
+                "label": label,
+            },
+        )
 
-    pass
+    @classmethod
+    def mean_iou(cls, value: float):
+        """
+        Mean Intersection over Union (mIOU) ratio.
 
+        The mIOU value is computed by averaging IOU over all labels.
 
-class mIoU(_Value):
-    """
-    Mean Intersection over Union (mIoU) ratio.
+        Parameters
+        ----------
+        value : float
+            The mIOU value.
 
-    The mIoU value is computed by averaging IoU over all labels.
+        Returns
+        -------
+        Metric
+        """
+        return cls(type=MetricType.mIOU.value, value=value, parameters={})
 
-    Attributes
-    ----------
-    value : float
-        The mIoU value.
-
-    Methods
-    -------
-    to_metric()
-        Converts the instance to a generic `Metric` object.
-    to_dict()
-        Converts the instance to a dictionary representation.
-    """
+    @classmethod
+    def accuracy(cls, value: float):
+        """
+        Accuracy metric computed over all labels.
 
-    pass
+        Parameters
+        ----------
+        value : float
+            The accuracy value.
 
+        Returns
+        -------
+        Metric
+        """
+        return cls(type=MetricType.Accuracy.value, value=value, parameters={})
 
-@dataclass
-class ConfusionMatrix:
-    """
-    The confusion matrix and related metrics for semantic segmentation tasks.
-
-    This class encapsulates detailed information about the model's performance, including correct
-    predictions, misclassifications, hallucinations (false positives), and missing predictions
-    (false negatives). It provides counts for each category to facilitate in-depth analysis.
+    @classmethod
+    def confusion_matrix(
+        cls,
+        confusion_matrix: dict[
+            str,  # ground truth label value
+            dict[
+                str,  # prediction label value
+                dict[str, float],  # iou
+            ],
+        ],
+        hallucinations: dict[
+            str,  # prediction label value
+            dict[str, float],  # pixel ratio
+        ],
+        missing_predictions: dict[
+            str,  # ground truth label value
+            dict[str, float],  # pixel ratio
+        ],
+    ):
+        """
+        The confusion matrix and related metrics for semantic segmentation tasks.
+
+        This class encapsulates detailed information about the model's performance, including correct
+        predictions, misclassifications, hallucinations (false positives), and missing predictions
+        (false negatives). It provides counts for each category to facilitate in-depth analysis.
+
+        Confusion Matrix Format:
+        {
+            <ground truth label>: {
+                <prediction label>: {
+                    'iou': <float>,
+                },
+            },
+        }
 
-    Confusion Matrix Format:
-    {
-        <ground truth label>: {
+        Hallucinations Format:
+        {
             <prediction label>: {
                 'iou': <float>,
             },
-        },
-    }
-
-    Hallucinations Format:
-    {
-        <prediction label>: {
-            'iou': <float>,
-        },
-    }
-
-    Missing Predictions Format:
-    {
-        <ground truth label>: {
-            'iou': <float>,
-        },
-    }
+        }
 
-    Attributes
-    ----------
-    confusion_matrix : dict
-        Nested dictionaries representing the Intersection over Union (IoU) scores for each
-        ground truth label and prediction label pair.
-    hallucinations : dict
-        Dictionary representing the pixel ratios for predicted labels that do not correspond
-        to any ground truth labels (false positives).
-    missing_predictions : dict
-        Dictionary representing the pixel ratios for ground truth labels that were not predicted
-        (false negatives).
-
-    Methods
-    -------
-    to_metric()
-        Converts the instance to a generic `Metric` object.
-    to_dict()
-        Converts the instance to a dictionary representation.
-    """
-
-    confusion_matrix: dict[
-        str,  # ground truth label value
-        dict[
-            str,  # prediction label value
-            dict[str, float],  # iou
-        ],
-    ]
-    hallucinations: dict[
-        str,  # prediction label value
-        dict[str, float],  # pixel ratio
-    ]
-    missing_predictions: dict[
-        str,  # ground truth label value
-        dict[str, float],  # pixel ratio
-    ]
-
-    def to_metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
+        Missing Predictions Format:
+        {
+            <ground truth label>: {
+                'iou': <float>,
+            },
+        }
+
+        Parameters
+        ----------
+        confusion_matrix : dict
+            Nested dictionaries representing the Intersection over Union (IOU) scores for each
+            ground truth label and prediction label pair.
+        hallucinations : dict
+            Dictionary representing the pixel ratios for predicted labels that do not correspond
+            to any ground truth labels (false positives).
+        missing_predictions : dict
+            Dictionary representing the pixel ratios for ground truth labels that were not predicted
+            (false negatives).
+
+        Returns
+        -------
+        Metric
+        """
+        return cls(
+            type=MetricType.ConfusionMatrix.value,
             value={
-                "confusion_matrix": self.confusion_matrix,
-                "hallucinations": self.hallucinations,
-                "missing_predictions": self.missing_predictions,
+                "confusion_matrix": confusion_matrix,
+                "hallucinations": hallucinations,
+                "missing_predictions": missing_predictions,
             },
             parameters={},
         )
-
-    def to_dict(self) -> dict:
-        return self.to_metric().to_dict()