dataeval 0.70.1__py3-none-any.whl → 0.71.1__py3-none-any.whl

dataeval/__init__.py

@@ -1,8 +1,9 @@
-__version__ = "0.70.1"
+__version__ = "0.71.1"
 
 from importlib.util import find_spec
 
 _IS_TORCH_AVAILABLE = find_spec("torch") is not None
+_IS_TORCHVISION_AVAILABLE = find_spec("torchvision") is not None
 _IS_TENSORFLOW_AVAILABLE = find_spec("tensorflow") is not None and find_spec("tensorflow_probability") is not None
 
 del find_spec

dataeval/_internal/detectors/ood/ae.py

@@ -10,9 +10,9 @@ from __future__ import annotations
 
 from typing import Callable
 
-import keras
 import numpy as np
 import tensorflow as tf
+import tf_keras as keras
 from numpy.typing import ArrayLike
 
 from dataeval._internal.detectors.ood.base import OODBase, OODScoreOutput

dataeval/_internal/detectors/ood/aegmm.py

@@ -10,8 +10,8 @@ from __future__ import annotations
 
 from typing import Callable
 
-import keras
 import tensorflow as tf
+import tf_keras as keras
 from numpy.typing import ArrayLike
 
 from dataeval._internal.detectors.ood.base import OODGMMBase, OODScoreOutput

dataeval/_internal/detectors/ood/base.py

@@ -12,9 +12,9 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Callable, Literal, cast
 
-import keras
 import numpy as np
 import tensorflow as tf
+import tf_keras as keras
 from numpy.typing import ArrayLike, NDArray
 
 from dataeval._internal.interop import to_numpy

dataeval/_internal/detectors/ood/llr.py

@@ -11,12 +11,12 @@ from __future__ import annotations
 from functools import partial
 from typing import Callable
 
-import keras
 import numpy as np
 import tensorflow as tf
-from keras.layers import Input
-from keras.models import Model
+import tf_keras as keras
 from numpy.typing import ArrayLike, NDArray
+from tf_keras.layers import Input
+from tf_keras.models import Model
 
 from dataeval._internal.detectors.ood.base import OODBase, OODScoreOutput
 from dataeval._internal.interop import to_numpy

dataeval/_internal/detectors/ood/vae.py

@@ -10,9 +10,9 @@ from __future__ import annotations
 
 from typing import Callable
 
-import keras
 import numpy as np
 import tensorflow as tf
+import tf_keras as keras
 from numpy.typing import ArrayLike
 
 from dataeval._internal.detectors.ood.base import OODBase, OODScoreOutput

dataeval/_internal/detectors/ood/vaegmm.py

@@ -10,9 +10,9 @@ from __future__ import annotations
 
 from typing import Callable
 
-import keras
 import numpy as np
 import tensorflow as tf
+import tf_keras as keras
 from numpy.typing import ArrayLike
 
 from dataeval._internal.detectors.ood.base import OODGMMBase, OODScoreOutput

dataeval/_internal/detectors/outliers.py

@@ -147,7 +147,7 @@ class Outliers:
                 mask = _get_outlier_mask(values.astype(np.float64), self.outlier_method, self.outlier_threshold)
                 indices = np.flatnonzero(mask)
                 for i, value in zip(indices, values[mask]):
-                    flagged_images.setdefault(i, {}).update({stat: value})
+                    flagged_images.setdefault(int(i), {}).update({stat: value})
 
         return dict(sorted(flagged_images.items()))
 
@@ -261,11 +261,6 @@ class Outliers:
         >>> results.issues[10]
         {'skew': -3.906, 'kurtosis': 13.266, 'entropy': 0.2128, 'contrast': 1.25, 'zeros': 0.05493}
         """
-        self.stats = datasetstats(
-            images=data,
-            use_dimension=self.use_dimension,
-            use_pixel=self.use_pixel,
-            use_visual=self.use_visual,
-        )
-        outliers = self._get_outliers({k: v for o in self.stats.outputs() for k, v in o.dict().items()})
+        self.stats = datasetstats(images=data)
+        outliers = self._get_outliers(self.stats.dict())
         return OutliersOutput(outliers)

dataeval/_internal/metrics/stats/base.py

@@ -3,9 +3,13 @@ from __future__ import annotations
 import re
 import warnings
 from dataclasses import dataclass
-from typing import Any, Callable, Iterable, NamedTuple, Optional, Union
+from functools import partial
+from itertools import repeat
+from multiprocessing import Pool
+from typing import Any, Callable, Generic, Iterable, NamedTuple, Optional, TypeVar, Union
 
 import numpy as np
+import tqdm
 from numpy.typing import ArrayLike, NDArray
 
 from dataeval._internal.interop import to_numpy_iter
@@ -91,7 +95,11 @@ class BaseStatsOutput(OutputMetadata):
         return len(self.source_index)
 
 
-class StatsProcessor:
+TStatsOutput = TypeVar("TStatsOutput", bound=BaseStatsOutput, covariant=True)
+
+
+class StatsProcessor(Generic[TStatsOutput]):
+    output_class: type[TStatsOutput]
     cache_keys: list[str] = []
     image_function_map: dict[str, Callable[[StatsProcessor], Any]] = {}
     channel_function_map: dict[str, Callable[[StatsProcessor], Any]] = {}
@@ -119,6 +127,9 @@ class StatsProcessor:
         else:
             return self.fn_map[fn_key](self)
 
+    def process(self) -> dict:
+        return {k: self.fn_map[k](self) for k in self.fn_map}
+
     @property
     def image(self) -> NDArray:
         if self._image is None:
@@ -143,14 +154,66 @@ class StatsProcessor:
                 self._scaled = self._scaled.reshape(self.image.shape[0], -1)
         return self._scaled
 
+    @classmethod
+    def convert_output(
+        cls, source: dict[str, Any], source_index: list[SourceIndex], box_count: list[int]
+    ) -> TStatsOutput:
+        output = {}
+        for key in source:
+            if key not in cls.output_class.__annotations__:
+                continue
+            stat_type: str = cls.output_class.__annotations__[key]
+            dtype_match = re.match(DTYPE_REGEX, stat_type)
+            if dtype_match is not None:
+                output[key] = np.asarray(source[key], dtype=np.dtype(dtype_match.group(1)))
+            else:
+                output[key] = source[key]
+        return cls.output_class(**output, source_index=source_index, box_count=np.asarray(box_count, dtype=np.uint16))
+
+
+class StatsProcessorOutput(NamedTuple):
+    results: list[dict[str, Any]]
+    source_indices: list[SourceIndex]
+    box_counts: list[int]
+    warnings_list: list[tuple[int, int, NDArray, tuple[int, ...]]]
+
+
+def process_stats(
+    i: int,
+    image_boxes: tuple[NDArray, NDArray | None],
+    per_channel: bool,
+    stats_processor_cls: Iterable[type[StatsProcessor]],
+) -> StatsProcessorOutput:
+    image, boxes = image_boxes
+    results_list: list[dict[str, Any]] = []
+    source_indices: list[SourceIndex] = []
+    box_counts: list[int] = []
+    warnings_list: list[tuple[int, int, NDArray, tuple[int, ...]]] = []
+    nboxes = [None] if boxes is None else normalize_box_shape(boxes)
+    for i_b, box in enumerate(nboxes):
+        i_b = None if box is None else i_b
+        processor_list = [p(image, box, per_channel) for p in stats_processor_cls]
+        if any(not p.is_valid_slice for p in processor_list) and i_b is not None and box is not None:
+            warnings_list.append((i, i_b, box, image.shape))
+        results_list.append({k: v for p in processor_list for k, v in p.process().items()})
+        if per_channel:
+            source_indices.extend([SourceIndex(i, i_b, c) for c in range(image_boxes[0].shape[-3])])
+        else:
+            source_indices.append(SourceIndex(i, i_b, None))
+    box_counts.append(0 if boxes is None else len(boxes))
+    return StatsProcessorOutput(results_list, source_indices, box_counts, warnings_list)
+
+
+def process_stats_unpack(args, per_channel: bool, stats_processor_cls: Iterable[type[StatsProcessor]]):
+    return process_stats(*args, per_channel=per_channel, stats_processor_cls=stats_processor_cls)
+
 
 def run_stats(
     images: Iterable[ArrayLike],
     bboxes: Iterable[ArrayLike] | None,
     per_channel: bool,
-    stats_processor_cls: type,
-    output_cls: type,
-) -> dict:
+    stats_processor_cls: Iterable[type[StatsProcessor[TStatsOutput]]],
+) -> list[TStatsOutput]:
     """
     Compute specified statistics on a set of images.
 
@@ -169,15 +232,13 @@ def run_stats(
         iterable should match the length of the input images.
     per_channel : bool
         A flag which determines if the states should be evaluated on a per-channel basis or not.
-    output_cls : type
-        The output class for which stats values will be calculated.
+    stats_processor_cls : Iterable[type[StatsProcessor]]
+        An iterable of stats processor classes that calculate stats and return output classes.
 
     Returns
     -------
-    dict[str, NDArray]]
-        A dictionary containing the computed statistics for each image.
-        The dictionary keys correspond to the names of the statistics, and the values are NumPy arrays
-        with the results of the computations.
+    list[TStatsOutput]
+        A list of output classes corresponding to the input processor types.
 
     Note
     ----
@@ -189,43 +250,41 @@ def run_stats(
       be reused to avoid redundant computation.
     """
     results_list: list[dict[str, NDArray]] = []
-    output_list = list(output_cls.__annotations__)
     source_index = []
     box_count = []
-    bbox_iter = (None for _ in images) if bboxes is None else to_numpy_iter(bboxes)
-
-    for i, (boxes, image) in enumerate(zip(bbox_iter, to_numpy_iter(images))):
-        nboxes = [None] if boxes is None else normalize_box_shape(boxes)
-        for i_b, box in enumerate(nboxes):
-            i_b = None if box is None else i_b
-            processor: StatsProcessor = stats_processor_cls(image, box, per_channel)
-            if not processor.is_valid_slice:
-                warnings.warn(f"Bounding box {i_b}: {box} is out of bounds of image {i}: {image.shape}.")
-            results_list.append({stat: processor.get(stat) for stat in output_list})
-            if per_channel:
-                source_index.extend([SourceIndex(i, i_b, c) for c in range(image.shape[-3])])
-            else:
-                source_index.append(SourceIndex(i, i_b, None))
-        box_count.append(0 if boxes is None else len(boxes))
+    bbox_iter = repeat(None) if bboxes is None else to_numpy_iter(bboxes)
+
+    warning_list = []
+    total_for_status = getattr(images, "__len__")() if hasattr(images, "__len__") else None
+    stats_processor_cls = stats_processor_cls if isinstance(stats_processor_cls, Iterable) else [stats_processor_cls]
+
+    # TODO: Introduce global controls for CPU job parallelism and GPU configurations
+    with Pool(16) as p:
+        for r in tqdm.tqdm(
+            p.imap(
+                partial(process_stats_unpack, per_channel=per_channel, stats_processor_cls=stats_processor_cls),
+                enumerate(zip(to_numpy_iter(images), bbox_iter)),
+            ),
+            total=total_for_status,
+        ):
+            results_list.extend(r.results)
+            source_index.extend(r.source_indices)
+            box_count.extend(r.box_counts)
+            warning_list.extend(r.warnings_list)
+    p.close()
+    p.join()
+
+    # warnings are not emitted while in multiprocessing pools so we emit after gathering all warnings
+    for w in warning_list:
+        warnings.warn(f"Bounding box [{w[0]}][{w[1]}]: {w[2]} is out of bounds of {w[3]}.", UserWarning)
 
     output = {}
-    if per_channel:
-        for i, results in enumerate(results_list):
-            for stat, result in results.items():
+    for results in results_list:
+        for stat, result in results.items():
+            if per_channel:
                 output.setdefault(stat, []).extend(result.tolist())
-    else:
-        for results in results_list:
-            for stat, result in results.items():
+            else:
                 output.setdefault(stat, []).append(result.tolist() if isinstance(result, np.ndarray) else result)
 
-    for stat in output:
-        stat_type: str = output_cls.__annotations__[stat]
-
-        dtype_match = re.match(DTYPE_REGEX, stat_type)
-        if dtype_match is not None:
-            output[stat] = np.asarray(output[stat], dtype=np.dtype(dtype_match.group(1)))
-
-    output[SOURCE_INDEX] = source_index
-    output[BOX_COUNT] = np.asarray(box_count, dtype=np.uint16)
-
-    return output
+    outputs = [s.convert_output(output, source_index, box_count) for s in stats_processor_cls]
+    return outputs

dataeval/_internal/metrics/stats/datasetstats.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Iterable
+from typing import Any, Iterable
 
 from numpy.typing import ArrayLike
 
-from dataeval._internal.metrics.stats.base import BaseStatsOutput
-from dataeval._internal.metrics.stats.dimensionstats import DimensionStatsOutput, dimensionstats
+from dataeval._internal.metrics.stats.base import BaseStatsOutput, run_stats
+from dataeval._internal.metrics.stats.dimensionstats import (
+    DimensionStatsOutput,
+    DimensionStatsProcessor,
+)
 from dataeval._internal.metrics.stats.labelstats import LabelStatsOutput, labelstats
-from dataeval._internal.metrics.stats.pixelstats import PixelStatsOutput, pixelstats
-from dataeval._internal.metrics.stats.visualstats import VisualStatsOutput, visualstats
+from dataeval._internal.metrics.stats.pixelstats import PixelStatsOutput, PixelStatsProcessor
+from dataeval._internal.metrics.stats.visualstats import VisualStatsOutput, VisualStatsProcessor
 from dataeval._internal.output import OutputMetadata, set_metadata
 
 
@@ -25,19 +28,53 @@ class DatasetStatsOutput(OutputMetadata):
 
     Attributes
     ----------
-    dimensionstats : DimensionStatsOutput or None
-    pixelstats: PixelStatsOutput or None
-    visualstats: VisualStatsOutput or None
-    labelstats: LabelStatsOutput or None, default None
+    dimensionstats : DimensionStatsOutput
+    pixelstats: PixelStatsOutput
+    visualstats: VisualStatsOutput
+    labelstats: LabelStatsOutput or None
     """
 
-    dimensionstats: DimensionStatsOutput | None
-    pixelstats: PixelStatsOutput | None
-    visualstats: VisualStatsOutput | None
+    dimensionstats: DimensionStatsOutput
+    pixelstats: PixelStatsOutput
+    visualstats: VisualStatsOutput
     labelstats: LabelStatsOutput | None = None
 
+    def outputs(self) -> list[OutputMetadata]:
+        return [s for s in (self.dimensionstats, self.pixelstats, self.visualstats, self.labelstats) if s is not None]
+
+    def dict(self) -> dict[str, Any]:
+        return {k: v for o in self.outputs() for k, v in o.dict().items()}
+
+    def __post_init__(self):
+        lengths = [len(s) for s in self.outputs() if isinstance(s, BaseStatsOutput)]
+        if not all(length == lengths[0] for length in lengths):
+            raise ValueError("All StatsOutput classes must contain the same number of image sources.")
+
+
+@dataclass(frozen=True)
+class ChannelStatsOutput(OutputMetadata):
+    """
+    Output class for :func:`channelstats` stats metric
+
+    This class represents the outputs of various per-channel stats functions against
+    a single dataset, such that each index across all stat outputs are representative
+    of the same source image.  Modifying or mixing outputs will result in inaccurate
+    outlier calculations if not created correctly.
+
+    Attributes
+    ----------
+    pixelstats: PixelStatsOutput
+    visualstats: VisualStatsOutput
+    """
+
+    pixelstats: PixelStatsOutput
+    visualstats: VisualStatsOutput
+
     def outputs(self) -> list[BaseStatsOutput]:
-        return [s for s in (self.dimensionstats, self.pixelstats, self.visualstats) if s is not None]
+        return [self.pixelstats, self.visualstats]
+
+    def dict(self) -> dict[str, Any]:
+        return {**self.pixelstats.dict(), **self.visualstats.dict()}
 
     def __post_init__(self):
         lengths = [len(s) for s in self.outputs()]
@@ -50,9 +87,6 @@ def datasetstats(
     images: Iterable[ArrayLike],
     bboxes: Iterable[ArrayLike] | None = None,
     labels: Iterable[ArrayLike] | None = None,
-    use_dimension: bool = True,
-    use_pixel: bool = True,
-    use_visual: bool = True,
 ) -> DatasetStatsOutput:
     """
     Calculates various statistics for each image
@@ -91,9 +125,47 @@ def datasetstats(
     [1.744   1.946   0.1164  0.0635  0.0633  0.06274 0.0429  0.0317  0.0317
      0.02576 0.02081 0.02171 0.01915 0.01767 0.01799 0.01595 0.01433 0.01478]
     """
-    return DatasetStatsOutput(
-        dimensionstats(images, bboxes) if use_dimension else None,
-        pixelstats(images, bboxes) if use_pixel else None,
-        visualstats(images, bboxes) if use_visual else None,
-        labelstats(labels) if labels else None,
-    )
+    outputs = run_stats(images, bboxes, False, [DimensionStatsProcessor, PixelStatsProcessor, VisualStatsProcessor])
+    return DatasetStatsOutput(*outputs, labelstats=labelstats(labels) if labels else None)  # type: ignore
+
+
+@set_metadata("dataeval.metrics")
+def channelstats(
+    images: Iterable[ArrayLike],
+    bboxes: Iterable[ArrayLike] | None = None,
+) -> ChannelStatsOutput:
+    """
+    Calculates various per-channel statistics for each image
+
+    This function computes pixel and visual metrics on the images
+    or individual bounding boxes for each image.
+
+    Parameters
+    ----------
+    images : Iterable[ArrayLike]
+        Images to perform calculations on
+    bboxes : Iterable[ArrayLike] or None
+        Bounding boxes in `xyxy` format for each image to perform calculations on
+
+    Returns
+    -------
+    ChannelStatsOutput
+        Output class containing the per-channel outputs of various stats functions
+
+    See Also
+    --------
+    pixelstats, visualstats
+
+    Examples
+    --------
+    Calculating the per-channel pixel and visual stats for a dataset
+
+    >>> stats = channelstats(images)
+    >>> print(stats.visualstats.darkness)
+    [0.07495 0.1748  0.275   0.1047  0.11096 0.1172  0.2047  0.2109  0.2172
+     0.3047  0.311   0.3171  0.4048  0.411   0.4172  0.505   0.5107  0.517
+     0.6045  0.611   0.617   0.7046  0.711   0.7173  0.8047  0.811   0.8174
+     0.905   0.911   0.917  ]
+    """
+    outputs = run_stats(images, bboxes, True, [PixelStatsProcessor, VisualStatsProcessor])
+    return ChannelStatsOutput(*outputs)  # type: ignore

dataeval/_internal/metrics/stats/dimensionstats.py

@@ -11,24 +11,6 @@ from dataeval._internal.metrics.utils import get_bitdepth
 from dataeval._internal.output import set_metadata
 
 
-class DimensionStatsProcessor(StatsProcessor):
-    image_function_map = {
-        "left": lambda x: x.box[0],
-        "top": lambda x: x.box[1],
-        "width": lambda x: x.shape[-1],
-        "height": lambda x: x.shape[-2],
-        "channels": lambda x: x.shape[-3],
-        "size": lambda x: np.prod(x.shape[-2:]),
-        "aspect_ratio": lambda x: x.shape[-1] / x.shape[-2],
-        "depth": lambda x: get_bitdepth(x.image).depth,
-        "center": lambda x: np.asarray([(x.box[0] + x.box[2]) / 2, (x.box[1] + x.box[3]) / 2]),
-        "distance": lambda x: np.sqrt(
-            np.square(((x.box[0] + x.box[2]) / 2) - (x.width / 2))
-            + np.square(((x.box[1] + x.box[3]) / 2) - (x.height / 2))
-        ),
-    }
-
-
 @dataclass(frozen=True)
 class DimensionStatsOutput(BaseStatsOutput):
     """
@@ -70,6 +52,25 @@ class DimensionStatsOutput(BaseStatsOutput):
     distance: NDArray[np.float16]
 
 
+class DimensionStatsProcessor(StatsProcessor[DimensionStatsOutput]):
+    output_class = DimensionStatsOutput
+    image_function_map = {
+        "left": lambda x: x.box[0],
+        "top": lambda x: x.box[1],
+        "width": lambda x: x.box[2] - x.box[0],
+        "height": lambda x: x.box[3] - x.box[1],
+        "channels": lambda x: x.shape[-3],
+        "size": lambda x: (x.box[2] - x.box[0]) * (x.box[3] - x.box[1]),
+        "aspect_ratio": lambda x: (x.box[2] - x.box[0]) / (x.box[3] - x.box[1]),
+        "depth": lambda x: get_bitdepth(x.image).depth,
+        "center": lambda x: np.asarray([(x.box[0] + x.box[2]) / 2, (x.box[1] + x.box[3]) / 2]),
+        "distance": lambda x: np.sqrt(
+            np.square(((x.box[0] + x.box[2]) / 2) - (x.shape[-1] / 2))
+            + np.square(((x.box[1] + x.box[3]) / 2) - (x.shape[-2] / 2))
+        ),
+    }
+
+
 @set_metadata("dataeval.metrics")
 def dimensionstats(
     images: Iterable[ArrayLike],
@@ -109,5 +110,4 @@ def dimensionstats(
     >>> print(results.channels)
     [1 1 1 1 1 1 3 1 1 3]
     """
-    output = run_stats(images, bboxes, False, DimensionStatsProcessor, DimensionStatsOutput)
-    return DimensionStatsOutput(**output)
+    return run_stats(images, bboxes, False, [DimensionStatsProcessor])[0]

dataeval/_internal/metrics/stats/hashstats.py

@@ -10,13 +10,6 @@ from dataeval._internal.metrics.utils import pchash, xxhash
 from dataeval._internal.output import set_metadata
 
 
-class HashStatsProcessor(StatsProcessor):
-    image_function_map = {
-        "xxhash": lambda x: xxhash(x.image),
-        "pchash": lambda x: pchash(x.image),
-    }
-
-
 @dataclass(frozen=True)
 class HashStatsOutput(BaseStatsOutput):
     """
@@ -34,6 +27,14 @@ class HashStatsOutput(BaseStatsOutput):
     pchash: list[str]
 
 
+class HashStatsProcessor(StatsProcessor[HashStatsOutput]):
+    output_class = HashStatsOutput
+    image_function_map = {
+        "xxhash": lambda x: xxhash(x.image),
+        "pchash": lambda x: pchash(x.image),
+    }
+
+
 @set_metadata("dataeval.metrics")
 def hashstats(
     images: Iterable[ArrayLike],
@@ -71,5 +72,4 @@ def hashstats(
     >>> print(results.pchash)
     ['8f25506af46a7c6a', '8000808000008080', '8e71f18e0ef18e0e', 'a956d6a956d6a928']
     """
-    output = run_stats(images, bboxes, False, HashStatsProcessor, HashStatsOutput)
-    return HashStatsOutput(**output)
+    return run_stats(images, bboxes, False, [HashStatsProcessor])[0]

dataeval/_internal/metrics/stats/pixelstats.py

@@ -11,28 +11,6 @@ from dataeval._internal.metrics.stats.base import BaseStatsOutput, StatsProcesso
 from dataeval._internal.output import set_metadata
 
 
-class PixelStatsProcessor(StatsProcessor):
-    cache_keys = ["histogram"]
-    image_function_map = {
-        "mean": lambda self: np.mean(self.scaled),
-        "std": lambda x: np.std(x.scaled),
-        "var": lambda x: np.var(x.scaled),
-        "skew": lambda x: np.nan_to_num(skew(x.scaled.ravel())),
-        "kurtosis": lambda x: np.nan_to_num(kurtosis(x.scaled.ravel())),
-        "histogram": lambda x: np.histogram(x.scaled, 256, (0, 1))[0],
-        "entropy": lambda x: entropy(x.get("histogram")),
-    }
-    channel_function_map = {
-        "mean": lambda x: np.mean(x.scaled, axis=1),
-        "std": lambda x: np.std(x.scaled, axis=1),
-        "var": lambda x: np.var(x.scaled, axis=1),
-        "skew": lambda x: np.nan_to_num(skew(x.scaled, axis=1)),
-        "kurtosis": lambda x: np.nan_to_num(kurtosis(x.scaled, axis=1)),
-        "histogram": lambda x: np.apply_along_axis(lambda y: np.histogram(y, 256, (0, 1))[0], 1, x.scaled),
-        "entropy": lambda x: entropy(x.get("histogram"), axis=1),
-    }
-
-
 @dataclass(frozen=True)
 class PixelStatsOutput(BaseStatsOutput):
     """
@@ -65,6 +43,29 @@ class PixelStatsOutput(BaseStatsOutput):
     entropy: NDArray[np.float16]
 
 
+class PixelStatsProcessor(StatsProcessor[PixelStatsOutput]):
+    output_class = PixelStatsOutput
+    cache_keys = ["histogram"]
+    image_function_map = {
+        "mean": lambda self: np.mean(self.scaled),
+        "std": lambda x: np.std(x.scaled),
+        "var": lambda x: np.var(x.scaled),
+        "skew": lambda x: np.nan_to_num(skew(x.scaled.ravel())),
+        "kurtosis": lambda x: np.nan_to_num(kurtosis(x.scaled.ravel())),
+        "histogram": lambda x: np.histogram(x.scaled, 256, (0, 1))[0],
+        "entropy": lambda x: entropy(x.get("histogram")),
+    }
+    channel_function_map = {
+        "mean": lambda x: np.mean(x.scaled, axis=1),
+        "std": lambda x: np.std(x.scaled, axis=1),
+        "var": lambda x: np.var(x.scaled, axis=1),
+        "skew": lambda x: np.nan_to_num(skew(x.scaled, axis=1)),
+        "kurtosis": lambda x: np.nan_to_num(kurtosis(x.scaled, axis=1)),
+        "histogram": lambda x: np.apply_along_axis(lambda y: np.histogram(y, 256, (0, 1))[0], 1, x.scaled),
+        "entropy": lambda x: entropy(x.get("histogram"), axis=1),
+    }
+
+
 @set_metadata("dataeval.metrics")
 def pixelstats(
     images: Iterable[ArrayLike],
@@ -115,5 +116,4 @@ def pixelstats(
      0.812  0.9883 0.795  0.9243 0.9243 0.795  0.9907 0.8125 1.028  0.8223
      1.046  0.8247 1.041  0.8203 1.012  0.812  0.9883 0.795  0.9243 0.9243]
     """
-    output = run_stats(images, bboxes, per_channel, PixelStatsProcessor, PixelStatsOutput)
-    return PixelStatsOutput(**output)
+    return run_stats(images, bboxes, per_channel, [PixelStatsProcessor])[0]

dataeval/_internal/metrics/stats/visualstats.py

@@ -13,33 +13,6 @@ from dataeval._internal.output import set_metadata
 QUARTILES = (0, 25, 50, 75, 100)
 
 
-class VisualStatsProcessor(StatsProcessor):
-    cache_keys = ["percentiles"]
-    image_function_map = {
-        "brightness": lambda x: x.get("percentiles")[-2],
-        "blurriness": lambda x: np.std(edge_filter(np.mean(x.image, axis=0))),
-        "contrast": lambda x: np.nan_to_num(
-            (np.max(x.get("percentiles")) - np.min(x.get("percentiles"))) / np.mean(x.get("percentiles"))
-        ),
-        "darkness": lambda x: x.get("percentiles")[1],
-        "missing": lambda x: np.sum(np.isnan(x.image)) / np.prod(x.shape[-2:]),
-        "zeros": lambda x: np.count_nonzero(x.image == 0) / np.prod(x.shape[-2:]),
-        "percentiles": lambda x: np.nanpercentile(x.scaled, q=QUARTILES),
-    }
-    channel_function_map = {
-        "brightness": lambda x: x.get("percentiles")[:, -2],
-        "blurriness": lambda x: np.std(np.vectorize(edge_filter, signature="(m,n)->(m,n)")(x.image), axis=(1, 2)),
-        "contrast": lambda x: np.nan_to_num(
-            (np.max(x.get("percentiles"), axis=1) - np.min(x.get("percentiles"), axis=1))
-            / np.mean(x.get("percentiles"), axis=1)
-        ),
-        "darkness": lambda x: x.get("percentiles")[:, 1],
-        "missing": lambda x: np.sum(np.isnan(x.image), axis=(1, 2)) / np.prod(x.shape[-2:]),
-        "zeros": lambda x: np.count_nonzero(x.image == 0, axis=(1, 2)) / np.prod(x.shape[-2:]),
-        "percentiles": lambda x: np.nanpercentile(x.scaled, q=QUARTILES, axis=1).T,
-    }
-
-
 @dataclass(frozen=True)
 class VisualStatsOutput(BaseStatsOutput):
     """
@@ -49,14 +22,14 @@ class VisualStatsOutput(BaseStatsOutput):
     ----------
     brightness : NDArray[np.float16]
         Brightness of the images
-    blurriness : NDArray[np.float16]
-        Blurriness of the images
     contrast : NDArray[np.float16]
         Image contrast ratio
     darkness : NDArray[np.float16]
         Darkness of the images
     missing : NDArray[np.float16]
         Percentage of the images with missing pixels
+    sharpness : NDArray[np.float16]
+        Sharpness of the images
     zeros : NDArray[np.float16]
         Percentage of the images with zero value pixels
     percentiles : NDArray[np.float16]
@@ -64,14 +37,42 @@ class VisualStatsOutput(BaseStatsOutput):
     """
 
     brightness: NDArray[np.float16]
-    blurriness: NDArray[np.float16]
     contrast: NDArray[np.float16]
     darkness: NDArray[np.float16]
     missing: NDArray[np.float16]
+    sharpness: NDArray[np.float16]
     zeros: NDArray[np.float16]
     percentiles: NDArray[np.float16]
 
 
+class VisualStatsProcessor(StatsProcessor[VisualStatsOutput]):
+    output_class = VisualStatsOutput
+    cache_keys = ["percentiles"]
+    image_function_map = {
+        "brightness": lambda x: x.get("percentiles")[1],
+        "contrast": lambda x: np.nan_to_num(
+            (np.max(x.get("percentiles")) - np.min(x.get("percentiles"))) / np.mean(x.get("percentiles"))
+        ),
+        "darkness": lambda x: x.get("percentiles")[-2],
+        "missing": lambda x: np.count_nonzero(np.isnan(np.sum(x.image, axis=0))) / np.prod(x.shape[-2:]),
+        "sharpness": lambda x: np.std(edge_filter(np.mean(x.image, axis=0))),
+        "zeros": lambda x: np.count_nonzero(np.sum(x.image, axis=0) == 0) / np.prod(x.shape[-2:]),
+        "percentiles": lambda x: np.nanpercentile(x.scaled, q=QUARTILES),
+    }
+    channel_function_map = {
+        "brightness": lambda x: x.get("percentiles")[:, 1],
+        "contrast": lambda x: np.nan_to_num(
+            (np.max(x.get("percentiles"), axis=1) - np.min(x.get("percentiles"), axis=1))
+            / np.mean(x.get("percentiles"), axis=1)
+        ),
+        "darkness": lambda x: x.get("percentiles")[:, -2],
+        "missing": lambda x: np.count_nonzero(np.isnan(x.image), axis=(1, 2)) / np.prod(x.shape[-2:]),
+        "sharpness": lambda x: np.std(np.vectorize(edge_filter, signature="(m,n)->(m,n)")(x.image), axis=(1, 2)),
+        "zeros": lambda x: np.count_nonzero(x.image == 0, axis=(1, 2)) / np.prod(x.shape[-2:]),
+        "percentiles": lambda x: np.nanpercentile(x.scaled, q=QUARTILES, axis=1).T,
+    }
+
+
 @set_metadata("dataeval.metrics")
 def visualstats(
     images: Iterable[ArrayLike],
@@ -81,7 +82,7 @@ def visualstats(
     """
     Calculates visual statistics for each image
 
-    This function computes various visual metrics (e.g., brightness, darkness, contrast, blurriness)
+    This function computes various visual metrics (e.g., brightness, darkness, contrast, sharpness)
     on the images as a whole.
 
     Parameters
@@ -95,7 +96,7 @@ def visualstats(
     -------
     VisualStatsOutput
         A dictionary-like object containing the computed visual statistics for each image. The keys correspond
-        to the names of the statistics (e.g., 'brightness', 'blurriness'), and the values are lists of results for
+        to the names of the statistics (e.g., 'brightness', 'sharpness'), and the values are lists of results for
         each image or numpy arrays when the results are multi-dimensional.
 
     See Also
@@ -112,13 +113,13 @@ def visualstats(
 
     >>> results = visualstats(images)
     >>> print(results.brightness)
-    [0.0737 0.607  0.0713 0.1046 0.138  0.1713 0.2046 0.2379 0.2712 0.3047
-     0.338  0.3713 0.4045 0.438  0.4712 0.5044 0.538  0.5713 0.6045 0.638
-     0.6714 0.7046 0.738  0.7715 0.8047 0.838  0.871  0.905  0.938  0.971 ]
+    [0.02246 0.5557  0.06805 0.1014  0.1348  0.1681  0.2014  0.2347  0.268
+     0.3015  0.3347  0.3682  0.4014  0.4348  0.468   0.5015  0.5347  0.568
+     0.6016  0.635   0.668   0.701   0.735   0.768   0.8013  0.835   0.868
+     0.9014  0.9346  0.9683 ]
     >>> print(results.contrast)
     [2.041 1.332 1.293 1.279 1.272 1.268 1.265 1.263 1.261 1.26  1.259 1.258
      1.258 1.257 1.257 1.256 1.256 1.255 1.255 1.255 1.255 1.254 1.254 1.254
      1.254 1.254 1.254 1.253 1.253 1.253]
     """
-    output = run_stats(images, bboxes, per_channel, VisualStatsProcessor, VisualStatsOutput)
-    return VisualStatsOutput(**output)
+    return run_stats(images, bboxes, per_channel, [VisualStatsProcessor])[0]

dataeval/_internal/models/tensorflow/autoencoder.py

@@ -12,9 +12,9 @@ from __future__ import annotations
 
 from typing import Callable, cast
 
-import keras
 import tensorflow as tf
-from keras.layers import (
+import tf_keras as keras
+from tf_keras.layers import (
     Dense,
     Flatten,
     Layer,

dataeval/_internal/models/tensorflow/losses.py

@@ -11,11 +11,11 @@ from __future__ import annotations
 from typing import Literal, cast
 
 import tensorflow as tf
-from keras.layers import Flatten
 from numpy.typing import NDArray
 from tensorflow_probability.python.distributions.mvn_diag import MultivariateNormalDiag
 from tensorflow_probability.python.distributions.mvn_tril import MultivariateNormalTriL
 from tensorflow_probability.python.stats import covariance
+from tf_keras.layers import Flatten
 
 from dataeval._internal.models.tensorflow.gmm import gmm_energy, gmm_params
 

dataeval/_internal/models/tensorflow/pixelcnn.py

@@ -13,9 +13,9 @@ from __future__ import annotations
 import functools
 import warnings
 
-import keras
 import numpy as np
 import tensorflow as tf
+import tf_keras as keras
 from tensorflow_probability.python.bijectors import bijector
 from tensorflow_probability.python.distributions import (
     categorical,

dataeval/_internal/models/tensorflow/trainer.py

@@ -10,9 +10,9 @@ from __future__ import annotations
 
 from typing import Callable, Iterable, cast
 
-import keras
 import numpy as np
 import tensorflow as tf
+import tf_keras as keras
 from numpy.typing import NDArray
 
 

dataeval/_internal/models/tensorflow/utils.py

@@ -11,11 +11,13 @@ from __future__ import annotations
 import math
 from typing import Callable, Union, cast
 
-import keras as keras
 import numpy as np
 import tensorflow as tf
-from keras import Sequential
-from keras.layers import (
+import tf_keras as keras
+from numpy.typing import NDArray
+from tensorflow._api.v2.nn import relu, softmax, tanh
+from tf_keras import Sequential
+from tf_keras.layers import (
     Conv2D,
     Conv2DTranspose,
     Dense,
@@ -23,8 +25,6 @@ from keras.layers import (
     InputLayer,
     Reshape,
 )
-from numpy.typing import NDArray
-from tensorflow._api.v2.nn import relu, softmax, tanh
 
 from dataeval._internal.models.tensorflow.autoencoder import AE, AEGMM, VAE, VAEGMM
 from dataeval._internal.models.tensorflow.pixelcnn import PixelCNN

dataeval/metrics/stats/__init__.py

@@ -4,7 +4,12 @@ and label statistics against the images and labels of a dataset.
 """
 
 from dataeval._internal.metrics.stats.boxratiostats import boxratiostats
-from dataeval._internal.metrics.stats.datasetstats import DatasetStatsOutput, datasetstats
+from dataeval._internal.metrics.stats.datasetstats import (
+    ChannelStatsOutput,
+    DatasetStatsOutput,
+    channelstats,
+    datasetstats,
+)
 from dataeval._internal.metrics.stats.dimensionstats import DimensionStatsOutput, dimensionstats
 from dataeval._internal.metrics.stats.hashstats import HashStatsOutput, hashstats
 from dataeval._internal.metrics.stats.labelstats import LabelStatsOutput, labelstats
@@ -13,12 +18,14 @@ from dataeval._internal.metrics.stats.visualstats import VisualStatsOutput, visu
 
 __all__ = [
     "boxratiostats",
+    "channelstats",
     "datasetstats",
     "dimensionstats",
     "hashstats",
     "labelstats",
     "pixelstats",
     "visualstats",
+    "ChannelStatsOutput",
     "DatasetStatsOutput",
     "DimensionStatsOutput",
     "HashStatsOutput",

dataeval/utils/tensorflow/__init__.py

@@ -6,6 +6,12 @@ as well as constructors which allow for customization of the encoder, decoder an
 layers used by the model.
 """
 
+from dataeval import _IS_TENSORFLOW_AVAILABLE
+
 from . import loss, models, recon
 
-__all__ = ["loss", "models", "recon"]
+__all__ = []
+
+
+if _IS_TENSORFLOW_AVAILABLE:
+    __all__ = ["loss", "models", "recon"]

dataeval/utils/tensorflow/loss/__init__.py

@@ -1,3 +1,7 @@
+from dataeval import _IS_TENSORFLOW_AVAILABLE
 from dataeval._internal.models.tensorflow.losses import Elbo, LossGMM
 
-__all__ = ["Elbo", "LossGMM"]
+__all__ = []
+
+if _IS_TENSORFLOW_AVAILABLE:
+    __all__ += ["Elbo", "LossGMM"]

dataeval/utils/tensorflow/models/__init__.py

@@ -1,5 +1,9 @@
+from dataeval import _IS_TENSORFLOW_AVAILABLE
 from dataeval._internal.models.tensorflow.autoencoder import AE, AEGMM, VAE, VAEGMM
 from dataeval._internal.models.tensorflow.pixelcnn import PixelCNN
 from dataeval._internal.models.tensorflow.utils import create_model
 
-__all__ = ["create_model", "AE", "AEGMM", "PixelCNN", "VAE", "VAEGMM"]
+__all__ = []
+
+if _IS_TENSORFLOW_AVAILABLE:
+    __all__ += ["create_model", "AE", "AEGMM", "PixelCNN", "VAE", "VAEGMM"]

dataeval/utils/torch/__init__.py

@@ -5,8 +5,17 @@ While these metrics can take in custom models, DataEval provides utility classes
 to create a seamless integration between custom models and DataEval's metrics.
 """
 
+from dataeval import _IS_TORCH_AVAILABLE, _IS_TORCHVISION_AVAILABLE
 from dataeval._internal.utils import read_dataset
 
-from . import models, trainer
+__all__ = []
 
-__all__ = ["read_dataset", "models", "trainer"]
+if _IS_TORCH_AVAILABLE:
+    from . import models, trainer
+
+    __all__ += ["read_dataset", "models", "trainer"]
+
+if _IS_TORCHVISION_AVAILABLE:
+    from . import datasets
+
+    __all__ += ["datasets"]

dataeval/utils/torch/datasets/__init__.py

@@ -2,6 +2,11 @@
 Provide access to common Torch datasets used for computer vision
 """
 
-from dataeval._internal.datasets import CIFAR10, MNIST, VOCDetection
+from dataeval import _IS_TORCHVISION_AVAILABLE
 
-__all__ = ["CIFAR10", "MNIST", "VOCDetection"]
+__all__ = []
+
+if _IS_TORCHVISION_AVAILABLE:
+    from dataeval._internal.datasets import CIFAR10, MNIST, VOCDetection
+
+    __all__ += ["CIFAR10", "MNIST", "VOCDetection"]

dataeval/utils/torch/models/__init__.py

@@ -1,7 +1,11 @@
+from dataeval import _IS_TORCH_AVAILABLE
 from dataeval._internal.models.pytorch.autoencoder import (
     AriaAutoencoder,
     Decoder,
     Encoder,
 )
 
-__all__ = ["AriaAutoencoder", "Decoder", "Encoder"]
+__all__ = []
+
+if _IS_TORCH_AVAILABLE:
+    __all__ += ["AriaAutoencoder", "Decoder", "Encoder"]

dataeval/utils/torch/trainer/__init__.py

@@ -1,3 +1,7 @@
+from dataeval import _IS_TORCH_AVAILABLE
 from dataeval._internal.models.pytorch.autoencoder import AETrainer
 
-__all__ = ["AETrainer"]
+__all__ = []
+
+if _IS_TORCH_AVAILABLE:
+    __all__ += ["AETrainer"]

{dataeval-0.70.1.dist-info → dataeval-0.71.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.70.1
+Version: 0.71.1
 Summary: DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks
 Home-page: https://dataeval.ai/
 License: MIT
@@ -29,10 +29,12 @@ Requires-Dist: nvidia-cudnn-cu11 (>=8.6.0.163) ; extra == "tensorflow" or extra
 Requires-Dist: pillow (>=10.3.0)
 Requires-Dist: scikit-learn (>=1.5.0)
 Requires-Dist: scipy (>=1.10)
-Requires-Dist: tensorflow (>=2.14.1,<2.16) ; extra == "tensorflow" or extra == "all"
-Requires-Dist: tensorflow_probability (>=0.22.1,<0.24) ; extra == "tensorflow" or extra == "all"
+Requires-Dist: tensorflow (>=2.16) ; extra == "tensorflow" or extra == "all"
+Requires-Dist: tensorflow_probability (>=0.24) ; extra == "tensorflow" or extra == "all"
+Requires-Dist: tf-keras (>2.16) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: torch (>=2.2.0) ; extra == "torch" or extra == "all"
 Requires-Dist: torchvision (>=0.17.0) ; extra == "torch" or extra == "all"
+Requires-Dist: tqdm
 Requires-Dist: xxhash (>=3.3)
 Project-URL: Documentation, https://dataeval.readthedocs.io/
 Project-URL: Repository, https://github.com/aria-ml/dataeval/

{dataeval-0.70.1.dist-info → dataeval-0.71.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dataeval/__init__.py,sha256=AIHxRS7PYlqg4s7fZJTPKuTtyWFWoVROw4knVoSBH6E,555
+dataeval/__init__.py,sha256=Qm1rDTX_NyCAtZl2ilQ49v0j_zqnWhhVwIhe0cvrKjk,620
 dataeval/_internal/datasets.py,sha256=KbXSR-vOAzFamfXHRnI9mhhqUzEPyGpK47fZsirQn1I,14638
 dataeval/_internal/detectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataeval/_internal/detectors/clusterer.py,sha256=srqTHzh9kIy7Ty4VYaptwuQlBh8emFeiEAeS_mYFKro,20750
@@ -12,13 +12,13 @@ dataeval/_internal/detectors/drift/uncertainty.py,sha256=Ot8L42AnFbkij4J3Tis7VzX
 dataeval/_internal/detectors/duplicates.py,sha256=wggaIl3uFxihNBQhPv5JcreZbhVaFKoMAJMv_9-aaHU,5324
 dataeval/_internal/detectors/merged_stats.py,sha256=okXGrqAgsqfANMxfIjiUQlZWlaIh5TVvIB9UPsOJZ7k,1351
 dataeval/_internal/detectors/ood/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/detectors/ood/ae.py,sha256=AIffh11UKZX-3oocDDp8-t-uDUm8aQKvrV0nIE3BLQo,2140
-dataeval/_internal/detectors/ood/aegmm.py,sha256=q2kRXZM5X0PoA10mRsi8Gh-W5FdFzEsnM1yDq3GFzn0,2518
-dataeval/_internal/detectors/ood/base.py,sha256=qYSmcN74x5-qL0_I7uNo4eQ8X8pr7M4cwjs2qvkJt5g,8561
-dataeval/_internal/detectors/ood/llr.py,sha256=VgZtMrMgI8zDVUzsqm2l4tqsULFIhdQeDd4lzdo_G7U,10217
-dataeval/_internal/detectors/ood/vae.py,sha256=iXEltu5pATWr42-28hZ3ARZavJrptLwUM5P9c8omA_s,3030
-dataeval/_internal/detectors/ood/vaegmm.py,sha256=ujp6UN0wpZcmPDPkVfTHZxgka5kuTOSzgXMmbKdmK2U,2947
-dataeval/_internal/detectors/outliers.py,sha256=JmAXoMO0Od7tc9RVFGJsDyOnByciPFG5FdS54Iu0BII,10396
+dataeval/_internal/detectors/ood/ae.py,sha256=OTcfvoiCdSFGaAAkejBKwwiHaHKB6sa01aW5fVBI1Bk,2152
+dataeval/_internal/detectors/ood/aegmm.py,sha256=7fRcTXfyUgYfcZOaa9GpGNNxAAp4sQ9zYowfs4s4420,2530
+dataeval/_internal/detectors/ood/base.py,sha256=jMMObJgPUZc2Vbql_UYNXvQAFO305TRhdVxk0YqfzJo,8573
+dataeval/_internal/detectors/ood/llr.py,sha256=wzWOeyqbD0WdXHRa1Qf-_3TbJYEfT6OuTQfcepPsbTM,10235
+dataeval/_internal/detectors/ood/vae.py,sha256=y_HP3tk7Clo3YG9hl-gke9_tJ4XW8x8sQlrC9ZtbVLw,3042
+dataeval/_internal/detectors/ood/vaegmm.py,sha256=SvdUKC8cVyEWfEGcczRmyA4SGJhbol0eDSDry1mZxII,2959
+dataeval/_internal/detectors/outliers.py,sha256=C7Iu66ze5KCCRQNc1TsqkFVKDFGfP4qjGMUv6RUpk-E,10206
 dataeval/_internal/interop.py,sha256=FLXJY-5hwJcKCtruyvaarqynXCMfcLbQSFvGnrWQDPo,1338
 dataeval/_internal/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataeval/_internal/metrics/balance.py,sha256=8KwuR5HvytJtS1YW9KkNrCu2dPn_gP4FSbXrxQ-9kK8,6182
@@ -27,14 +27,14 @@ dataeval/_internal/metrics/coverage.py,sha256=jxvzWpVQrfmN3S9rpXvyb35vpRn1ovV2Id
 dataeval/_internal/metrics/divergence.py,sha256=gKQt9rxmhW8RnODCoLgFSPnCUWEMjmNIPlCV2w6E6oU,4211
 dataeval/_internal/metrics/diversity.py,sha256=ZSlq1KBvkMRVAvlznils2QmlPC73TTpHs1ux7PoFrio,7664
 dataeval/_internal/metrics/parity.py,sha256=eTjltNBJOTFH6T_t9V9-1EFr_U0vqlU642o3x2RWgz0,16527
-dataeval/_internal/metrics/stats/base.py,sha256=HyjgHTQZqgkkCWDzOF-aNZBr88IAjnao8VSbHC5ZtbI,8554
+dataeval/_internal/metrics/stats/base.py,sha256=DRTaaFVtbH1M-wLO2NrtuAAXx699vlEjP9d2no72pM4,11066
 dataeval/_internal/metrics/stats/boxratiostats.py,sha256=Ac6nB41q43xHCJRDEXHNgsJF80VE8MpH8_kySxA84BE,6342
-dataeval/_internal/metrics/stats/datasetstats.py,sha256=6DFl3TE7t2ggDD8WBVgPH7F2bRvae7NR2PVoEWL92dw,3759
-dataeval/_internal/metrics/stats/dimensionstats.py,sha256=MUQJgrWmRoQFap7gPf8vTFXJ_z7G7bAQpZ7kCPRtNkA,3847
-dataeval/_internal/metrics/stats/hashstats.py,sha256=xH0k_wOeGO5UC7-0fhAIg4WV2fO8fnF0Jdn18gYhW88,2087
+dataeval/_internal/metrics/stats/datasetstats.py,sha256=1H8Njtr27oNO8Hn3pwizAlOFkVe3QpbJb-RYk4dLKkY,6201
+dataeval/_internal/metrics/stats/dimensionstats.py,sha256=EIXrRia7OyB147WgAW2tqEwPMcCNWmSQidx5uQukSqQ,3915
+dataeval/_internal/metrics/stats/hashstats.py,sha256=I-aX-R0Rlvjwo7A5bjq3Bqs7-utTapnXB87z9TyC12w,2088
 dataeval/_internal/metrics/stats/labelstats.py,sha256=BNxI2flvKhSps2o4-TPbN9nf52ctatI2SuDZ07hah5E,4058
-dataeval/_internal/metrics/stats/pixelstats.py,sha256=LxoDQ6afsNuzB0WnOgmzkEUV7s534MrAYkzS6Be7PPQ,4419
-dataeval/_internal/metrics/stats/visualstats.py,sha256=3uET0N3WgV5dcxst8Xb9DhcATiNfAXsx1OKbPz2mU4Q,4712
+dataeval/_internal/metrics/stats/pixelstats.py,sha256=_b0TdjHZwe2yj5Cdmz2IhbQP4LTnHI1qFlDgPV8fuCs,4420
+dataeval/_internal/metrics/stats/visualstats.py,sha256=TdPwiehv0dY5HJmOOQk4_omfMd725NqOPG21A-q_t0I,4788
 dataeval/_internal/metrics/uap.py,sha256=RumSQey6vNoz9CtOG2_Inb-TurKJrAHqwhkyWBirxhk,2128
 dataeval/_internal/metrics/utils.py,sha256=vW3mQHjF0AvYlml27X5dZgd0YBk3zyBvvztLEfdRkvI,13475
 dataeval/_internal/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -43,12 +43,12 @@ dataeval/_internal/models/pytorch/autoencoder.py,sha256=nPyLjLZrPNla-lMnym3fUW-O
 dataeval/_internal/models/pytorch/blocks.py,sha256=pm2xwsDZjZJYXrhhiz8husvh2vHmrkFMSYEn-EDUD5Q,1354
 dataeval/_internal/models/pytorch/utils.py,sha256=Qgwym1PxGuwxbXCKUT-8r6Iyrxqm7x94oj45Vf5_CjE,1675
 dataeval/_internal/models/tensorflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/models/tensorflow/autoencoder.py,sha256=Ryn11jDbpZJOM5De-kMGPdbJBQEdwip6B20ajS8HqpE,10354
+dataeval/_internal/models/tensorflow/autoencoder.py,sha256=l-3utb7Rwq6_KiqOPBHnYxR7ngYhpIDFvbvNZc5UvNI,10369
 dataeval/_internal/models/tensorflow/gmm.py,sha256=QoEgbeax1GETqRmUF7A2ih9uFOZfFAjGzgH2ljExlAc,3669
-dataeval/_internal/models/tensorflow/losses.py,sha256=pZH5RnlM9R0RrBde9Lgq32muwAp7_PWc56Mu4u8RVvo,3976
-dataeval/_internal/models/tensorflow/pixelcnn.py,sha256=keI1gTNjBk18YD91Cp4exfuGYWU9lt-wapvhSazhcVs,48319
-dataeval/_internal/models/tensorflow/trainer.py,sha256=xNY0Iw7Qa1TnCuy9N1b77_VduFoW_BhbZjfQCxOVby4,4082
-dataeval/_internal/models/tensorflow/utils.py,sha256=l6jXKMWyQAEI4LpAONq95Xwr7CPgrs408ypf9TuNxkY,8732
+dataeval/_internal/models/tensorflow/losses.py,sha256=LavFmi9AWfE_HO4YxQ54kV8LZG5-UeCOhOlcPpxo-ic,3979
+dataeval/_internal/models/tensorflow/pixelcnn.py,sha256=ru4KF8CZHKbOpp-ZgDxuRdbcv_nTCs1i1H2lTMamL7Y,48331
+dataeval/_internal/models/tensorflow/trainer.py,sha256=LJ3t6Ud95cofKN-cgb5o5nDrYSFse7LSDOYIBkMgDJk,4094
+dataeval/_internal/models/tensorflow/utils.py,sha256=Uq6eUTEeUHGopL1_VBH656-Ue18v6WgiEUjmk8SMsc8,8741
 dataeval/_internal/output.py,sha256=qVbOi41dvfQICQ4uxysHPWBRKo1XR61kXHPL_vKOPm0,2545
 dataeval/_internal/utils.py,sha256=jo6bGJZAgyuZqRpAAC4gwhAHYE12316na19ZuFwMqes,1504
 dataeval/_internal/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -62,19 +62,19 @@ dataeval/detectors/ood/__init__.py,sha256=K5QrSJg2QePs6Pa3Cg80ZwXu7BELLrSlbEpTdx
 dataeval/metrics/__init__.py,sha256=U0sRw5eiqeeDLbLPxT_rznZsvtNwONVxKVwfC0qVOgo,223
 dataeval/metrics/bias/__init__.py,sha256=Wn1Ui_g-9cR4c4IS7RFKJ6UH5DLXKjEBoXTuEYPXSBc,619
 dataeval/metrics/estimators/__init__.py,sha256=4VFMKLPsJdaWiflf84bXGQ2k8ertFQ4WEPhyWqjFFvE,377
-dataeval/metrics/stats/__init__.py,sha256=UcD41gFwFhcQMtqwWkPQlg6cFA2_gdj6yGRCDrKYXM8,1055
+dataeval/metrics/stats/__init__.py,sha256=AKlNelORMOM2OA9XIvwZ9nOn6dK6k-r-69ldEAuqgLA,1156
 dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataeval/utils/__init__.py,sha256=cW_5-DIZG2OFRs3FVLOz0uCv4JWdaoVO7C9rOlR7ZEA,526
-dataeval/utils/tensorflow/__init__.py,sha256=XgjqrMtI00ERPPpdokbO1lDyc_H3CZ1TTqUXIj0B6PI,435
-dataeval/utils/tensorflow/loss/__init__.py,sha256=E9eB87LNh0o5nUCqssB027EXBsOfEayNHPcNW0QGFdA,101
-dataeval/utils/tensorflow/models/__init__.py,sha256=OVpmHF8itDcgOlfw6N9jr7IphZPbMJoiu7OdqYhU9fs,291
+dataeval/utils/tensorflow/__init__.py,sha256=sKRG3b_MLQUrAftkRZ17JyNZt6gjEguvTK83hO_IwRQ,530
+dataeval/utils/tensorflow/loss/__init__.py,sha256=s7tD_5dYWcNDmntGiEHhG7bVDsMAY1UO8FpQFe9cUns,195
+dataeval/utils/tensorflow/models/__init__.py,sha256=1R9Oi5DOYwT0W3JSEfoMsPOvhYFaKqKilwkrUifNnig,385
 dataeval/utils/tensorflow/recon/__init__.py,sha256=xe6gAQqK9tyAoDQTtaJAxIPK1humt5QzsG_9NPsqx58,116
-dataeval/utils/torch/__init__.py,sha256=bYUm-nNlNVU3bqDz7dQHFmaRWgLy3lLrD4cSDumDlxQ,373
-dataeval/utils/torch/datasets/__init__.py,sha256=S6C4OaxEjJJaIpHSZcZfkl4U5iS5YtZ9N5GYHqvbzvM,191
-dataeval/utils/torch/models/__init__.py,sha256=YnDnePYpRIKHyYn3F5qR1OObMSb-g0FGvI8X-uTB09E,162
-dataeval/utils/torch/trainer/__init__.py,sha256=Te-qElt8h-Zv8NN0r-VJOEdCPHTQ2yO3rd2MhRiZGZs,93
+dataeval/utils/torch/__init__.py,sha256=430fNKbqLByuGSeNhnoIJy3g9Z94ckZsAKWUZ15MVP4,575
+dataeval/utils/torch/datasets/__init__.py,sha256=94k7fMQdxYlQXDYouAHUgrQJ2oBwnvq4koFJpyhlUVA,292
+dataeval/utils/torch/models/__init__.py,sha256=q1BzoLHWA0uBXzT2glWJDrxVA1BN7xnkT2r_d-7Dlyw,246
+dataeval/utils/torch/trainer/__init__.py,sha256=hpcrlCCXPzb8b7FOzEAKqFy6Z7Zl4V_cx3yA7n3L1L4,177
 dataeval/workflows/__init__.py,sha256=VFeJyMhZxvj8WnU5Un32mwO8lNfBQOBjD9IdOqexnAE,320
-dataeval-0.70.1.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
-dataeval-0.70.1.dist-info/METADATA,sha256=B2slR1eY_xRR4QcUTpV8EJh5Z_plWmHFqTT5j4r2Vvk,4502
-dataeval-0.70.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-dataeval-0.70.1.dist-info/RECORD,,
+dataeval-0.71.1.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.71.1.dist-info/METADATA,sha256=j1HnzvkOSLR-D6debnFFLlp2vgue8ueFQvjYlrX75cw,4580
+dataeval-0.71.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dataeval-0.71.1.dist-info/RECORD,,