dataeval 0.69.4__py3-none-any.whl → 0.70.0__py3-none-any.whl

dataeval/_internal/metrics/stats/datasetstats.py

@@ -0,0 +1,97 @@
+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):
+    """
+    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,
+    )

dataeval/_internal/metrics/stats/dimensionstats.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+from dataeval._internal.metrics.stats.base import BaseStatsOutput, StatsProcessor, run_stats
+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):
+    """
+    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]
+        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]
+
+
+@set_metadata("dataeval.metrics")
+def dimensionstats(
+    images: Iterable[ArrayLike],
+    bboxes: Iterable[ArrayLike] | None = None,
+) -> DimensionStatsOutput:
+    """
+    Calculates dimension 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 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(images)
+    >>> print(results.aspect_ratio)
+    [0.75  0.75  0.75  0.75  0.75  0.75  1.333 0.75  0.75  1.   ]
+    >>> print(results.channels)
+    [1 1 1 1 1 1 3 1 1 3]
+    """
+    output = run_stats(images, bboxes, False, DimensionStatsProcessor, DimensionStatsOutput)
+    return DimensionStatsOutput(**output)

dataeval/_internal/metrics/stats/hashstats.py

@@ -0,0 +1,73 @@
+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, StatsProcessor, run_stats
+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):
+    """
+    Attributes
+    ----------
+    xxhash : List[str]
+        xxHash hash of the images as a hex string
+    pchash : List[str]
+        Perception hash of the images as a hex string
+    """
+
+    xxhash: list[str]
+    pchash: list[str]
+
+
+@set_metadata("dataeval.metrics")
+def hashstats(
+    images: Iterable[ArrayLike],
+    bboxes: Iterable[ArrayLike] | None = None,
+) -> HashStatsOutput:
+    """
+    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.
+
+    Parameters
+    ----------
+    images : ArrayLike
+        Images to hashing
+    bboxes : Iterable[ArrayLike] or None
+        Bounding boxes in `xyxy` format for each image
+
+    Returns
+    -------
+    HashStatsOutput
+        A dictionary-like object containing the computed hashes for each image.
+
+    See Also
+    --------
+    Duplicates
+
+    Examples
+    --------
+    Calculating the statistics on the images, whose shape is (C, H, W)
+
+    >>> results = hashstats(images)
+    >>> print(results.xxhash)
+    ['a72434443d6e7336', 'efc12c2f14581d79', '4a1e03483a27d674', '3a3ecedbcf814226']
+    >>> print(results.pchash)
+    ['8f25506af46a7c6a', '8000808000008080', '8e71f18e0ef18e0e', 'a956d6a956d6a928']
+    """
+    output = run_stats(images, bboxes, False, HashStatsProcessor, HashStatsOutput)
+    return HashStatsOutput(**output)

dataeval/_internal/metrics/stats/labelstats.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from typing import Any, Iterable, Mapping, TypeVar
+
+from numpy.typing import ArrayLike
+
+from dataeval._internal.interop import to_numpy
+from dataeval._internal.output import OutputMetadata, set_metadata
+
+
+@dataclass(frozen=True)
+class LabelStatsOutput(OutputMetadata):
+    """
+    Output class for `labelstats` metrics function
+
+    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
+
+
+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]))
+
+
+@set_metadata("dataeval.metrics")
+def labelstats(
+    labels: Iterable[ArrayLike],
+) -> LabelStatsOutput:
+    """
+    Calculates 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 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 statistics on labels for a set of data
+
+    >>> stats = labelstats(labels)
+    >>> stats.label_counts_per_class
+    {'chicken': 3, 'cow': 8, 'horse': 9, 'pig': 7, 'sheep': 7}
+    >>> stats.label_counts_per_image
+    [3, 2, 3, 4, 1, 5, 4, 4, 4, 4]
+    >>> stats.image_counts_per_label
+    {'chicken': 2, 'cow': 6, 'horse': 7, 'pig': 5, 'sheep': 7}
+    >>> (stats.image_count, stats.class_count, stats.label_count)
+    (10, 5, 34)
+    """
+    label_counts = Counter()
+    image_counts = Counter()
+    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)
+
+        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/_internal/metrics/stats/pixelstats.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+from scipy.stats import entropy, kurtosis, skew
+
+from dataeval._internal.metrics.stats.base import BaseStatsOutput, StatsProcessor, run_stats
+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):
+    """
+    Attributes
+    ----------
+    mean : NDArray[np.float16]
+        Mean of the pixel values of the images
+    std : NDArray[np.float16]
+        Standard deviation of the pixel values of the images
+    var : NDArray[np.float16]
+        Variance of the pixel values of the images
+    skew : NDArray[np.float16]
+        Skew of the pixel values of the images
+    kurtosis : NDArray[np.float16]
+        Kurtosis of the pixel values of the images
+    histogram : NDArray[np.uint32]
+        Histogram of the pixel values of the images across 256 bins scaled between 0 and 1
+    entropy : NDArray[np.float16]
+        Entropy of the pixel values of the images
+    """
+
+    mean: NDArray[np.float16]
+    std: NDArray[np.float16]
+    var: NDArray[np.float16]
+    skew: NDArray[np.float16]
+    kurtosis: NDArray[np.float16]
+    histogram: NDArray[np.uint32]
+    entropy: NDArray[np.float16]
+
+
+@set_metadata("dataeval.metrics")
+def pixelstats(
+    images: Iterable[ArrayLike],
+    bboxes: Iterable[ArrayLike] | None = None,
+    per_channel: bool = False,
+) -> PixelStatsOutput:
+    """
+    Calculates pixel statistics for each image
+
+    This function computes various statistical metrics (e.g., mean, standard deviation, entropy)
+    on the images as a whole.
+
+    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
+
+    Returns
+    -------
+    PixelStatsOutput
+        A dictionary-like object containing the computed statistics for each image. The keys correspond
+        to the names of the statistics (e.g., 'mean', 'std'), and the values are lists of results for
+        each image or numpy arrays when the results are multi-dimensional.
+
+    See Also
+    --------
+    dimensionstats, visualstats, Outliers
+
+    Notes
+    -----
+    - All metrics are scaled based on the perceived bit depth (which is derived from the largest pixel value)
+      to allow for better comparison between images stored in different formats and different resolutions.
+
+    Examples
+    --------
+    Calculating the statistics on the images, whose shape is (C, H, W)
+
+    >>> results = pixelstats(images)
+    >>> print(results.mean)
+    [0.04828 0.562   0.06726 0.09937 0.1315  0.1636  0.1957  0.2278  0.26
+     0.292   0.3242  0.3562  0.3884  0.4204  0.4526  0.4846  0.5166  0.549
+     0.581   0.6133  0.6455  0.6772  0.7095  0.7417  0.774   0.8057  0.838
+     0.87    0.9023  0.934  ]
+    >>> print(results.entropy)
+    [3.238  3.303  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 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)

dataeval/_internal/metrics/stats/visualstats.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+from dataeval._internal.metrics.stats.base import BaseStatsOutput, StatsProcessor, run_stats
+from dataeval._internal.metrics.utils import edge_filter
+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):
+    """
+    Attributes
+    ----------
+    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
+    zeros : NDArray[np.float16]
+        Percentage of the images with zero value pixels
+    percentiles : NDArray[np.float16]
+        Percentiles of the pixel values of the images with quartiles of (0, 25, 50, 75, 100)
+    """
+
+    brightness: NDArray[np.float16]
+    blurriness: NDArray[np.float16]
+    contrast: NDArray[np.float16]
+    darkness: NDArray[np.float16]
+    missing: NDArray[np.float16]
+    zeros: NDArray[np.float16]
+    percentiles: NDArray[np.float16]
+
+
+@set_metadata("dataeval.metrics")
+def visualstats(
+    images: Iterable[ArrayLike],
+    bboxes: Iterable[ArrayLike] | None = None,
+    per_channel: bool = False,
+) -> VisualStatsOutput:
+    """
+    Calculates visual statistics for each image
+
+    This function computes various visual metrics (e.g., brightness, darkness, contrast, blurriness)
+    on the images as a whole.
+
+    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
+    -------
+    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
+        each image or numpy arrays when the results are multi-dimensional.
+
+    See Also
+    --------
+    dimensionstats, pixelstats, Outliers
+
+    Notes
+    -----
+    - `zeros` and `missing` are presented as a percentage of total pixel counts
+
+    Examples
+    --------
+    Calculating the statistics on the images, whose shape is (C, H, W)
+
+    >>> 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 ]
+    >>> 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)

dataeval/_internal/metrics/uap.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass
 from numpy.typing import ArrayLike
 from sklearn.metrics import average_precision_score
 
-from dataeval._internal.interop import to_numpy
+from dataeval._internal.interop import as_numpy
 from dataeval._internal.output import OutputMetadata, set_metadata
 
 
@@ -75,5 +75,5 @@ def uap(labels: ArrayLike, scores: ArrayLike) -> UAPOutput:
     UAPOutput(uap=0.7777777777777777)
     """
 
-    precision = float(average_precision_score(to_numpy(labels), to_numpy(scores), average="weighted"))
+    precision = float(average_precision_score(as_numpy(labels), as_numpy(scores), average="weighted"))
     return UAPOutput(precision)