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

dataeval/metrics/stats/datasetstats.py

@@ -1,202 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from dataclasses import dataclass
-from typing import Any, Iterable
-
-from numpy.typing import ArrayLike
-
-from dataeval.metrics.stats.base import BaseStatsOutput, HistogramPlotMixin, _is_plottable, run_stats
-from dataeval.metrics.stats.dimensionstats import (
-    DimensionStatsOutput,
-    DimensionStatsProcessor,
-)
-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, HistogramPlotMixin):
-    """
-    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
-
-    _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]
-
-    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) -> None:
-        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.")
-
-
-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.
-
-    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) -> tuple[PixelStatsOutput, VisualStatsOutput]:
-        return (self.pixelstats, self.visualstats)
-
-    def dict(self) -> dict[str, Any]:
-        return {**self.pixelstats.dict(), **self.visualstats.dict()}
-
-    def __post_init__(self) -> None:
-        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.")
-
-    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(
-    images: Iterable[ArrayLike],
-    bboxes: Iterable[ArrayLike] | None = None,
-    labels: Iterable[ArrayLike] | None = None,
-) -> DatasetStatsOutput:
-    """
-    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
-    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(stats_images, bboxes)
-    >>> print(stats.dimensionstats.aspect_ratio)
-    [ 0.864   0.5884 16.      1.143   1.692   0.5835  0.6665  2.555   1.3   ]
-    >>> print(stats.visualstats.sharpness)
-    [4.04   4.434  0.2778 4.957  5.145  5.22   4.957  3.076  2.855 ]
-    """
-    outputs = run_stats(images, bboxes, False, [DimensionStatsProcessor, PixelStatsProcessor, VisualStatsProcessor])
-    return DatasetStatsOutput(*outputs, labelstats=labelstats(labels) if labels else None)  # type: ignore
-
-
-@set_metadata
-def channelstats(
-    images: Iterable[ArrayLike],
-    bboxes: Iterable[ArrayLike] | None = None,
-) -> ChannelStatsOutput:
-    """
-    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.
-
-    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(stats_images)
-    >>> print(stats.visualstats.darkness)
-    [0.1499 0.3499 0.55   0.2094 0.2219 0.2344 0.4194 0.6094 0.622  0.6343
-     0.8154]
-    """
-    outputs = run_stats(images, bboxes, True, [PixelStatsProcessor, VisualStatsProcessor])
-    return ChannelStatsOutput(*outputs)  # type: ignore

dataeval/metrics/stats/dimensionstats.py

@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from dataclasses import dataclass
-from typing import Any, Callable, Iterable
-
-import numpy as np
-from numpy.typing import ArrayLike, NDArray
-
-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, HistogramPlotMixin):
-    """
-    Output class for :func:`dimensionstats` stats metric.
-
-    Attributes
-    ----------
-    left : NDArray[np.int32]
-        Offsets from the left edge of images in pixels
-    top : NDArray[np.int32]
-        Offsets from the top edge of images in pixels
-    width : NDArray[np.uint32]
-        Width of the images in pixels
-    height : NDArray[np.uint32]
-        Height of the images in pixels
-    channels : NDArray[np.uint8]
-        Channel count of the images in pixels
-    size : NDArray[np.uint32]
-        Size of the images in pixels
-    aspect_ratio : NDArray[np.float16]
-        :term:`ASspect Ratio<Aspect Ratio>` of the images (width/height)
-    depth : NDArray[np.uint8]
-        Color depth of the images in bits
-    center : NDArray[np.uint16]
-        Offset from center in [x,y] coordinates of the images in pixels
-    distance : NDArray[np.float16]
-        Distance in pixels from center
-    """
-
-    left: NDArray[np.int32]
-    top: NDArray[np.int32]
-    width: NDArray[np.uint32]
-    height: NDArray[np.uint32]
-    channels: NDArray[np.uint8]
-    size: NDArray[np.uint32]
-    aspect_ratio: NDArray[np.float16]
-    depth: NDArray[np.uint8]
-    center: NDArray[np.int16]
-    distance: NDArray[np.float16]
-
-
-class DimensionStatsProcessor(StatsProcessor[DimensionStatsOutput]):
-    output_class: type = DimensionStatsOutput
-    image_function_map: dict[str, Callable[[StatsProcessor[DimensionStatsOutput]], Any]] = {
-        "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
-def dimensionstats(
-    images: Iterable[ArrayLike],
-    bboxes: Iterable[ArrayLike] | None = None,
-) -> DimensionStatsOutput:
-    """
-    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.
-
-    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
-    -------
-    DimensionStatsOutput
-        A dictionary-like object containing the computed dimension statistics for each image or bounding
-        box. The keys correspond to the names of the statistics (e.g., 'width', 'height'), and the values
-        are lists of results for each image or :term:NumPy` arrays when the results are multi-dimensional.
-
-    See Also
-    --------
-    pixelstats, visualstats, Outliers
-
-    Examples
-    --------
-    Calculating the dimension statistics on the images, whose shape is (C, H, W)
-
-    >>> results = dimensionstats(stats_images)
-    >>> print(results.aspect_ratio)
-    [1.     1.     1.333  1.     0.6665]
-    >>> print(results.channels)
-    [3 3 1 3 1]
-    """
-    return run_stats(images, bboxes, False, [DimensionStatsProcessor])[0]

dataeval/metrics/stats/labelstats.py

@@ -1,210 +0,0 @@
-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 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.
-
-    Attributes
-    ----------
-    label_counts_per_class : dict[str | int, int]
-        Dictionary whose keys are the different label classes and
-        values are total counts of each class
-    label_counts_per_image : list[int]
-        Number of labels per image
-    image_counts_per_label : dict[str | int, int]
-        Dictionary whose keys are the different label classes and
-        values are total counts of each image the class is present in
-    image_indices_per_label : dict[str | int, list]
-        Dictionary whose keys are the different label classes and
-        values are lists containing the images that have that label
-    image_count : int
-        Total number of images present
-    class_count : int
-        Total number of classes present
-    label_count : int
-        Total number of labels present
-    """
-
-    label_counts_per_class: dict[str | int, int]
-    label_counts_per_image: list[int]
-    image_counts_per_label: dict[str | int, int]
-    image_indices_per_label: dict[str | int, list[int]]
-    image_count: int
-    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)
-
-
-def sort(d: Mapping[TKey, Any]) -> dict[TKey, Any]:
-    """
-    Sort mappings by key in increasing order
-    """
-    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.
-
-    This function computes counting metrics (e.g., total per class, total per image)
-    on the labels.
-
-    Parameters
-    ----------
-    labels : ArrayLike, shape - [label] | [[label]] or (N,M) | (N,)
-        Lists or :term:`NumPy` array of labels.
-        A set of lists where each list contains all labels per image -
-        (e.g. [[label1, label2], [label2], [label1, label3]] or [label1, label2, label1, label3]).
-        If a numpy array, N is the number of images, M is the number of labels per image.
-
-    Returns
-    -------
-    LabelStatsOutput
-        A dictionary-like object containing the computed counting metrics for the labels.
-
-    Examples
-    --------
-    Calculating the :term:`statistics<Statistics>` on labels for a set of data
-
-    >>> stats = labelstats(labels)
-    >>> stats.label_counts_per_class
-    {'chicken': 12, 'cow': 5, 'horse': 4, 'pig': 7, 'sheep': 4}
-    >>> stats.label_counts_per_image
-    [3, 3, 5, 3, 2, 5, 5, 2, 2, 2]
-    >>> stats.image_counts_per_label
-    {'chicken': 8, 'cow': 4, 'horse': 4, 'pig': 7, 'sheep': 4}
-    >>> (stats.image_count, stats.class_count, stats.label_count)
-    (10, 5, 32)
-    """
-    label_counts = Counter()
-    image_counts = Counter()
-    index_location = defaultdict(list[int])
-    label_per_image: list[int] = []
-
-    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
-        label_per_image.append(len(group))
-
-        # Create a set of unique items in the current sublist
-        unique_items: set[int] = set(group)
-
-        # Update image counts and index locations
-        image_counts.update(unique_items)
-        for item in unique_items:
-            index_location[item].append(i)
-
-    return LabelStatsOutput(
-        label_counts_per_class=sort(label_counts),
-        label_counts_per_image=label_per_image,
-        image_counts_per_label=sort(image_counts),
-        image_indices_per_label=sort(index_location),
-        image_count=len(label_per_image),
-        class_count=len(label_counts),
-        label_count=sum(label_counts.values()),
-    )

dataeval/utils/dataset/__init__.py

@@ -1,7 +0,0 @@
-"""Provides utility functions for interacting with Computer Vision datasets."""
-
-__all__ = ["datasets", "read_dataset", "SplitDatasetOutput", "split_dataset"]
-
-from dataeval.utils.dataset import datasets
-from dataeval.utils.dataset.read import read_dataset
-from dataeval.utils.dataset.split import SplitDatasetOutput, split_dataset