valor-lite 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

valor_lite/semantic_segmentation/__init__.py

@@ -1,5 +1,5 @@
-from .annotation import Bitmask, Segmentation, generate_segmentation
-from .manager import DataLoader, Evaluator
+from .annotation import Bitmask, Segmentation
+from .manager import DataLoader, Evaluator, Filter
 from .metric import Metric, MetricType
 
 __all__ = [
@@ -9,5 +9,5 @@ __all__ = [
     "Bitmask",
     "Metric",
     "MetricType",
-    "generate_segmentation",
+    "Filter",
 ]

valor_lite/semantic_segmentation/annotation.py

@@ -68,112 +68,41 @@ class Segmentation:
     uid: str
     groundtruths: list[Bitmask]
     predictions: list[Bitmask]
-    shape: tuple[int, ...] = field(default_factory=lambda: (0, 0))
+    shape: tuple[int, ...]
     size: int = field(default=0)
 
     def __post_init__(self):
 
-        groundtruth_shape = {
-            groundtruth.mask.shape for groundtruth in self.groundtruths
-        }
-        prediction_shape = {
-            prediction.mask.shape for prediction in self.predictions
-        }
-        if len(groundtruth_shape) == 0:
-            raise ValueError("The segmenation is missing ground truths.")
-        elif len(prediction_shape) == 0:
-            raise ValueError("The segmenation is missing predictions.")
-        elif (
-            len(groundtruth_shape) != 1
-            or len(prediction_shape) != 1
-            or groundtruth_shape != prediction_shape
-        ):
+        if len(self.shape) != 2 or self.shape[0] <= 0 or self.shape[1] <= 0:
             raise ValueError(
-                "A shape mismatch exists within the segmentation."
+                f"segmentations must be 2-dimensional and have non-zero dimensions. Recieved shape '{self.shape}'"
             )
-
-        self.shape = groundtruth_shape.pop()
-        self.size = int(np.prod(np.array(self.shape)))
-
-
-def generate_segmentation(
-    datum_uid: str,
-    number_of_unique_labels: int,
-    mask_height: int,
-    mask_width: int,
-) -> Segmentation:
-    """
-    Generates a semantic segmentation annotation.
-
-    Parameters
-    ----------
-    datum_uid : str
-        The datum UID for the generated segmentation.
-    number_of_unique_labels : int
-        The number of unique labels.
-    mask_height : int
-        The height of the mask in pixels.
-    mask_width : int
-        The width of the mask in pixels.
-
-    Returns
-    -------
-    Segmentation
-        A generated semantic segmenatation annotation.
-    """
-
-    if number_of_unique_labels > 1:
-        common_proba = 0.4 / (number_of_unique_labels - 1)
-        min_proba = min(common_proba, 0.1)
-        labels = [str(i) for i in range(number_of_unique_labels)] + [None]
-        proba = (
-            [0.5]
-            + [common_proba for _ in range(number_of_unique_labels - 1)]
-            + [0.1]
-        )
-    elif number_of_unique_labels == 1:
-        labels = ["0", None]
-        proba = [0.9, 0.1]
-        min_proba = 0.1
-    else:
-        raise ValueError(
-            "The number of unique labels should be greater than zero."
-        )
-
-    probabilities = np.array(proba, dtype=np.float64)
-    weights = (probabilities / min_proba).astype(np.int32)
-
-    indices = np.random.choice(
-        np.arange(len(weights)),
-        size=(mask_height * 2, mask_width),
-        p=probabilities,
-    )
-
-    N = len(labels)
-
-    masks = np.arange(N)[:, None, None] == indices
-
-    gts = []
-    pds = []
-    for lidx in range(N):
-        label = labels[lidx]
-        if label is None:
-            continue
-        gts.append(
-            Bitmask(
-                mask=masks[lidx, :mask_height, :],
-                label=label,
-            )
-        )
-        pds.append(
-            Bitmask(
-                mask=masks[lidx, mask_height:, :],
-                label=label,
-            )
-        )
-
-    return Segmentation(
-        uid=datum_uid,
-        groundtruths=gts,
-        predictions=pds,
-    )
+        self.size = self.shape[0] * self.shape[1]
+
+        mask_accumulation = None
+        for groundtruth in self.groundtruths:
+            if self.shape != groundtruth.mask.shape:
+                raise ValueError(
+                    f"ground truth masks for datum '{self.uid}' should have shape '{self.shape}'. Received mask with shape '{groundtruth.mask.shape}'"
+                )
+
+            if mask_accumulation is None:
+                mask_accumulation = groundtruth.mask.copy()
+            elif np.logical_and(mask_accumulation, groundtruth.mask).any():
+                raise ValueError("ground truth masks cannot overlap")
+            else:
+                mask_accumulation = mask_accumulation | groundtruth.mask
+
+        mask_accumulation = None
+        for prediction in self.predictions:
+            if self.shape != prediction.mask.shape:
+                raise ValueError(
+                    f"prediction masks for datum '{self.uid}' should have shape '{self.shape}'. Received mask with shape '{prediction.mask.shape}'"
+                )
+
+            if mask_accumulation is None:
+                mask_accumulation = prediction.mask.copy()
+            elif np.logical_and(mask_accumulation, prediction.mask).any():
+                raise ValueError("prediction masks cannot overlap")
+            else:
+                mask_accumulation = mask_accumulation | prediction.mask

valor_lite/semantic_segmentation/benchmark.py

@@ -1,5 +1,91 @@
+import numpy as np
+
 from valor_lite.profiling import create_runtime_profiler
-from valor_lite.semantic_segmentation import DataLoader, generate_segmentation
+from valor_lite.semantic_segmentation import Bitmask, DataLoader, Segmentation
+
+
+def generate_segmentation(
+    datum_uid: str,
+    number_of_unique_labels: int,
+    mask_height: int,
+    mask_width: int,
+) -> Segmentation:
+    """
+    Generates a semantic segmentation annotation.
+
+    Parameters
+    ----------
+    datum_uid : str
+        The datum UID for the generated segmentation.
+    number_of_unique_labels : int
+        The number of unique labels.
+    mask_height : int
+        The height of the mask in pixels.
+    mask_width : int
+        The width of the mask in pixels.
+
+    Returns
+    -------
+    Segmentation
+        A generated semantic segmenatation annotation.
+    """
+
+    if number_of_unique_labels > 1:
+        common_proba = 0.4 / (number_of_unique_labels - 1)
+        min_proba = min(common_proba, 0.1)
+        labels = [str(i) for i in range(number_of_unique_labels)] + [None]
+        proba = (
+            [0.5]
+            + [common_proba for _ in range(number_of_unique_labels - 1)]
+            + [0.1]
+        )
+    elif number_of_unique_labels == 1:
+        labels = ["0", None]
+        proba = [0.9, 0.1]
+        min_proba = 0.1
+    else:
+        raise ValueError(
+            "The number of unique labels should be greater than zero."
+        )
+
+    probabilities = np.array(proba, dtype=np.float64)
+    weights = (probabilities / min_proba).astype(np.int32)
+
+    indices = np.random.choice(
+        np.arange(len(weights)),
+        size=(mask_height * 2, mask_width),
+        p=probabilities,
+    )
+
+    N = len(labels)
+
+    masks = np.arange(N)[:, None, None] == indices
+
+    gts = []
+    pds = []
+    for lidx in range(N):
+        label = labels[lidx]
+        if label is None:
+            continue
+        gts.append(
+            Bitmask(
+                mask=masks[lidx, :mask_height, :],
+                label=label,
+            )
+        )
+        pds.append(
+            Bitmask(
+                mask=masks[lidx, mask_height:, :],
+                label=label,
+            )
+        )
+
+    return Segmentation(
+        uid=datum_uid,
+        groundtruths=gts,
+        predictions=pds,
+        shape=(mask_height, mask_width),
+    )
 
 
 def benchmark_add_data(

valor_lite/semantic_segmentation/computation.py

@@ -2,13 +2,93 @@ import numpy as np
 from numpy.typing import NDArray
 
 
+def compute_label_metadata(
+    confusion_matrices: NDArray[np.int64],
+    n_labels: int,
+) -> NDArray[np.int64]:
+    """
+    Computes label metadata returning a count of annotations per label.
+
+    Parameters
+    ----------
+    confusion_matrices : NDArray[np.int64]
+        Confusion matrices per datum with shape (n_datums, n_labels + 1, n_labels + 1).
+    n_labels : int
+        The total number of unique labels.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        The label metadata array with shape (n_labels, 2).
+            Index 0 - Ground truth label count
+            Index 1 - Prediction label count
+    """
+    label_metadata = np.zeros((n_labels, 2), dtype=np.int64)
+    label_metadata[:, 0] = confusion_matrices[:, 1:, :].sum(axis=(0, 2))
+    label_metadata[:, 1] = confusion_matrices[:, :, 1:].sum(axis=(0, 1))
+    return label_metadata
+
+
+def filter_cache(
+    confusion_matrices: NDArray[np.int64],
+    datum_mask: NDArray[np.bool_],
+    label_mask: NDArray[np.bool_],
+    number_of_labels: int,
+) -> tuple[NDArray[np.int64], NDArray[np.int64]]:
+    """
+    Performs the filter operation over the internal cache.
+
+    Parameters
+    ----------
+    confusion_matrices : NDArray[int64]
+        The internal evaluator cache.
+    datum_mask : NDArray[bool]
+        A mask that filters out datums.
+    datum_mask : NDArray[bool]
+        A mask that filters out labels.
+
+    Returns
+    -------
+    NDArray[int64]
+        Filtered confusion matrices.
+    NDArray[int64]
+        Filtered label metadata.
+    """
+    if label_mask.any():
+        # add filtered labels to background
+        null_predictions = confusion_matrices[:, label_mask, :].sum(
+            axis=(1, 2)
+        )
+        null_groundtruths = confusion_matrices[:, :, label_mask].sum(
+            axis=(1, 2)
+        )
+        null_intersection = (
+            confusion_matrices[:, label_mask, label_mask]
+            .reshape(confusion_matrices.shape[0], -1)
+            .sum(axis=1)
+        )
+        confusion_matrices[:, 0, 0] += (
+            null_groundtruths + null_predictions - null_intersection
+        )
+        confusion_matrices[:, label_mask, :] = 0
+        confusion_matrices[:, :, label_mask] = 0
+
+    confusion_matrices = confusion_matrices[datum_mask]
+
+    label_metadata = compute_label_metadata(
+        confusion_matrices=confusion_matrices,
+        n_labels=number_of_labels,
+    )
+    return confusion_matrices, label_metadata
+
+
 def compute_intermediate_confusion_matrices(
     groundtruths: NDArray[np.bool_],
     predictions: NDArray[np.bool_],
-    groundtruth_labels: NDArray[np.int32],
-    prediction_labels: NDArray[np.int32],
+    groundtruth_labels: NDArray[np.int64],
+    prediction_labels: NDArray[np.int64],
     n_labels: int,
-) -> NDArray[np.int32]:
+) -> NDArray[np.int64]:
     """
     Computes an intermediate confusion matrix containing label counts.
 
@@ -18,16 +98,16 @@ def compute_intermediate_confusion_matrices(
         A 2-D array containing flattened bitmasks for each label.
     predictions : NDArray[np.bool_]
         A 2-D array containing flattened bitmasks for each label.
-    groundtruth_labels : NDArray[np.int32]
+    groundtruth_labels : NDArray[np.int64]
         A 1-D array containing label indices.
-    groundtruth_labels : NDArray[np.int32]
+    groundtruth_labels : NDArray[np.int64]
         A 1-D array containing label indices.
     n_labels : int
         The number of unique labels.
 
     Returns
     -------
-    NDArray[np.int32]
+    NDArray[np.int64]
         A 2-D confusion matrix with shape (n_labels + 1, n_labels + 1).
     """
 
@@ -45,7 +125,7 @@ def compute_intermediate_confusion_matrices(
     intersected_groundtruth_counts = intersection_counts.sum(axis=1)
     intersected_prediction_counts = intersection_counts.sum(axis=0)
 
-    confusion_matrix = np.zeros((n_labels + 1, n_labels + 1), dtype=np.int32)
+    confusion_matrix = np.zeros((n_labels + 1, n_labels + 1), dtype=np.int64)
     confusion_matrix[0, 0] = background_counts
     confusion_matrix[
         np.ix_(groundtruth_labels + 1, prediction_labels + 1)
@@ -61,8 +141,8 @@ def compute_intermediate_confusion_matrices(
 
 
 def compute_metrics(
-    data: NDArray[np.float64],
-    label_metadata: NDArray[np.int32],
+    confusion_matrices: NDArray[np.int64],
+    label_metadata: NDArray[np.int64],
     n_pixels: int,
 ) -> tuple[
     NDArray[np.float64],
@@ -80,10 +160,12 @@ def compute_metrics(
 
     Parameters
     ----------
-    data : NDArray[np.float64]
-        A 3-D array containing confusion matrices for each datum.
-    label_metadata : NDArray[np.int32]
-        A 2-D array containing label metadata.
+    confusion_matrices : NDArray[np.int64]
+        A 3-D array containing confusion matrices for each datum with shape (n_datums, n_labels + 1, n_labels + 1).
+    label_metadata : NDArray[np.int64]
+        A 2-D array containing label metadata with shape (n_labels, 2).
+            Index 0: Ground Truth Label Count
+            Index 1: Prediction Label Count
 
     Returns
     -------
@@ -106,7 +188,7 @@ def compute_metrics(
     gt_counts = label_metadata[:, 0]
     pd_counts = label_metadata[:, 1]
 
-    counts = data.sum(axis=0)
+    counts = confusion_matrices.sum(axis=0)
 
     # compute iou, unmatched_ground_truth and unmatched predictions
     intersection_ = counts[1:, 1:]