dataeval 0.75.0__py3-none-any.whl → 0.76.1__py3-none-any.whl

dataeval/metrics/stats/boxratiostats.py

@@ -26,7 +26,7 @@ class BoxImageStatsOutputSlice(Generic[TStatOutput]):
         def __getitem__(self, key: str) -> NDArray[np.float64]:
             _stat = cast(np.ndarray, getattr(self._stats, key)).astype(np.float64)
             _shape = _stat[0].shape
-            _slice = _stat[self._slice[0] : self._slice[1]]
+            _slice = _stat[int(self._slice[0]) : int(self._slice[1])]
             return _slice.reshape(-1, self._channels, *_shape) if self._channels else _slice.reshape(-1, *_shape)
 
     box: StatSlicer
@@ -102,7 +102,7 @@ def boxratiostats(
     imgstats: TStatOutput,
 ) -> TStatOutput:
     """
-    Calculates ratio :term:`statistics<Statistics>` of box outputs over image outputs
+    Calculates ratio :term:`statistics<Statistics>` of box outputs over image outputs.
 
     Parameters
     ----------
@@ -147,13 +147,13 @@ def boxratiostats(
     if boxstats.source_index[-1].image != imgstats.source_index[-1].image:
         raise ValueError("Stats index_map length mismatch. Check if the correct box and image stats were provided.")
     if all(count == 0 for count in boxstats.box_count):
-        raise TypeError("Input for boxstats must contain box information.")
+        raise ValueError("Input for boxstats must contain box information.")
     if any(count != 0 for count in imgstats.box_count):
-        raise TypeError("Input for imgstats must not contain box information.")
+        raise ValueError("Input for imgstats must not contain box information.")
     boxstats_has_channels = any(si.channel is None for si in boxstats.source_index)
     imgstats_has_channels = any(si.channel is None for si in imgstats.source_index)
     if boxstats_has_channels != imgstats_has_channels:
-        raise TypeError("Input for boxstats and imgstats must have matching channel information.")
+        raise ValueError("Input for boxstats and imgstats must have matching channel information.")
 
     output_dict = {}
     for key in boxstats.dict():

dataeval/metrics/stats/datasetstats.py

@@ -7,7 +7,7 @@ from typing import Any, Iterable
 
 from numpy.typing import ArrayLike
 
-from dataeval.metrics.stats.base import BaseStatsOutput, run_stats
+from dataeval.metrics.stats.base import BaseStatsOutput, HistogramPlotMixin, _is_plottable, run_stats
 from dataeval.metrics.stats.dimensionstats import (
     DimensionStatsOutput,
     DimensionStatsProcessor,
@@ -16,12 +16,13 @@ from dataeval.metrics.stats.labelstats import LabelStatsOutput, labelstats
 from dataeval.metrics.stats.pixelstats import PixelStatsOutput, PixelStatsProcessor
 from dataeval.metrics.stats.visualstats import VisualStatsOutput, VisualStatsProcessor
 from dataeval.output import Output, set_metadata
+from dataeval.utils.plot import channel_histogram_plot
 
 
 @dataclass(frozen=True)
-class DatasetStatsOutput(Output):
+class DatasetStatsOutput(Output, HistogramPlotMixin):
     """
-    Output class for :func:`datasetstats` stats metric
+    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
@@ -41,6 +42,8 @@ class DatasetStatsOutput(Output):
     visualstats: VisualStatsOutput
     labelstats: LabelStatsOutput | None = None
 
+    _excluded_keys = ["histogram", "percentiles"]
+
     def _outputs(self) -> list[Output]:
         return [s for s in (self.dimensionstats, self.pixelstats, self.visualstats, self.labelstats) if s is not None]
 
@@ -53,10 +56,33 @@ class DatasetStatsOutput(Output):
             raise ValueError("All StatsOutput classes must contain the same number of image sources.")
 
 
+def _get_channels(cls, channel_limit: int | None = None, channel_index: int | Iterable[int] | None = None):
+    raw_channels = max([si.channel for si in cls.dict()["source_index"]]) + 1
+    if isinstance(channel_index, int):
+        max_channels = 1 if channel_index < raw_channels else raw_channels
+        ch_mask = cls.pixelstats.get_channel_mask(channel_index)
+    elif isinstance(channel_index, Iterable) and all(isinstance(val, int) for val in list(channel_index)):
+        max_channels = len(list(channel_index))
+        ch_mask = cls.pixelstats.get_channel_mask(channel_index)
+    elif isinstance(channel_limit, int):
+        max_channels = channel_limit
+        ch_mask = cls.pixelstats.get_channel_mask(None, channel_limit)
+    else:
+        max_channels = raw_channels
+        ch_mask = None
+
+    if max_channels > raw_channels:
+        max_channels = raw_channels
+    if ch_mask is not None and not any(ch_mask):
+        ch_mask = None
+
+    return max_channels, ch_mask
+
+
 @dataclass(frozen=True)
 class ChannelStatsOutput(Output):
     """
-    Output class for :func:`channelstats` stats metric
+    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
@@ -83,6 +109,13 @@ class ChannelStatsOutput(Output):
         if not all(length == lengths[0] for length in lengths):
             raise ValueError("All StatsOutput classes must contain the same number of image sources.")
 
+    def plot(
+        self, log: bool, channel_limit: int | None = None, channel_index: int | Iterable[int] | None = None
+    ) -> None:
+        max_channels, ch_mask = _get_channels(self, channel_limit, channel_index)
+        data_dict = {k: v for k, v in self.dict().items() if _is_plottable(k, v, ("histogram", "percentiles"))}
+        channel_histogram_plot(data_dict, log, max_channels, ch_mask)
+
 
 @set_metadata
 def datasetstats(
@@ -91,7 +124,7 @@ def datasetstats(
     labels: Iterable[ArrayLike] | None = None,
 ) -> DatasetStatsOutput:
     """
-    Calculates various :term:`statistics<Statistics>` for each image
+    Calculates various :term:`statistics<Statistics>` for each image.
 
     This function computes dimension, pixel and visual metrics
     on the images or individual bounding boxes for each image as
@@ -135,7 +168,7 @@ def channelstats(
     bboxes: Iterable[ArrayLike] | None = None,
 ) -> ChannelStatsOutput:
     """
-    Calculates various per-channel statistics for each image
+    Calculates various per-channel :term:`statistics` for each image.
 
     This function computes pixel and visual metrics on the images
     or individual bounding boxes for each image.

dataeval/metrics/stats/dimensionstats.py

@@ -8,15 +8,15 @@ from typing import Any, Callable, Iterable
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
 
-from dataeval.metrics.stats.base import BaseStatsOutput, StatsProcessor, run_stats
+from dataeval.metrics.stats.base import BaseStatsOutput, HistogramPlotMixin, StatsProcessor, run_stats
 from dataeval.output import set_metadata
 from dataeval.utils.image import get_bitdepth
 
 
 @dataclass(frozen=True)
-class DimensionStatsOutput(BaseStatsOutput):
+class DimensionStatsOutput(BaseStatsOutput, HistogramPlotMixin):
     """
-    Output class for :func:`dimensionstats` stats metric
+    Output class for :func:`dimensionstats` stats metric.
 
     Attributes
     ----------
@@ -79,7 +79,7 @@ def dimensionstats(
     bboxes: Iterable[ArrayLike] | None = None,
 ) -> DimensionStatsOutput:
     """
-    Calculates dimension :term:`statistics<Statistics>` for each image
+    Calculates dimension :term:`statistics<Statistics>` for each image.
 
     This function computes various dimensional metrics (e.g., width, height, channels)
     on the images or individual bounding boxes for each image.

dataeval/metrics/stats/hashstats.py

@@ -25,7 +25,7 @@ MAX_FACTOR = 4
 @dataclass(frozen=True)
 class HashStatsOutput(BaseStatsOutput):
     """
-    Output class for :func:`hashstats` stats metric
+    Output class for :func:`hashstats` stats metric.
 
     Attributes
     ----------
@@ -126,7 +126,7 @@ def hashstats(
     bboxes: Iterable[ArrayLike] | None = None,
 ) -> HashStatsOutput:
     """
-    Calculates hashes for each image
+    Calculates hashes for each image.
 
     This function computes hashes from the images including exact hashes and perception-based
     hashes. These hash values can be used to determine if images are exact or near matches.

dataeval/metrics/stats/labelstats.py

@@ -2,20 +2,25 @@ from __future__ import annotations
 
 __all__ = []
 
+import contextlib
 from collections import Counter, defaultdict
 from dataclasses import dataclass
 from typing import Any, Iterable, Mapping, TypeVar
 
+import numpy as np
 from numpy.typing import ArrayLike
 
-from dataeval.interop import to_numpy
+from dataeval.interop import as_numpy
 from dataeval.output import Output, set_metadata
 
+with contextlib.suppress(ImportError):
+    import pandas as pd
+
 
 @dataclass(frozen=True)
 class LabelStatsOutput(Output):
     """
-    Output class for :func:`labelstats` stats metric
+    Output class for :func:`labelstats` stats metric.
 
     Attributes
     ----------
@@ -46,6 +51,47 @@ class LabelStatsOutput(Output):
     class_count: int
     label_count: int
 
+    def to_table(self) -> str:
+        max_char = max(len(key) if isinstance(key, str) else key // 10 + 1 for key in self.label_counts_per_class)
+        max_char = max(max_char, 5)
+        max_label = max(list(self.label_counts_per_class.values()))
+        max_img = max(list(self.image_counts_per_label.values()))
+        max_num = int(np.ceil(np.log10(max(max_label, max_img))))
+        max_num = max(max_num, 11)
+
+        # Display basic counts
+        table_str = f"Class Count: {self.class_count}\n"
+        table_str += f"Label Count: {self.label_count}\n"
+        table_str += f"Average # Labels per Image: {round(np.mean(self.label_counts_per_image), 2)}\n"
+        table_str += "--------------------------------------\n"
+
+        # Display counts per class
+        table_str += f"{'Label':>{max_char}}: Total Count - Image Count\n"
+        for cls in self.label_counts_per_class:
+            table_str += f"{cls:>{max_char}}: {self.label_counts_per_class[cls]:^{max_num}} "
+            table_str += f"- {self.image_counts_per_label[cls]:^{max_num}}\n"
+
+        return table_str
+
+    def to_dataframe(self) -> pd.DataFrame:
+        import pandas as pd
+
+        class_list = []
+        total_count = []
+        image_count = []
+        for cls in self.label_counts_per_class:
+            class_list.append(cls)
+            total_count.append(self.label_counts_per_class[cls])
+            image_count.append(self.image_counts_per_label[cls])
+
+        return pd.DataFrame(
+            {
+                "Label": class_list,
+                "Total Count": total_count,
+                "Image Count": image_count,
+            }
+        )
+
 
 TKey = TypeVar("TKey", int, str)
 
@@ -57,12 +103,47 @@ def sort(d: Mapping[TKey, Any]) -> dict[TKey, Any]:
     return dict(sorted(d.items(), key=lambda x: x[0]))
 
 
+def _ensure_2d(labels: Iterable[ArrayLike]) -> Iterable[ArrayLike]:
+    if isinstance(labels, np.ndarray):
+        return labels[:, None]
+    else:
+        return [[lbl] for lbl in labels]  # type: ignore
+
+
+def _get_list_depth(lst):
+    if isinstance(lst, list) and lst:
+        return 1 + max(_get_list_depth(item) for item in lst)
+    return 0
+
+
+def _check_labels_dimension(labels: Iterable[ArrayLike]) -> Iterable[ArrayLike]:
+    # Check for nested lists beyond 2 levels
+
+    if isinstance(labels, np.ndarray):
+        if labels.ndim == 1:
+            return _ensure_2d(labels)
+        elif labels.ndim == 2:
+            return labels
+        else:
+            raise ValueError("The label array must not have more than 2 dimensions.")
+    elif isinstance(labels, list):
+        depth = _get_list_depth(labels)
+        if depth == 1:
+            return _ensure_2d(labels)
+        elif depth == 2:
+            return labels
+        else:
+            raise ValueError("The label list must not be empty or have more than 2 levels of nesting.")
+    else:
+        raise TypeError("Labels must be either a NumPy array or a list.")
+
+
 @set_metadata
 def labelstats(
     labels: Iterable[ArrayLike],
 ) -> LabelStatsOutput:
     """
-    Calculates :term:`statistics<Statistics>` for data labels
+    Calculates :term:`statistics<Statistics>` for data labels.
 
     This function computes counting metrics (e.g., total per class, total per image)
     on the labels.
@@ -99,10 +180,12 @@ def labelstats(
     index_location = defaultdict(list[int])
     label_per_image: list[int] = []
 
-    for i, group in enumerate(labels):
-        # Count occurrences of each label in all sublists
-        group = to_numpy(group)
+    labels_2d = _check_labels_dimension(labels)
+
+    for i, group in enumerate(labels_2d):
+        group = as_numpy(group)
 
+        # Count occurrences of each label in all sublists
         label_counts.update(group)
 
         # Get the number of labels per image

dataeval/metrics/stats/pixelstats.py

@@ -9,14 +9,14 @@ import numpy as np
 from numpy.typing import ArrayLike, NDArray
 from scipy.stats import entropy, kurtosis, skew
 
-from dataeval.metrics.stats.base import BaseStatsOutput, StatsProcessor, run_stats
+from dataeval.metrics.stats.base import BaseStatsOutput, HistogramPlotMixin, StatsProcessor, run_stats
 from dataeval.output import set_metadata
 
 
 @dataclass(frozen=True)
-class PixelStatsOutput(BaseStatsOutput):
+class PixelStatsOutput(BaseStatsOutput, HistogramPlotMixin):
     """
-    Output class for :func:`pixelstats` stats metric
+    Output class for :func:`pixelstats` stats metric.
 
     Attributes
     ----------
@@ -44,11 +44,13 @@ class PixelStatsOutput(BaseStatsOutput):
     histogram: NDArray[np.uint32]
     entropy: NDArray[np.float16]
 
+    _excluded_keys = ["histogram"]
+
 
 class PixelStatsProcessor(StatsProcessor[PixelStatsOutput]):
     output_class: type = PixelStatsOutput
     image_function_map: dict[str, Callable[[StatsProcessor[PixelStatsOutput]], Any]] = {
-        "mean": lambda self: np.mean(self.scaled),
+        "mean": lambda x: np.mean(x.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())),
@@ -74,7 +76,7 @@ def pixelstats(
     per_channel: bool = False,
 ) -> PixelStatsOutput:
     """
-    Calculates pixel :term:`statistics<Statistics>` for each image
+    Calculates pixel :term:`statistics<Statistics>` for each image.
 
     This function computes various statistical metrics (e.g., mean, standard deviation, entropy)
     on the images as a whole.

dataeval/metrics/stats/visualstats.py

@@ -8,7 +8,7 @@ from typing import Any, Callable, Iterable
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
 
-from dataeval.metrics.stats.base import BaseStatsOutput, StatsProcessor, run_stats
+from dataeval.metrics.stats.base import BaseStatsOutput, HistogramPlotMixin, StatsProcessor, run_stats
 from dataeval.output import set_metadata
 from dataeval.utils.image import edge_filter
 
@@ -16,9 +16,9 @@ QUARTILES = (0, 25, 50, 75, 100)
 
 
 @dataclass(frozen=True)
-class VisualStatsOutput(BaseStatsOutput):
+class VisualStatsOutput(BaseStatsOutput, HistogramPlotMixin):
     """
-    Output class for :func:`visualstats` stats metric
+    Output class for :func:`visualstats` stats metric.
 
     Attributes
     ----------
@@ -46,6 +46,8 @@ class VisualStatsOutput(BaseStatsOutput):
     zeros: NDArray[np.float16]
     percentiles: NDArray[np.float16]
 
+    _excluded_keys = ["percentiles"]
+
 
 class VisualStatsProcessor(StatsProcessor[VisualStatsOutput]):
     output_class: type = VisualStatsOutput
@@ -81,7 +83,7 @@ def visualstats(
     per_channel: bool = False,
 ) -> VisualStatsOutput:
     """
-    Calculates visual statistics for each image
+    Calculates visual :term:`statistics` for each image.
 
     This function computes various visual metrics (e.g., :term:`brightness<Brightness>`, darkness, contrast, blurriness)
     on the images as a whole.

dataeval/output.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 __all__ = []
 
 import inspect
+import logging
 import sys
 from collections.abc import Mapping
 from datetime import datetime, timezone
@@ -81,29 +82,37 @@ def set_metadata(fn: Callable[P, R] | None = None, *, state: list[str] | None =
                 return f"{v.__class__.__name__}: len={len(v)}"
             return f"{v.__class__.__name__}"
 
-        time = datetime.now(timezone.utc)
-        result = fn(*args, **kwargs)
-        duration = (datetime.now(timezone.utc) - time).total_seconds()
-        fn_params = inspect.signature(fn).parameters
-
+        # Collect function metadata
         # set all params with defaults then update params with mapped arguments and explicit keyword args
+        fn_params = inspect.signature(fn).parameters
         arguments = {k: None if v.default is inspect.Parameter.empty else v.default for k, v in fn_params.items()}
         arguments.update(zip(fn_params, args))
         arguments.update(kwargs)
         arguments = {k: fmt(v) for k, v in arguments.items()}
-        state_attrs = (
-            {k: fmt(getattr(args[0], k)) for k in state if "self" in arguments} if "self" in arguments and state else {}
-        )
-        name = (
-            f"{args[0].__class__.__module__}.{args[0].__class__.__name__}.{fn.__name__}"
-            if "self" in arguments
-            else f"{fn.__module__}.{fn.__qualname__}"
-        )
+        is_method = "self" in arguments
+        state_attrs = {k: fmt(getattr(args[0], k)) for k in state or []} if is_method else {}
+        module = args[0].__class__.__module__ if is_method else fn.__module__.removeprefix("src.")
+        class_prefix = f".{args[0].__class__.__name__}." if is_method else "."
+        name = f"{module}{class_prefix}{fn.__name__}"
+        arguments = {k: v for k, v in arguments.items() if k != "self"}
+
+        _logger = logging.getLogger(module)
+        time = datetime.now(timezone.utc)
+        _logger.log(logging.INFO, f">>> Executing '{name}': args={arguments} state={state} <<<")
+
+        ##### EXECUTE FUNCTION #####
+        result = fn(*args, **kwargs)
+        ############################
+
+        duration = (datetime.now(timezone.utc) - time).total_seconds()
+        _logger.log(logging.INFO, f">>> Completed '{name}': args={arguments} state={state} duration={duration} <<<")
+
+        # Update output with recorded metadata
         metadata = {
             "_name": name,
             "_execution_time": time,
             "_execution_duration": duration,
-            "_arguments": {k: v for k, v in arguments.items() if k != "self"},
+            "_arguments": arguments,
             "_state": state_attrs,
             "_version": __version__,
         }

dataeval/utils/__init__.py

@@ -1,6 +1,6 @@
 """
-The utility classes and functions are provided by DataEval to assist users
-in setting up data and architectures that are guaranteed to work with applicable
+The utility classes and functions are provided by DataEval to assist users \
+in setting up data and architectures that are guaranteed to work with applicable \
 DataEval metrics.
 """
 

dataeval/utils/dataset/read.py

@@ -10,7 +10,7 @@ from torch.utils.data import Dataset
 
 def read_dataset(dataset: Dataset[Any]) -> list[list[Any]]:
     """
-    Extract information from a dataset at each index into individual lists of each information position
+    Extract information from a dataset at each index into individual lists of each information position.
 
     Parameters
     ----------

dataeval/utils/dataset/split.py

@@ -26,7 +26,7 @@ class TrainValSplit(NamedTuple):
 @dataclass(frozen=True)
 class SplitDatasetOutput(Output):
     """
-    Output class containing test indices and a list of TrainValSplits
+    Output class containing test indices and a list of TrainValSplits.
 
     Attributes
     ----------