dataeval 0.70.1__tar.gz → 0.71.0__tar.gz

{dataeval-0.70.1 → dataeval-0.71.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.70.1
+Version: 0.71.0
 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
@@ -33,6 +33,7 @@ Requires-Dist: tensorflow (>=2.14.1,<2.16) ; extra == "tensorflow" or extra == "
 Requires-Dist: tensorflow_probability (>=0.22.1,<0.24) ; 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 → dataeval-0.71.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dataeval"
-version = "0.70.1" # dynamic
+version = "0.71.0" # dynamic
 description = "DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks"
 license = "MIT"
 readme = "README.md"
@@ -46,6 +46,7 @@ numpy = {version = ">1.24.3"}
 pillow = {version = ">=10.3.0"}
 scipy = {version = ">=1.10"}
 scikit-learn = {version = ">=1.5.0"}
+tqdm = {version = "*"}
 xxhash = {version = ">=3.3"}
 
 # optional
@@ -135,6 +136,8 @@ addopts = ["--pythonwarnings=ignore::DeprecationWarning", "--verbose", "--durati
 [tool.coverage.run]
 source = ["src/dataeval", "src/dataeval/_internal"]
 branch = true
+concurrency = ["multiprocessing"]
+parallel = true
 
 [tool.coverage.report]
 exclude_also = ["raise NotImplementedError"]

{dataeval-0.70.1 → dataeval-0.71.0}/src/dataeval/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.70.1"
+__version__ = "0.71.0"
 
 from importlib.util import find_spec
 

{dataeval-0.70.1 → dataeval-0.71.0}/src/dataeval/_internal/detectors/outliers.py

@@ -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-0.70.1 → dataeval-0.71.0}/src/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-0.71.0/src/dataeval/_internal/metrics/stats/datasetstats.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+from numpy.typing import ArrayLike
+
+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, PixelStatsProcessor
+from dataeval._internal.metrics.stats.visualstats import VisualStatsOutput, VisualStatsProcessor
+from dataeval._internal.output import OutputMetadata, set_metadata
+
+
+@dataclass(frozen=True)
+class DatasetStatsOutput(OutputMetadata):
+    """
+    Output class for :func:`datasetstats` stats metric
+
+    This class represents the outputs of various 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
+    ----------
+    dimensionstats : DimensionStatsOutput
+    pixelstats: PixelStatsOutput
+    visualstats: VisualStatsOutput
+    labelstats: LabelStatsOutput or 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 [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()]
+        if not all(length == lengths[0] for length in lengths):
+            raise ValueError("All StatsOutput classes must contain the same number of image sources.")
+
+
+@set_metadata("dataeval.metrics")
+def datasetstats(
+    images: Iterable[ArrayLike],
+    bboxes: Iterable[ArrayLike] | None = None,
+    labels: Iterable[ArrayLike] | None = None,
+) -> DatasetStatsOutput:
+    """
+    Calculates various statistics for each image
+
+    This function computes dimension, pixel and visual metrics
+    on the images or individual bounding boxes for each image as
+    well as label statistics if provided.
+
+    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
+    labels : Iterable[ArrayLike] or None
+        Labels of images or boxes to perform calculations on
+
+    Returns
+    -------
+    DatasetStatsOutput
+        Output class containing the outputs of various stats functions
+
+    See Also
+    --------
+    dimensionstats, labelstats, pixelstats, visualstats, Outliers
+
+    Examples
+    --------
+    Calculating the dimension, pixel and visual stats for a dataset with bounding boxes
+
+    >>> stats = datasetstats(images, bboxes)
+    >>> print(stats.dimensionstats.aspect_ratio)
+    [ 0.864   0.5884 16.      1.143   1.692   0.5835  0.6665  2.555   1.3
+      0.8335  1.      0.6     0.522  15.      3.834   1.75    0.75    0.7   ]
+    >>> print(stats.visualstats.contrast)
+    [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]
+    """
+    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.02124 0.1213  0.2212  0.1013  0.1076  0.11383 0.2013  0.2076  0.2139
+     0.3013  0.3076  0.3137  0.4014  0.4075  0.4138  0.5015  0.508   0.5137
+     0.6016  0.6074  0.614   0.701   0.7075  0.714   0.8013  0.8076  0.814
+     0.9014  0.9077  0.914  ]
+    """
+    outputs = run_stats(images, bboxes, True, [PixelStatsProcessor, VisualStatsProcessor])
+    return ChannelStatsOutput(*outputs)  # type: ignore

{dataeval-0.70.1 → dataeval-0.71.0}/src/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.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))
+        ),
+    }
+
+
 @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-0.70.1 → dataeval-0.71.0}/src/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-0.70.1 → dataeval-0.71.0}/src/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-0.70.1 → dataeval-0.71.0}/src/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,7 +22,7 @@ class VisualStatsOutput(BaseStatsOutput):
     ----------
     brightness : NDArray[np.float16]
         Brightness of the images
-    blurriness : NDArray[np.float16]
+    sharpness : NDArray[np.float16]
         Blurriness of the images
     contrast : NDArray[np.float16]
         Image contrast ratio
@@ -64,7 +37,7 @@ class VisualStatsOutput(BaseStatsOutput):
     """
 
     brightness: NDArray[np.float16]
-    blurriness: NDArray[np.float16]
+    sharpness: NDArray[np.float16]
     contrast: NDArray[np.float16]
     darkness: NDArray[np.float16]
     missing: NDArray[np.float16]
@@ -72,6 +45,34 @@ class VisualStatsOutput(BaseStatsOutput):
     percentiles: NDArray[np.float16]
 
 
+class VisualStatsProcessor(StatsProcessor[VisualStatsOutput]):
+    output_class = VisualStatsOutput
+    cache_keys = ["percentiles"]
+    image_function_map = {
+        "brightness": lambda x: x.get("percentiles")[-2],
+        "sharpness": 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.count_nonzero(np.isnan(np.sum(x.image, axis=0))) / np.prod(x.shape[-2:]),
+        "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")[:, -2],
+        "sharpness": 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.count_nonzero(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,
+    }
+
+
 @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
@@ -120,5 +121,4 @@ def visualstats(
      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-0.70.1 → dataeval-0.71.0}/src/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-0.70.1/src/dataeval/_internal/metrics/stats/datasetstats.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import 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.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.output import OutputMetadata, set_metadata
-
-
-@dataclass(frozen=True)
-class DatasetStatsOutput(OutputMetadata):
-    """
-    Output class for :func:`datasetstats` stats metric
-
-    This class represents the outputs of various 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
-    ----------
-    dimensionstats : DimensionStatsOutput or None
-    pixelstats: PixelStatsOutput or None
-    visualstats: VisualStatsOutput or None
-    labelstats: LabelStatsOutput or None, default None
-    """
-
-    dimensionstats: DimensionStatsOutput | None
-    pixelstats: PixelStatsOutput | None
-    visualstats: VisualStatsOutput | None
-    labelstats: LabelStatsOutput | None = None
-
-    def outputs(self) -> list[BaseStatsOutput]:
-        return [s for s in (self.dimensionstats, self.pixelstats, self.visualstats) if s is not None]
-
-    def __post_init__(self):
-        lengths = [len(s) for s in self.outputs()]
-        if not all(length == lengths[0] for length in lengths):
-            raise ValueError("All StatsOutput classes must contain the same number of image sources.")
-
-
-@set_metadata("dataeval.metrics")
-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
-
-    This function computes dimension, pixel and visual metrics
-    on the images or individual bounding boxes for each image as
-    well as label statistics if provided.
-
-    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
-    labels : Iterable[ArrayLike] or None
-        Labels of images or boxes to perform calculations on
-
-    Returns
-    -------
-    DatasetStatsOutput
-        Output class containing the outputs of various stats functions
-
-    See Also
-    --------
-    dimensionstats, labelstats, pixelstats, visualstats, Outliers
-
-    Examples
-    --------
-    Calculating the dimension, pixel and visual stats for a dataset with bounding boxes
-
-    >>> stats = datasetstats(images, bboxes)
-    >>> print(stats.dimensionstats.aspect_ratio)
-    [ 0.864   0.5884 16.      1.143   1.692   0.5835  0.6665  2.555   1.3
-      0.8335  1.      0.6     0.522  15.      3.834   1.75    0.75    0.7   ]
-    >>> print(stats.visualstats.contrast)
-    [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,
-    )