valor-lite 0.36.3__py3-none-any.whl → 0.36.5__py3-none-any.whl

valor_lite/classification/manager.py

@@ -144,18 +144,18 @@ class Evaluator:
 
     def create_filter(
         self,
-        datum_ids: list[str] | None = None,
-        labels: list[str] | None = None,
+        datums: list[str] | NDArray[np.int32] | None = None,
+        labels: list[str] | NDArray[np.int32] | None = None,
     ) -> Filter:
         """
         Creates a filter object.
 
         Parameters
         ----------
-        datum_uids : list[str], optional
-            An optional list of string uids representing datums.
-        labels : list[str], optional
-            An optional list of labels.
+        datums : list[str] | NDArray[int32], optional
+            An optional list of string uids or integer indices representing datums.
+        labels : list[str] | NDArray[int32], optional
+            An optional list of strings or integer indices representing labels.
 
         Returns
         -------
@@ -165,50 +165,72 @@ class Evaluator:
         # create datum mask
         n_pairs = self._detailed_pairs.shape[0]
         datum_mask = np.ones(n_pairs, dtype=np.bool_)
-        if datum_ids is not None:
-            if not datum_ids:
-                return Filter(
-                    datum_mask=np.zeros_like(datum_mask),
-                    valid_label_indices=None,
-                    metadata=Metadata(),
+        if datums is not None:
+            # convert to array of valid datum indices
+            if isinstance(datums, list):
+                datums = np.array(
+                    [self.datum_id_to_index[uid] for uid in datums],
+                    dtype=np.int32,
                 )
-            valid_datum_indices = np.array(
-                [self.datum_id_to_index[uid] for uid in datum_ids],
-                dtype=np.int32,
-            )
-            datum_mask = np.isin(
-                self._detailed_pairs[:, 0], valid_datum_indices
-            )
+
+            # return early if all data removed
+            if datums.size == 0:
+                raise EmptyFilterError("filter removes all datums")
+
+            # validate indices
+            if datums.max() >= len(self.index_to_datum_id):
+                raise ValueError(
+                    f"datum index '{datums.max()}' exceeds total number of datums"
+                )
+            elif datums.min() < 0:
+                raise ValueError(
+                    f"datum index '{datums.min()}' is a negative value"
+                )
+
+            # create datum mask
+            datum_mask = np.isin(self._detailed_pairs[:, 0], datums)
 
         # collect valid label indices
-        valid_label_indices = None
         if labels is not None:
-            if not labels:
-                return Filter(
-                    datum_mask=datum_mask,
-                    valid_label_indices=np.array([], dtype=np.int32),
-                    metadata=Metadata(),
+            # convert to array of valid label indices
+            if isinstance(labels, list):
+                labels = np.array(
+                    [self.label_to_index[label] for label in labels]
                 )
-            valid_label_indices = np.array(
-                [self.label_to_index[label] for label in labels] + [-1]
-            )
+
+            # return early if all data removed
+            if labels.size == 0:
+                raise EmptyFilterError("filter removes all labels")
+
+            # validate indices
+            if labels.max() >= len(self.index_to_label):
+                raise ValueError(
+                    f"label index '{labels.max()}' exceeds total number of labels"
+                )
+            elif labels.min() < 0:
+                raise ValueError(
+                    f"label index '{labels.min()}' is a negative value"
+                )
+
+            # add -1 to represent null labels which should not be filtered
+            labels = np.concatenate([labels, np.array([-1])])
 
         filtered_detailed_pairs, _ = filter_cache(
             detailed_pairs=self._detailed_pairs,
             datum_mask=datum_mask,
-            valid_label_indices=valid_label_indices,
+            valid_label_indices=labels,
             n_labels=self.metadata.number_of_labels,
         )
 
         number_of_datums = (
-            len(datum_ids)
-            if datum_ids is not None
+            datums.size
+            if datums is not None
             else self.metadata.number_of_datums
         )
 
         return Filter(
             datum_mask=datum_mask,
-            valid_label_indices=valid_label_indices,
+            valid_label_indices=labels,
             metadata=Metadata.create(
                 detailed_pairs=filtered_detailed_pairs,
                 number_of_datums=number_of_datums,

valor_lite/object_detection/manager.py

@@ -173,38 +173,52 @@ class Evaluator:
 
     def create_filter(
         self,
-        datum_ids: list[str] | None = None,
-        groundtruth_ids: list[str] | None = None,
-        prediction_ids: list[str] | None = None,
-        labels: list[str] | None = None,
+        datums: list[str] | NDArray[np.int32] | None = None,
+        groundtruths: list[str] | NDArray[np.int32] | None = None,
+        predictions: list[str] | NDArray[np.int32] | None = None,
+        labels: list[str] | NDArray[np.int32] | None = None,
     ) -> Filter:
         """
         Creates a filter object.
 
         Parameters
         ----------
-        datum_uids : list[str], optional
-            An optional list of string uids representing datums to keep.
-        groundtruth_ids : list[str], optional
-            An optional list of string uids representing ground truth annotations to keep.
-        prediction_ids : list[str], optional
-            An optional list of string uids representing prediction annotations to keep.
-        labels : list[str], optional
-            An optional list of labels to keep.
+        datum : list[str] | NDArray[int32], optional
+            An optional list of string ids or indices representing datums to keep.
+        groundtruth : list[str] | NDArray[int32], optional
+            An optional list of string ids or indices representing ground truth annotations to keep.
+        prediction : list[str] | NDArray[int32], optional
+            An optional list of string ids or indices representing prediction annotations to keep.
+        labels : list[str] | NDArray[int32], optional
+            An optional list of labels or indices to keep.
         """
         mask_datums = np.ones(self._detailed_pairs.shape[0], dtype=np.bool_)
 
         # filter datums
-        if datum_ids is not None:
-            if not datum_ids:
-                raise EmptyFilterError("filter removes all datums")
-            valid_datum_indices = np.array(
-                [self.datum_id_to_index[uid] for uid in datum_ids],
-                dtype=np.int32,
-            )
-            mask_datums = np.isin(
-                self._detailed_pairs[:, 0], valid_datum_indices
-            )
+        if datums is not None:
+            # convert to indices
+            if isinstance(datums, list):
+                datums = np.array(
+                    [self.datum_id_to_index[uid] for uid in datums],
+                    dtype=np.int32,
+                )
+
+            # validate indices
+            if datums.size == 0:
+                raise EmptyFilterError(
+                    "filter removes all datums"
+                )  # validate indices
+            elif datums.min() < 0:
+                raise ValueError(
+                    f"datum index cannot be negative '{datums.min()}'"
+                )
+            elif datums.max() >= len(self.index_to_datum_id):
+                raise ValueError(
+                    f"datum index cannot exceed total number of datums '{datums.max()}'"
+                )
+
+            # apply to mask
+            mask_datums = np.isin(self._detailed_pairs[:, 0], datums)
 
         filtered_detailed_pairs = self._detailed_pairs[mask_datums]
         n_pairs = self._detailed_pairs[mask_datums].shape[0]
@@ -212,43 +226,93 @@ class Evaluator:
         mask_predictions = np.zeros_like(mask_groundtruths)
 
         # filter by ground truth annotation ids
-        if groundtruth_ids is not None:
-            valid_groundtruth_indices = np.array(
-                [self.groundtruth_id_to_index[uid] for uid in groundtruth_ids],
-                dtype=np.int32,
-            )
+        if groundtruths is not None:
+            # convert to indices
+            if isinstance(groundtruths, list):
+                groundtruths = np.array(
+                    [
+                        self.groundtruth_id_to_index[uid]
+                        for uid in groundtruths
+                    ],
+                    dtype=np.int32,
+                )
+
+            # validate indices
+            if groundtruths.size == 0:
+                warnings.warn("filter removes all ground truths")
+            elif groundtruths.min() < 0:
+                raise ValueError(
+                    f"groundtruth annotation index cannot be negative '{groundtruths.min()}'"
+                )
+            elif groundtruths.max() >= len(self.index_to_groundtruth_id):
+                raise ValueError(
+                    f"groundtruth annotation index cannot exceed total number of groundtruths '{groundtruths.max()}'"
+                )
+
+            # apply to mask
             mask_groundtruths[
                 ~np.isin(
                     filtered_detailed_pairs[:, 1],
-                    valid_groundtruth_indices,
+                    groundtruths,
                 )
             ] = True
 
         # filter by prediction annotation ids
-        if prediction_ids is not None:
-            valid_prediction_indices = np.array(
-                [self.prediction_id_to_index[uid] for uid in prediction_ids],
-                dtype=np.int32,
-            )
+        if predictions is not None:
+            # convert to indices
+            if isinstance(predictions, list):
+                predictions = np.array(
+                    [self.prediction_id_to_index[uid] for uid in predictions],
+                    dtype=np.int32,
+                )
+
+            # validate indices
+            if predictions.size == 0:
+                warnings.warn("filter removes all predictions")
+            elif predictions.min() < 0:
+                raise ValueError(
+                    f"prediction annotation index cannot be negative '{predictions.min()}'"
+                )
+            elif predictions.max() >= len(self.index_to_prediction_id):
+                raise ValueError(
+                    f"prediction annotation index cannot exceed total number of predictions '{predictions.max()}'"
+                )
+
+            # apply to mask
             mask_predictions[
                 ~np.isin(
                     filtered_detailed_pairs[:, 2],
-                    valid_prediction_indices,
+                    predictions,
                 )
             ] = True
 
         # filter by labels
         if labels is not None:
-            if not labels:
+            # convert to indices
+            if isinstance(labels, list):
+                labels = np.array(
+                    [self.label_to_index[label] for label in labels]
+                )
+
+            # validate indices
+            if labels.size == 0:
                 raise EmptyFilterError("filter removes all labels")
-            valid_label_indices = np.array(
-                [self.label_to_index[label] for label in labels] + [-1]
-            )
+            elif labels.min() < 0:
+                raise ValueError(
+                    f"label index cannot be negative '{labels.min()}'"
+                )
+            elif labels.max() >= len(self.index_to_label):
+                raise ValueError(
+                    f"label index cannot exceed total number of labels '{labels.max()}'"
+                )
+
+            # apply to mask
+            labels = np.concatenate([labels, np.array([-1])])  # add null label
             mask_groundtruths[
-                ~np.isin(filtered_detailed_pairs[:, 3], valid_label_indices)
+                ~np.isin(filtered_detailed_pairs[:, 3], labels)
             ] = True
             mask_predictions[
-                ~np.isin(filtered_detailed_pairs[:, 4], valid_label_indices)
+                ~np.isin(filtered_detailed_pairs[:, 4], labels)
             ] = True
 
         filtered_detailed_pairs, _, _ = filter_cache(
@@ -260,8 +324,8 @@ class Evaluator:
         )
 
         number_of_datums = (
-            len(datum_ids)
-            if datum_ids
+            datums.size
+            if datums is not None
             else np.unique(filtered_detailed_pairs[:, 0]).size
         )
 

valor_lite/semantic_segmentation/annotation.py

@@ -1,3 +1,4 @@
+import warnings
 from dataclasses import dataclass, field
 
 import numpy as np
@@ -79,30 +80,37 @@ class Segmentation:
             )
         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
+        self._validate_bitmasks(self.groundtruths, "ground truth")
+        self._validate_bitmasks(self.predictions, "prediction")
 
+    def _validate_bitmasks(self, bitmasks: list[Bitmask], key: str):
         mask_accumulation = None
-        for prediction in self.predictions:
-            if self.shape != prediction.mask.shape:
+        mask_overlap_accumulation = None
+        for idx, bitmask in enumerate(bitmasks):
+            if not isinstance(bitmask, Bitmask):
+                raise ValueError(f"expected 'Bitmask', got '{bitmask}'")
+            if self.shape != bitmask.mask.shape:
                 raise ValueError(
-                    f"prediction masks for datum '{self.uid}' should have shape '{self.shape}'. Received mask with shape '{prediction.mask.shape}'"
+                    f"{key} masks for datum '{self.uid}' should have shape '{self.shape}'. Received mask with shape '{bitmask.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")
+                mask_accumulation = bitmask.mask.copy()
+                mask_overlap_accumulation = np.zeros_like(mask_accumulation)
+            elif np.logical_and(mask_accumulation, bitmask.mask).any():
+                mask_overlap = np.logical_and(mask_accumulation, bitmask.mask)
+                bitmasks[idx].mask[mask_overlap] = False
+                mask_overlap_accumulation = (
+                    mask_overlap_accumulation | mask_overlap
+                )
             else:
-                mask_accumulation = mask_accumulation | prediction.mask
+                mask_accumulation = mask_accumulation | bitmask.mask
+        if (
+            mask_overlap_accumulation is not None
+            and mask_overlap_accumulation.any()
+        ):
+            count = mask_overlap_accumulation.sum()
+            total = mask_overlap_accumulation.size
+            warnings.warn(
+                f"{key} masks for datum '{self.uid}' had {count} / {total} pixels overlapped."
+            )

valor_lite/semantic_segmentation/manager.py

@@ -127,18 +127,18 @@ class Evaluator:
 
     def create_filter(
         self,
-        datum_ids: list[str] | None = None,
-        labels: list[str] | None = None,
+        datums: list[str] | NDArray[np.int64] | None = None,
+        labels: list[str] | NDArray[np.int64] | None = None,
     ) -> Filter:
         """
         Creates a filter for use with the evaluator.
 
         Parameters
         ----------
-        datum_ids : list[str], optional
-            An optional list of string uids representing datums.
-        labels : list[str], optional
-            An optional list of labels.
+        datums : list[str] | NDArray[int64], optional
+            An optional list of string ids or array of indices representing datums.
+        labels : list[str] | NDArray[int64], optional
+            An optional list of labels or array of indices.
 
         Returns
         -------
@@ -150,38 +150,61 @@ class Evaluator:
             self.metadata.number_of_labels + 1, dtype=np.bool_
         )
 
-        if datum_ids is not None:
-            if not datum_ids:
-                return Filter(
-                    datum_mask=np.zeros_like(datum_mask),
-                    label_mask=label_mask,
-                    metadata=Metadata(),
+        if datums is not None:
+            # convert to indices
+            if isinstance(datums, list):
+                datums = np.array(
+                    [self.datum_id_to_index[uid] for uid in datums],
+                    dtype=np.int64,
                 )
-            datum_id_array = np.array(
-                [self.datum_id_to_index[uid] for uid in datum_ids],
-                dtype=np.int64,
-            )
-            datum_id_array.sort()
+
+            # validate indices
+            if datums.size == 0:
+                raise EmptyFilterError(
+                    "filter removes all datums"
+                )  # validate indices
+            elif datums.min() < 0:
+                raise ValueError(
+                    f"datum index cannot be negative '{datums.min()}'"
+                )
+            elif datums.max() >= len(self.index_to_datum_id):
+                raise ValueError(
+                    f"datum index cannot exceed total number of datums '{datums.max()}'"
+                )
+
+            # apply to mask
+            datums.sort()
             mask_valid_datums = (
                 np.arange(self._confusion_matrices.shape[0]).reshape(-1, 1)
-                == datum_id_array.reshape(1, -1)
+                == datums.reshape(1, -1)
             ).any(axis=1)
             datum_mask[~mask_valid_datums] = False
 
         if labels is not None:
-            if not labels:
-                return Filter(
-                    datum_mask=datum_mask,
-                    label_mask=np.ones_like(label_mask),
-                    metadata=Metadata(),
+            # convert to indices
+            if isinstance(labels, list):
+                labels = np.array(
+                    [self.label_to_index[label] for label in labels],
+                    dtype=np.int64,
                 )
-            labels_id_array = np.array(
-                [self.label_to_index[label] for label in labels] + [-1],
-                dtype=np.int64,
-            )
+
+            # validate indices
+            if labels.size == 0:
+                raise EmptyFilterError("filter removes all labels")
+            elif labels.min() < 0:
+                raise ValueError(
+                    f"label index cannot be negative '{labels.min()}'"
+                )
+            elif labels.max() >= len(self.index_to_label):
+                raise ValueError(
+                    f"label index cannot exceed total number of labels '{labels.max()}'"
+                )
+
+            # apply to mask
+            labels = np.concatenate([labels, np.array([-1])])
             label_range = np.arange(self.metadata.number_of_labels + 1) - 1
             mask_valid_labels = (
-                label_range.reshape(-1, 1) == labels_id_array.reshape(1, -1)
+                label_range.reshape(-1, 1) == labels.reshape(1, -1)
             ).any(axis=1)
             label_mask[~mask_valid_labels] = True
 

{valor_lite-0.36.3.dist-info → valor_lite-0.36.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valor-lite
-Version: 0.36.3
+Version: 0.36.5
 Summary: Evaluate machine learning models.
 Project-URL: homepage, https://www.striveworks.com
 Requires-Python: >=3.10

{valor_lite-0.36.3.dist-info → valor_lite-0.36.5.dist-info}/RECORD

@@ -6,21 +6,21 @@ valor_lite/schemas.py,sha256=pB0MrPx5qFLbwBWDiOUUm-vmXdWvbJLFCBmKgbcbI5g,198
 valor_lite/classification/__init__.py,sha256=KXaVwyqAbeeeEq7bzNPyt4GTpbxhrABjV7lR58KR6Y4,440
 valor_lite/classification/annotation.py,sha256=0aUOvcwBAZgiNOJuyh-pXyNTG7vP7r8CUfnU3OmpUwQ,1113
 valor_lite/classification/computation.py,sha256=kB5n-RHzDsKG75Guvgg25xAOeLEQCq1TgjwHwfwbQ60,12010
-valor_lite/classification/manager.py,sha256=OGLtdTkOlhyU5zpjRFy4c3zqZ2Lt3SV38J6hzbAXrJY,15905
+valor_lite/classification/manager.py,sha256=JZwA9sf-OG7p7uK5qIo-D711kSpBDDeTcXsPr1uuIBI,16884
 valor_lite/classification/metric.py,sha256=nSNWjoxQ1ou7gxTPOYxLNoUYf7avKQzJq3NHR9jzM48,11693
 valor_lite/classification/numpy_compatibility.py,sha256=roqtTetsm1_HxuaejrthQdydjsRIy-FpXpGb86cLh_E,365
 valor_lite/classification/utilities.py,sha256=jAcir7dW-o4I2gk_NEmlRr8j8Iniyyq9QT5j3PMxVHk,6435
 valor_lite/object_detection/__init__.py,sha256=eSrVAOpSykk1CfHXIKy1necplonUGxjyVKyDQ5UZoBQ,343
 valor_lite/object_detection/annotation.py,sha256=LVec-rIk408LuFxcOoIkPk0QZMWSSxbmsady4wapC1s,7007
 valor_lite/object_detection/computation.py,sha256=njLN-1_yql56NSVxY4KGKohxJUIStPYczVTpEpj5geA,24478
-valor_lite/object_detection/manager.py,sha256=-DayHeOirI23pYCp2SqMv4EmsqYuADR95qXt1JMoNo8,27444
+valor_lite/object_detection/manager.py,sha256=HfSbq4vfKv2Q3kBRIqpBbq7VCrOxCl7_Pd80yUl6TKQ,30053
 valor_lite/object_detection/metric.py,sha256=sUYSZwXYfIyfmXG6_7Tje1_ZL_QwvecPq85jrGmwOWE,22739
 valor_lite/object_detection/utilities.py,sha256=tNdv5dL7JhzOamGQkZ8x3ocZoTwPI6K8rcRAGMhp2nc,11217
 valor_lite/semantic_segmentation/__init__.py,sha256=3YdItCThY_tW23IChCBm-R0zahnbZ06JDVjs-gQLVes,293
-valor_lite/semantic_segmentation/annotation.py,sha256=XRMV32Sx9A1bAVMFQdBGc3tN5Xz2RfmlyKGXCzdee7A,3705
+valor_lite/semantic_segmentation/annotation.py,sha256=KrDqmSVzBsutxEdh0Kl8VqcEpTe4S68UdkVg-nyxcFg,4025
 valor_lite/semantic_segmentation/benchmark.py,sha256=uxd0SiDY3npsgU5pdeT4HvNP_au9GVRWzoqT6br9DtM,5961
 valor_lite/semantic_segmentation/computation.py,sha256=ZO0qAFmq8lN73UjCyiynSv18qQDtn35FNOmvuXY4rOw,7380
-valor_lite/semantic_segmentation/manager.py,sha256=NAm7u1HNwPnBbZBSMX_A51f5jUB578-4ZDmBbpeAe7M,13299
+valor_lite/semantic_segmentation/manager.py,sha256=h5w8Xl-O9gZxAzqT-ESofVE2th7d3cYahx4hHBic3pw,14256
 valor_lite/semantic_segmentation/metric.py,sha256=T9RfPJf4WgqGQTXYvSy08vJG5bjXXJnyYZeW0mlxMa8,7132
 valor_lite/semantic_segmentation/utilities.py,sha256=zgVmV8nyKWQK-T4Ov8cZFQzOmTKc5EL7errKFvc2H0g,2957
 valor_lite/text_generation/__init__.py,sha256=pGhpWCSZjLM0pPHCtPykAfos55B8ie3mi9EzbNxfj-U,356
@@ -35,7 +35,7 @@ valor_lite/text_generation/llm/instructions.py,sha256=fz2onBZZWcl5W8iy7zEWkPGU9N
 valor_lite/text_generation/llm/integrations.py,sha256=-rTfdAjq1zH-4ixwYuMQEOQ80pIFzMTe0BYfroVx3Pg,6974
 valor_lite/text_generation/llm/utilities.py,sha256=bjqatGgtVTcl1PrMwiDKTYPGJXKrBrx7PDtzIblGSys,1178
 valor_lite/text_generation/llm/validators.py,sha256=Wzr5RlfF58_2wOU-uTw7C8skan_fYdhy4Gfn0jSJ8HM,2700
-valor_lite-0.36.3.dist-info/METADATA,sha256=My77v0oKGoLJuhNu26YD_Q2dKJGTLTbmsJtYGwGDomA,5071
-valor_lite-0.36.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-valor_lite-0.36.3.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
-valor_lite-0.36.3.dist-info/RECORD,,
+valor_lite-0.36.5.dist-info/METADATA,sha256=Ttur0Z2wqHuaN6cOYousNZUqBL9A9qZFEnZejPSFRdo,5071
+valor_lite-0.36.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+valor_lite-0.36.5.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
+valor_lite-0.36.5.dist-info/RECORD,,