dataeval 0.84.0__py3-none-any.whl → 0.84.1__py3-none-any.whl

dataeval/metrics/stats/_base.py

@@ -10,7 +10,7 @@ from copy import deepcopy
 from dataclasses import dataclass
 from functools import partial
 from multiprocessing import Pool
-from typing import Any, Callable, Generic, Iterable, Sequence, TypeVar, cast
+from typing import Any, Callable, Generic, Iterable, Sequence, TypeVar
 
 import numpy as np
 import tqdm
@@ -19,7 +19,7 @@ from numpy.typing import NDArray
 from dataeval.config import get_max_processes
 from dataeval.outputs._stats import BaseStatsOutput, SourceIndex
 from dataeval.typing import Array, ArrayLike, Dataset, ObjectDetectionTarget
-from dataeval.utils._array import to_numpy
+from dataeval.utils._array import as_numpy, to_numpy
 from dataeval.utils._image import normalize_image_shape, rescale
 
 DTYPE_REGEX = re.compile(r"NDArray\[np\.(.*?)\]")
@@ -138,19 +138,19 @@ def process_stats(
 
 
 def process_stats_unpack(
-    args: tuple[int, Array, list[BoundingBox] | None],
+    args: tuple[int, ArrayLike, list[BoundingBox] | None],
     per_channel: bool,
     stats_processor_cls: Iterable[type[StatsProcessor[TStatsOutput]]],
 ) -> StatsProcessorOutput:
     return process_stats(*args, per_channel=per_channel, stats_processor_cls=stats_processor_cls)
 
 
-def _enumerate(dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]], per_box: bool):
+def _enumerate(dataset: Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]], per_box: bool):
     for i in range(len(dataset)):
         d = dataset[i]
         image = d[0] if isinstance(d, tuple) else d
         if per_box and isinstance(d, tuple) and isinstance(d[1], ObjectDetectionTarget):
-            boxes = cast(Array, d[1].boxes)
+            boxes = d[1].boxes if isinstance(d[1].boxes, Array) else as_numpy(d[1].boxes)
             target = [BoundingBox(float(box[i]) for i in range(4)) for box in boxes]
         else:
             target = None
@@ -159,7 +159,7 @@ def _enumerate(dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]], per_bo
 
 
 def run_stats(
-    dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]],
+    dataset: Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]],
     per_box: bool,
     per_channel: bool,
     stats_processor_cls: Iterable[type[StatsProcessor[TStatsOutput]]],
@@ -173,7 +173,7 @@ def run_stats(
 
     Parameters
     ----------
-    data : Dataset[Array] | Dataset[tuple[Array, Any, Any]]
+    data : Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]]
         A dataset of images and targets to compute statistics on.
     per_box : bool
         A flag which determines if the statistics should be evaluated on a per-box basis or not.

dataeval/metrics/stats/_dimensionstats.py

@@ -9,7 +9,7 @@ import numpy as np
 from dataeval.metrics.stats._base import StatsProcessor, run_stats
 from dataeval.outputs import DimensionStatsOutput
 from dataeval.outputs._base import set_metadata
-from dataeval.typing import Array, Dataset
+from dataeval.typing import ArrayLike, Dataset
 from dataeval.utils._image import get_bitdepth
 
 
@@ -34,7 +34,7 @@ class DimensionStatsProcessor(StatsProcessor[DimensionStatsOutput]):
 
 @set_metadata
 def dimensionstats(
-    dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]],
+    dataset: Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]],
     *,
     per_box: bool = False,
 ) -> DimensionStatsOutput:

dataeval/metrics/stats/_hashstats.py

@@ -14,7 +14,7 @@ from scipy.fftpack import dct
 from dataeval.metrics.stats._base import StatsProcessor, run_stats
 from dataeval.outputs import HashStatsOutput
 from dataeval.outputs._base import set_metadata
-from dataeval.typing import Array, ArrayLike, Dataset
+from dataeval.typing import ArrayLike, Dataset
 from dataeval.utils._array import as_numpy
 from dataeval.utils._image import normalize_image_shape, rescale
 
@@ -105,7 +105,7 @@ class HashStatsProcessor(StatsProcessor[HashStatsOutput]):
 
 @set_metadata
 def hashstats(
-    dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]],
+    dataset: Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]],
     *,
     per_box: bool = False,
 ) -> HashStatsOutput:

dataeval/metrics/stats/_imagestats.py

@@ -10,12 +10,12 @@ from dataeval.metrics.stats._pixelstats import PixelStatsProcessor
 from dataeval.metrics.stats._visualstats import VisualStatsProcessor
 from dataeval.outputs import ChannelStatsOutput, ImageStatsOutput
 from dataeval.outputs._base import set_metadata
-from dataeval.typing import Array, Dataset
+from dataeval.typing import ArrayLike, Dataset
 
 
 @overload
 def imagestats(
-    dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]],
+    dataset: Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]],
     *,
     per_box: bool = False,
     per_channel: Literal[True],
@@ -24,7 +24,7 @@ def imagestats(
 
 @overload
 def imagestats(
-    dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]],
+    dataset: Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]],
     *,
     per_box: bool = False,
     per_channel: Literal[False] = False,
@@ -33,7 +33,7 @@ def imagestats(
 
 @set_metadata
 def imagestats(
-    dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]],
+    dataset: Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]],
     *,
     per_box: bool = False,
     per_channel: bool = False,

dataeval/metrics/stats/_pixelstats.py

@@ -10,7 +10,7 @@ from scipy.stats import entropy, kurtosis, skew
 from dataeval.metrics.stats._base import StatsProcessor, run_stats
 from dataeval.outputs import PixelStatsOutput
 from dataeval.outputs._base import set_metadata
-from dataeval.typing import Array, Dataset
+from dataeval.typing import ArrayLike, Dataset
 
 
 class PixelStatsProcessor(StatsProcessor[PixelStatsOutput]):
@@ -37,7 +37,7 @@ class PixelStatsProcessor(StatsProcessor[PixelStatsOutput]):
 
 @set_metadata
 def pixelstats(
-    dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]],
+    dataset: Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]],
     *,
     per_box: bool = False,
     per_channel: bool = False,

dataeval/metrics/stats/_visualstats.py

@@ -9,7 +9,7 @@ import numpy as np
 from dataeval.metrics.stats._base import StatsProcessor, run_stats
 from dataeval.outputs import VisualStatsOutput
 from dataeval.outputs._base import set_metadata
-from dataeval.typing import Array, Dataset
+from dataeval.typing import ArrayLike, Dataset
 from dataeval.utils._image import edge_filter
 
 QUARTILES = (0, 25, 50, 75, 100)
@@ -44,7 +44,7 @@ class VisualStatsProcessor(StatsProcessor[VisualStatsOutput]):
 
 @set_metadata
 def visualstats(
-    dataset: Dataset[Array] | Dataset[tuple[Array, Any, Any]],
+    dataset: Dataset[ArrayLike] | Dataset[tuple[ArrayLike, Any, Any]],
     *,
     per_box: bool = False,
     per_channel: bool = False,

dataeval/typing.py

@@ -21,8 +21,9 @@ __all__ = [
 
 
 import sys
-from typing import Any, Generic, Iterator, Protocol, Sequence, TypedDict, TypeVar, Union, runtime_checkable
+from typing import Any, Generic, Iterator, Protocol, TypedDict, TypeVar, runtime_checkable
 
+import numpy.typing
 from typing_extensions import NotRequired, ReadOnly, Required
 
 if sys.version_info >= (3, 10):
@@ -31,6 +32,16 @@ else:
     from typing_extensions import TypeAlias
 
 
+ArrayLike: TypeAlias = numpy.typing.ArrayLike
+"""
+Type alias for a `Union` representing objects that can be coerced into an array.
+
+See Also
+--------
+`NumPy ArrayLike <https://numpy.org/doc/stable/reference/typing.html#numpy.typing.ArrayLike>`_
+"""
+
+
 @runtime_checkable
 class Array(Protocol):
     """
@@ -67,16 +78,8 @@ class Array(Protocol):
     def __len__(self) -> int: ...
 
 
-T = TypeVar("T")
+_T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
-_ScalarType = Union[int, float, bool, str]
-ArrayLike: TypeAlias = Union[Sequence[_ScalarType], Sequence[Sequence[_ScalarType]], Sequence[Array], Array]
-"""
-Type alias for array-like objects used for interoperability with DataEval.
-
-This includes native Python sequences, as well as objects that conform to
-the :class:`Array` protocol.
-"""
 
 
 class DatasetMetadata(TypedDict, total=False):
@@ -140,12 +143,12 @@ class AnnotatedDataset(Dataset[_T_co], Generic[_T_co], Protocol):
 # ========== IMAGE CLASSIFICATION DATASETS ==========
 
 
-ImageClassificationDatum: TypeAlias = tuple[Array, Array, dict[str, Any]]
+ImageClassificationDatum: TypeAlias = tuple[ArrayLike, ArrayLike, dict[str, Any]]
 """
 Type alias for an image classification datum tuple.
 
-- :class:`Array` of shape (C, H, W) - Image data in channel, height, width format.
-- :class:`Array` of shape (N,) - Class label as one-hot encoded ground-truth or prediction confidences.
+- :class:`ArrayLike` of shape (C, H, W) - Image data in channel, height, width format.
+- :class:`ArrayLike` of shape (N,) - Class label as one-hot encoded ground-truth or prediction confidences.
 - dict[str, Any] - Datum level metadata.
 """
 
@@ -180,11 +183,11 @@ class ObjectDetectionTarget(Protocol):
     def scores(self) -> ArrayLike: ...
 
 
-ObjectDetectionDatum: TypeAlias = tuple[Array, ObjectDetectionTarget, dict[str, Any]]
+ObjectDetectionDatum: TypeAlias = tuple[ArrayLike, ObjectDetectionTarget, dict[str, Any]]
 """
 Type alias for an object detection datum tuple.
 
-- :class:`Array` of shape (C, H, W) - Image data in channel, height, width format.
+- :class:`ArrayLike` of shape (C, H, W) - Image data in channel, height, width format.
 - :class:`ObjectDetectionTarget` - Object detection target information for the image.
 - dict[str, Any] - Datum level metadata.
 """
@@ -221,11 +224,11 @@ class SegmentationTarget(Protocol):
     def scores(self) -> ArrayLike: ...
 
 
-SegmentationDatum: TypeAlias = tuple[Array, SegmentationTarget, dict[str, Any]]
+SegmentationDatum: TypeAlias = tuple[ArrayLike, SegmentationTarget, dict[str, Any]]
 """
 Type alias for an image classification datum tuple.
 
-- :class:`Array` of shape (C, H, W) - Image data in channel, height, width format.
+- :class:`ArrayLike` of shape (C, H, W) - Image data in channel, height, width format.
 - :class:`SegmentationTarget` - Segmentation target information for the image.
 - dict[str, Any] - Datum level metadata.
 """
@@ -237,7 +240,7 @@ Type alias for an :class:`AnnotatedDataset` of :class:`SegmentationDatum` elemen
 
 
 @runtime_checkable
-class Transform(Generic[T], Protocol):
+class Transform(Generic[_T], Protocol):
     """
     Protocol defining a transform function.
 
@@ -262,4 +265,4 @@ class Transform(Generic[T], Protocol):
     array([0.004, 0.008, 0.012])
     """
 
-    def __call__(self, data: T, /) -> T: ...
+    def __call__(self, data: _T, /) -> _T: ...

dataeval/utils/_array.py

@@ -92,7 +92,7 @@ def ensure_embeddings(
 @overload
 def ensure_embeddings(
     embeddings: T,
-    dtype: None,
+    dtype: None = None,
     unit_interval: Literal[True, False, "force"] = False,
 ) -> T: ...
 
@@ -152,21 +152,32 @@ def ensure_embeddings(
         return arr
 
 
-def flatten(array: ArrayLike) -> NDArray[Any]:
+@overload
+def flatten(array: torch.Tensor) -> torch.Tensor: ...
+@overload
+def flatten(array: ArrayLike) -> NDArray[Any]: ...
+
+
+def flatten(array: ArrayLike) -> NDArray[Any] | torch.Tensor:
     """
     Flattens input array from (N, ... ) to (N, -1) where all samples N have all data in their last dimension
 
     Parameters
     ----------
-    X : NDArray, shape - (N, ... )
+    array : ArrayLike
         Input array
 
     Returns
     -------
-    NDArray, shape - (N, -1)
+    np.ndarray or torch.Tensor, shape: (N, -1)
     """
-    nparr = as_numpy(array)
-    return nparr.reshape((nparr.shape[0], -1))
+    if isinstance(array, np.ndarray):
+        nparr = as_numpy(array)
+        return nparr.reshape((nparr.shape[0], -1))
+    elif isinstance(array, torch.Tensor):
+        return torch.flatten(array, start_dim=1)
+    else:
+        raise TypeError(f"Unsupported array type {type(array)}.")
 
 
 _TArray = TypeVar("_TArray", bound=Array)
@@ -191,4 +202,4 @@ def channels_first_to_last(array: _TArray) -> _TArray:
     elif isinstance(array, torch.Tensor):
         return torch.permute(array, (1, 2, 0))
     else:
-        raise TypeError(f"Unsupported array type {type(array)} for conversion.")
+        raise TypeError(f"Unsupported array type {type(array)}.")

dataeval/utils/data/_dataset.py

@@ -52,10 +52,12 @@ def _validate_data(
 
 
 def _find_max(arr: ArrayLike) -> Any:
-    if isinstance(arr[0], (Iterable, Sequence, Array)):
-        return max([_find_max(x) for x in arr])  # type: ignore
-    else:
-        return max(arr)
+    if isinstance(arr, (Iterable, Sequence, Array)):
+        if isinstance(arr[0], (Iterable, Sequence, Array)):
+            return max([_find_max(x) for x in arr])  # type: ignore
+        else:
+            return max(arr)
+    return arr
 
 
 _TLabels = TypeVar("_TLabels", Sequence[int], Sequence[Sequence[int]])

dataeval/utils/data/_embeddings.py

@@ -6,11 +6,13 @@ import math
 from typing import Any, Iterator, Sequence, cast
 
 import torch
+from numpy.typing import NDArray
 from torch.utils.data import DataLoader, Subset
 from tqdm import tqdm
 
 from dataeval.config import DeviceLike, get_device
-from dataeval.typing import Array, Dataset, Transform
+from dataeval.typing import Array, ArrayLike, Dataset, Transform
+from dataeval.utils._array import as_numpy
 from dataeval.utils.torch.models import SupportsEncode
 
 
@@ -45,7 +47,7 @@ class Embeddings:
 
     def __init__(
         self,
-        dataset: Dataset[tuple[Array, Any, Any]],
+        dataset: Dataset[tuple[ArrayLike, Any, Any]] | Dataset[ArrayLike],
         batch_size: int,
         transforms: Transform[torch.Tensor] | Sequence[Transform[torch.Tensor]] | None = None,
         model: torch.nn.Module | None = None,
@@ -62,9 +64,9 @@ class Embeddings:
         self._length = len(dataset)
         model = torch.nn.Flatten() if model is None else model
         self._transforms = [transforms] if isinstance(transforms, Transform) else transforms
-        self._model = model.to(self.device).eval()
+        self._model = model.to(self.device).eval() if isinstance(model, torch.nn.Module) else model
         self._encoder = model.encode if isinstance(model, SupportsEncode) else model
-        self._collate_fn = lambda datum: [torch.as_tensor(i) for i, _, _ in datum]
+        self._collate_fn = lambda datum: [torch.as_tensor(d[0] if isinstance(d, tuple) else d) for d in datum]
         self._cached_idx = set()
         self._embeddings: torch.Tensor = torch.empty(())
         self._shallow: bool = False
@@ -91,14 +93,50 @@ class Embeddings:
         else:
             return self[:]
 
+    def to_numpy(self, indices: Sequence[int] | None = None) -> NDArray[Any]:
+        """
+        Converts dataset to embeddings as numpy array.
+
+        Parameters
+        ----------
+        indices : Sequence[int] or None, default None
+            The indices to convert to embeddings
+
+        Returns
+        -------
+        NDArray[Any]
+
+        Warning
+        -------
+        Processing large quantities of data can be resource intensive.
+        """
+        return self.to_tensor(indices).cpu().numpy()
+
+    def new(self, dataset: Dataset[tuple[ArrayLike, Any, Any]] | Dataset[ArrayLike]) -> Embeddings:
+        """
+        Creates a new Embeddings object with the same parameters but a different dataset.
+
+        Parameters
+        ----------
+        dataset : ImageClassificationDataset or ObjectDetectionDataset
+            Dataset to access original images from.
+
+        Returns
+        -------
+        Embeddings
+        """
+        return Embeddings(
+            dataset, self.batch_size, self._transforms, self._model, self.device, self.cache, self.verbose
+        )
+
     @classmethod
-    def from_array(cls, array: Array, device: DeviceLike | None = None) -> Embeddings:
+    def from_array(cls, array: ArrayLike, device: DeviceLike | None = None) -> Embeddings:
         """
         Instantiates a shallow Embeddings object using an array.
 
         Parameters
         ----------
-        array : Array
+        array : ArrayLike
             The array to convert to embeddings.
         device : DeviceLike or None, default None
             The hardware device to use if specified, otherwise uses the DataEval
@@ -118,6 +156,7 @@ class Embeddings:
         torch.Size([100, 3, 224, 224])
         """
         embeddings = Embeddings([], 0, None, None, device, True, False)
+        array = array if isinstance(array, Array) else as_numpy(array)
         embeddings._length = len(array)
         embeddings._cached_idx = set(range(len(array)))
         embeddings._embeddings = torch.as_tensor(array).to(get_device(device))
@@ -131,7 +170,7 @@ class Embeddings:
 
     @torch.no_grad()  # Reduce overhead cost by not tracking tensor gradients
     def _batch(self, indices: Sequence[int]) -> Iterator[torch.Tensor]:
-        dataset = cast(torch.utils.data.Dataset[tuple[Array, Any, Any]], self._dataset)
+        dataset = cast(torch.utils.data.Dataset, self._dataset)
         total_batches = math.ceil(len(indices) / self.batch_size)
 
         # If not caching, process all indices normally

dataeval/utils/data/_images.py

@@ -4,13 +4,13 @@ __all__ = []
 
 from typing import TYPE_CHECKING, Any, Generic, Iterator, Sequence, TypeVar, cast, overload
 
-from dataeval.typing import Array, Dataset
+from dataeval.typing import Array, ArrayLike, Dataset
 from dataeval.utils._array import as_numpy, channels_first_to_last
 
 if TYPE_CHECKING:
     from matplotlib.figure import Figure
 
-T = TypeVar("T", bound=Array)
+T = TypeVar("T", Array, ArrayLike)
 
 
 class Images(Generic[T]):

dataeval/utils/data/_metadata.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 __all__ = []
 
 import warnings
-from typing import TYPE_CHECKING, Any, Literal, Mapping, Sequence, cast
+from typing import TYPE_CHECKING, Any, Literal, Mapping, Sequence, Sized, cast
 
 import numpy as np
 from numpy.typing import NDArray
@@ -208,8 +208,9 @@ class Metadata:
             raw.append(metadata)
 
             if is_od_target := isinstance(target, ObjectDetectionTarget):
-                target_len = len(target.labels)
-                labels.extend(as_numpy(target.labels).tolist())
+                target_labels = as_numpy(target.labels)
+                target_len = len(target_labels)
+                labels.extend(target_labels.tolist())
                 bboxes.extend(as_numpy(target.boxes).tolist())
                 scores.extend(as_numpy(target.scores).tolist())
                 srcidx.extend([i] * target_len)
@@ -360,7 +361,7 @@ class Metadata:
         self._merge()
         self._processed = False
         target_len = len(self.targets.source) if self.targets.source is not None else len(self.targets)
-        if any(len(v) != target_len for v in factors.values()):
+        if any(len(v if isinstance(v, Sized) else as_numpy(v)) != target_len for v in factors.values()):
             raise ValueError(
                 "The lists/arrays in the provided factors have a different length than the current metadata factors."
             )

dataeval/utils/data/datasets/_base.py

@@ -19,9 +19,12 @@ from dataeval.utils.data.datasets._types import (
 )
 
 if TYPE_CHECKING:
-    from dataeval.typing import Transform
+    from dataeval.typing import Array, Transform
+
+    _TArray = TypeVar("_TArray", bound=Array)
+else:
+    _TArray = TypeVar("_TArray")
 
-_TArray = TypeVar("_TArray")
 _TTarget = TypeVar("_TTarget")
 _TRawTarget = TypeVar("_TRawTarget", list[int], list[str])
 
@@ -51,9 +54,9 @@ class BaseDataset(AnnotatedDataset[tuple[_TArray, _TTarget, dict[str, Any]]], Ge
     def __init__(
         self,
         root: str | Path,
-        download: bool = False,
-        image_set: Literal["train", "val", "test", "base"] = "train",
+        image_set: Literal["train", "val", "test", "operational", "base"] = "train",
         transforms: Transform[_TArray] | Sequence[Transform[_TArray]] | None = None,
+        download: bool = False,
         verbose: bool = False,
     ) -> None:
         self._root: Path = root.absolute() if isinstance(root, Path) else Path(root).absolute()

dataeval/utils/data/datasets/_cifar10.py

@@ -27,13 +27,13 @@ class CIFAR10(BaseICDataset[NDArray[Any]], BaseDatasetNumpyMixin):
     ----------
     root : str or pathlib.Path
         Root directory of dataset where the ``mnist`` folder exists.
-    download : bool, default False
-        If True, downloads the dataset from the internet and puts it in root directory.
-        Class checks to see if data is already downloaded to ensure it does not create a duplicate download.
     image_set : "train", "test" or "base", default "train"
         If "base", returns all of the data to allow the user to create their own splits.
     transforms : Transform, Sequence[Transform] or None, default None
         Transform(s) to apply to the data.
+    download : bool, default False
+        If True, downloads the dataset from the internet and puts it in root directory.
+        Class checks to see if data is already downloaded to ensure it does not create a duplicate download.
     verbose : bool, default False
         If True, outputs print statements.
 
@@ -43,16 +43,16 @@ class CIFAR10(BaseICDataset[NDArray[Any]], BaseDatasetNumpyMixin):
         Location of the folder containing the data.
     image_set : "train", "test" or "base"
         The selected image set from the dataset.
+    transforms : Sequence[Transform]
+        The transforms to be applied to the data.
+    size : int
+        The size of the dataset.
     index2label : dict[int, str]
         Dictionary which translates from class integers to the associated class strings.
     label2index : dict[str, int]
         Dictionary which translates from class strings to the associated class integers.
     metadata : DatasetMetadata
         Typed dictionary containing dataset metadata, such as `id` which returns the dataset class name.
-    transforms : Sequence[Transform]
-        The transforms to be applied to the data.
-    size : int
-        The size of the dataset.
     """
 
     _resources = [
@@ -80,16 +80,16 @@ class CIFAR10(BaseICDataset[NDArray[Any]], BaseDatasetNumpyMixin):
     def __init__(
         self,
         root: str | Path,
-        download: bool = False,
         image_set: Literal["train", "test", "base"] = "train",
         transforms: Transform[NDArray[Any]] | Sequence[Transform[NDArray[Any]]] | None = None,
+        download: bool = False,
         verbose: bool = False,
     ) -> None:
         super().__init__(
             root,
-            download,
             image_set,
             transforms,
+            download,
             verbose,
         )