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

dataeval/_internal/metrics/stats.py

@@ -1,397 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Callable, Iterable
-
-import numpy as np
-from numpy.typing import ArrayLike, NDArray
-from scipy.stats import entropy, kurtosis, skew
-
-from dataeval._internal.flags import ImageStat, to_distinct, verify_supported
-from dataeval._internal.interop import to_numpy_iter
-from dataeval._internal.metrics.utils import edge_filter, get_bitdepth, normalize_image_shape, pchash, rescale, xxhash
-from dataeval._internal.output import OutputMetadata, populate_defaults, set_metadata
-
-CH_IDX_MAP = "ch_idx_map"
-
-
-@dataclass(frozen=True)
-class StatsOutput(OutputMetadata):
-    """
-    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
-    width : NDArray[np.uint16]
-        Width of the images in pixels
-    height : NDArray[np.uint16]
-        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
-    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
-    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
-    percentiles : NDArray[np.float16]
-        Percentiles of the pixel values of the images with quartiles of (0, 25, 50, 75, 100)
-    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
-    ch_idx_map : Dict[int, List[int]]
-        Per-channel mapping of indices for each metric
-    """
-
-    xxhash: list[str]
-    pchash: list[str]
-    width: NDArray[np.uint16]
-    height: NDArray[np.uint16]
-    channels: NDArray[np.uint8]
-    size: NDArray[np.uint32]
-    aspect_ratio: NDArray[np.float16]
-    depth: NDArray[np.uint8]
-    brightness: NDArray[np.float16]
-    blurriness: NDArray[np.float16]
-    contrast: NDArray[np.float16]
-    darkness: NDArray[np.float16]
-    missing: NDArray[np.float16]
-    zeros: NDArray[np.float16]
-    mean: NDArray[np.float16]
-    std: NDArray[np.float16]
-    var: NDArray[np.float16]
-    skew: NDArray[np.float16]
-    kurtosis: NDArray[np.float16]
-    percentiles: NDArray[np.float16]
-    histogram: NDArray[np.uint32]
-    entropy: NDArray[np.float16]
-    ch_idx_map: dict[int, list[int]]
-
-    def dict(self):
-        return {k: v for k, v in self.__dict__.items() if not k.startswith("_") and len(v) > 0}
-
-    def __len__(self) -> int:
-        if self.ch_idx_map:
-            return sum([len(idxs) for idxs in self.ch_idx_map.values()])
-        else:
-            for a in self.__annotations__:
-                attr = getattr(self, a, None)
-                if attr is not None and hasattr(a, "__len__") and len(attr) > 0:
-                    return len(attr)
-        return 0
-
-
-QUARTILES = (0, 25, 50, 75, 100)
-
-IMAGESTATS_FN_MAP: dict[ImageStat, Callable[[NDArray], Any]] = {
-    ImageStat.XXHASH: lambda x: xxhash(x),
-    ImageStat.PCHASH: lambda x: pchash(x),
-    ImageStat.WIDTH: lambda x: np.uint16(x.shape[-1]),
-    ImageStat.HEIGHT: lambda x: np.uint16(x.shape[-2]),
-    ImageStat.CHANNELS: lambda x: np.uint8(x.shape[-3]),
-    ImageStat.SIZE: lambda x: np.uint32(np.prod(x.shape[-2:])),
-    ImageStat.ASPECT_RATIO: lambda x: np.float16(x.shape[-1] / x.shape[-2]),
-    ImageStat.DEPTH: lambda x: np.uint8(get_bitdepth(x).depth),
-    ImageStat.BRIGHTNESS: lambda x: x[-2],
-    ImageStat.BLURRINESS: lambda x: np.float16(np.std(edge_filter(np.mean(x, axis=0)))),
-    ImageStat.CONTRAST: lambda x: np.float16((np.max(x) - np.min(x)) / np.mean(x)),
-    ImageStat.DARKNESS: lambda x: x[1],
-    ImageStat.MISSING: lambda x: np.float16(np.sum(np.isnan(x)) / np.prod(x.shape[-2:])),
-    ImageStat.ZEROS: lambda x: np.float16(np.count_nonzero(x == 0) / np.prod(x.shape[-2:])),
-    ImageStat.MEAN: lambda x: np.float16(np.mean(x)),
-    ImageStat.STD: lambda x: np.float16(np.std(x)),
-    ImageStat.VAR: lambda x: np.float16(np.var(x)),
-    ImageStat.SKEW: lambda x: np.float16(skew(x.ravel())),
-    ImageStat.KURTOSIS: lambda x: np.float16(kurtosis(x.ravel())),
-    ImageStat.PERCENTILES: lambda x: np.float16(np.nanpercentile(x, q=QUARTILES)),
-    ImageStat.HISTOGRAM: lambda x: np.uint32(np.histogram(x, 256, (0, 1))[0]),
-    ImageStat.ENTROPY: lambda x: np.float16(entropy(x)),
-}
-
-CHANNELSTATS_FN_MAP: dict[ImageStat, Callable[[NDArray], Any]] = {
-    ImageStat.BRIGHTNESS: lambda x: np.float16((np.max(x, axis=1) - np.mean(x, axis=1)) / np.var(x, axis=1)),
-    ImageStat.CONTRAST: lambda x: np.float16((np.max(x, axis=1) - np.min(x, axis=1)) / np.mean(x, axis=1)),
-    ImageStat.DARKNESS: lambda x: np.float16((np.mean(x, axis=1) - np.min(x, axis=1)) / np.var(x, axis=1)),
-    ImageStat.ZEROS: lambda x: np.float16(np.count_nonzero(x == 0, axis=(1, 2)) / np.prod(x.shape[-2:])),
-    ImageStat.MEAN: lambda x: np.float16(np.mean(x, axis=1)),
-    ImageStat.STD: lambda x: np.float16(np.std(x, axis=1)),
-    ImageStat.VAR: lambda x: np.float16(np.var(x, axis=1)),
-    ImageStat.SKEW: lambda x: np.float16(skew(x, axis=1)),
-    ImageStat.KURTOSIS: lambda x: np.float16(kurtosis(x, axis=1)),
-    ImageStat.PERCENTILES: lambda x: np.float16(np.nanpercentile(x, q=QUARTILES, axis=1).T),
-    ImageStat.HISTOGRAM: lambda x: np.uint32(np.apply_along_axis(lambda y: np.histogram(y, 256, (0, 1))[0], 1, x)),
-    ImageStat.ENTROPY: lambda x: np.float16(entropy(x, axis=1)),
-}
-
-
-def run_stats(
-    images: Iterable[ArrayLike],
-    flags: ImageStat,
-    fn_map: dict[ImageStat, Callable[[NDArray], Any]],
-    flatten: bool,
-):
-    """
-    Compute specified statistics on a set of images.
-
-    This function applies a set of statistical operations to each image in the input iterable,
-    based on the specified flags. The function dynamically determines which statistics to apply
-    using a flag system and a corresponding function map. It also supports optional image
-    flattening for pixel-wise calculations.
-
-    Parameters
-    ----------
-    images : ArrayLike
-        An iterable of images (e.g., list of arrays), where each image is represented as an
-        array-like structure (e.g., NumPy arrays).
-    flags : ImageStat
-        A bitwise flag or set of flags specifying the statistics to compute for each image.
-        These flags determine which functions in `fn_map` to apply.
-    fn_map : dict[ImageStat, Callable]
-        A dictionary mapping `ImageStat` flags to functions that compute the corresponding statistics.
-        Each function accepts a NumPy array (representing an image or rescaled pixel data) and returns a result.
-    flatten : bool
-        If True, the image is flattened into a 2D array for pixel-wise operations. Otherwise, the
-        original image dimensions are preserved.
-
-    Returns
-    -------
-    list[dict[str, NDArray]]
-        A list of dictionaries, where each dictionary contains the computed statistics for an image.
-        The dictionary keys correspond to the names of the statistics, and the values are NumPy arrays
-        with the results of the computations.
-
-    Raises
-    ------
-    ValueError
-        If unsupported flags are provided that are not present in `fn_map`.
-
-    Notes
-    -----
-    - The function performs image normalization (rescaling the image values)
-      before applying some of the statistics.
-    - Pixel-level statistics (e.g., brightness, entropy) are computed after
-      rescaling and, optionally, flattening the images.
-    - For statistics like histograms and entropy, intermediate results may
-      be reused to avoid redundant computation.
-    """
-    verify_supported(flags, fn_map)
-    flag_dict = to_distinct(flags)
-
-    results_list: list[dict[str, NDArray]] = []
-    for image in to_numpy_iter(images):
-        normalized = normalize_image_shape(image)
-        scaled = None
-        hist = None
-        percentiles = None
-        output: dict[str, NDArray] = {}
-        for flag, stat in flag_dict.items():
-            if flag & (ImageStat.ALL_PIXELSTATS | ImageStat.BRIGHTNESS | ImageStat.CONTRAST | ImageStat.DARKNESS):
-                if scaled is None:
-                    scaled = rescale(normalized).reshape(image.shape[0], -1) if flatten else rescale(normalized)
-                if flag & (ImageStat.HISTOGRAM | ImageStat.ENTROPY):
-                    if hist is None:
-                        hist = fn_map[ImageStat.HISTOGRAM](scaled)
-                    output[stat] = hist if flag & ImageStat.HISTOGRAM else fn_map[flag](hist)
-                elif flag & (ImageStat.BRIGHTNESS | ImageStat.DARKNESS | ImageStat.PERCENTILES):
-                    if percentiles is None:
-                        percentiles = fn_map[ImageStat.PERCENTILES](scaled)
-                    output[stat] = percentiles if flag & ImageStat.PERCENTILES else fn_map[flag](percentiles)
-                else:
-                    output[stat] = fn_map[flag](scaled)
-            else:
-                output[stat] = fn_map[flag](normalized)
-        results_list.append(output)
-    return results_list
-
-
-@set_metadata("dataeval.metrics")
-def imagestats(images: Iterable[ArrayLike], flags: ImageStat = ImageStat.ALL_STATS) -> StatsOutput:
-    """
-    Calculates image and pixel statistics for each image
-
-    This function computes various statistical metrics (e.g., mean, standard deviation, entropy)
-    on the images as a whole, based on the specified flags. It supports multiple types of statistics
-    that can be selected using the `flags` argument.
-
-    Parameters
-    ----------
-    images : ArrayLike
-        Images to run statistical tests on
-    flags : ImageStat, default ImageStat.ALL_STATS
-        Metric(s) to calculate for each image. The default flag ``ImageStat.ALL_STATS``
-        computes all available statistics.
-
-    Returns
-    -------
-    StatsOutput
-        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
-    --------
-    ImageStat, channelstats, Outliers, Duplicates
-
-    Notes
-    -----
-    - All metrics in the ImageStat.ALL_PIXELSTATS flag 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.
-    - ImageStat.ZERO and ImageStat.MISSING are presented as a percentage of total pixel counts
-
-    Examples
-    --------
-    Calculating the statistics on the images, whose shape is (C, H, W)
-
-    >>> results = imagestats(images, flags=ImageStat.MEAN | ImageStat.ALL_VISUALS)
-    >>> print(results.mean)
-    [0.16650391 0.52050781 0.05471802 0.07702637 0.09875488 0.12188721
-     0.14440918 0.16711426 0.18859863 0.21264648 0.2355957  0.25854492
-     0.27978516 0.3046875  0.32788086 0.35131836 0.37255859 0.39819336
-     0.42163086 0.4453125  0.46630859 0.49267578 0.51660156 0.54052734
-     0.56152344 0.58837891 0.61230469 0.63671875 0.65771484 0.68505859
-     0.70947266 0.73388672 0.75488281 0.78271484 0.80712891 0.83203125
-     0.85302734 0.88134766 0.90625    0.93115234]
-    >>> print(results.zeros)
-    [0.12561035 0.         0.         0.         0.11730957 0.
-     0.         0.         0.10986328 0.         0.         0.
-     0.10266113 0.         0.         0.         0.09570312 0.
-     0.         0.         0.08898926 0.         0.         0.
-     0.08251953 0.         0.         0.         0.07629395 0.
-     0.         0.         0.0703125  0.         0.         0.
-     0.0645752  0.         0.         0.        ]
-    """
-    stats = run_stats(images, flags, IMAGESTATS_FN_MAP, False)
-    output = {}
-    length = len(stats)
-    for i, results in enumerate(stats):
-        for stat, result in results.items():
-            if not isinstance(result, (np.ndarray, np.generic)):
-                output.setdefault(stat, []).append(result)
-            else:
-                shape = () if np.isscalar(result) else result.shape
-                output.setdefault(stat, np.empty((length,) + shape))[i] = result
-    return StatsOutput(**populate_defaults(output, StatsOutput))
-
-
-@set_metadata("dataeval.metrics")
-def channelstats(images: Iterable[ArrayLike], flags=ImageStat.ALL_CHANNEL_STATS) -> StatsOutput:
-    """
-    Calculates pixel statistics for each image per channel
-
-    This function computes pixel-level statistics (e.g., mean, variance, etc.) on a per-channel basis
-    for each image. The statistics can be selected using the `flags` argument, and the results will
-    be grouped by the number of channels (e.g., RGB channels) in each image.
-
-    Parameters
-    ----------
-    images : ArrayLike
-        Images to run statistical tests on
-    flags: ImageStat, default ImageStat.ALL_CHANNEL_STATS
-        Metric(s) to calculate for each image per channel.
-        Only flags within the ``ImageStat.ALL_CHANNEL_STATS`` category are supported.
-
-    Returns
-    -------
-    StatsOutput
-        A dictionary-like object containing the computed statistics for each image per channel. The keys
-        correspond to the names of the statistics (e.g., 'mean', 'variance'), and the values are numpy arrays
-        with results for each channel of each image.
-
-    See Also
-    --------
-    ImageStat, imagestats, Outliers, Duplicates
-
-    Notes
-    -----
-    - All metrics in the ImageStat.ALL_PIXELSTATS flag along with ImageStat.Brightness,
-      ImageStat.Contrast and ImageStat.Darkness 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 a per channel basis for images, whose shape is (N, C, H, W)
-
-    >>> results = channelstats(images, flags=ImageStat.MEAN | ImageStat.VAR)
-    >>> print(results.mean)
-    {3: array([[0.01617, 0.5303 , 0.06525, 0.09735, 0.1295 , 0.1616 , 0.1937 ,
-            0.2258 , 0.2578 , 0.29   , 0.322  , 0.3542 , 0.3865 , 0.4185 ,
-            0.4507 , 0.4827 , 0.5146 , 0.547  , 0.579  , 0.6113 , 0.643  ,
-            0.6753 , 0.7075 , 0.7397 , 0.7715 , 0.8037 , 0.836  , 0.868  ,
-            0.9004 , 0.932  ],
-           [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  ],
-           [0.0804 , 0.594  , 0.0693 , 0.1014 , 0.1334 , 0.1656 , 0.1978 ,
-            0.2299 , 0.262  , 0.294  , 0.3262 , 0.3584 , 0.3904 , 0.4226 ,
-            0.4546 , 0.4868 , 0.519  , 0.551  , 0.583  , 0.615  , 0.6475 ,
-            0.679  , 0.7114 , 0.7437 , 0.776  , 0.808  , 0.84   , 0.872  ,
-            0.9043 , 0.9365 ]], dtype=float16)}
-    >>> print(results.var)
-    {3: array([[0.00010103, 0.01077   , 0.0001621 , 0.0003605 , 0.0006375 ,
-            0.000993  , 0.001427  , 0.001939  , 0.00253   , 0.003199  ,
-            0.003944  , 0.004772  , 0.005676  , 0.006657  , 0.007717  ,
-            0.00886   , 0.01008   , 0.01137   , 0.01275   , 0.0142    ,
-            0.01573   , 0.01733   , 0.01903   , 0.0208    , 0.02264   ,
-            0.02457   , 0.02657   , 0.02864   , 0.0308    , 0.03305   ],
-           [0.0001798 , 0.0121    , 0.0001721 , 0.0003753 , 0.0006566 ,
-            0.001017  , 0.001455  , 0.001972  , 0.002565  , 0.003239  ,
-            0.00399   , 0.00482   , 0.00573   , 0.006714  , 0.007782  ,
-            0.00893   , 0.01015   , 0.011444  , 0.012825  , 0.01428   ,
-            0.01581   , 0.01743   , 0.01912   , 0.02089   , 0.02274   ,
-            0.02466   , 0.02667   , 0.02875   , 0.03091   , 0.03314   ],
-           [0.000337  , 0.0135    , 0.0001824 , 0.0003903 , 0.0006766 ,
-            0.00104   , 0.001484  , 0.002005  , 0.002604  , 0.00328   ,
-            0.004036  , 0.00487   , 0.005783  , 0.006775  , 0.00784   ,
-            0.00899   , 0.010216  , 0.01152   , 0.0129    , 0.01436   ,
-            0.0159    , 0.01752   , 0.01921   , 0.02098   , 0.02283   ,
-            0.02477   , 0.02676   , 0.02885   , 0.03102   , 0.03326   ]],
-          dtype=float16)}
-    """
-    stats = run_stats(images, flags, CHANNELSTATS_FN_MAP, True)
-    output = {}
-    for i, results in enumerate(stats):
-        for stat, result in results.items():
-            channels = result.shape[0]
-            output.setdefault(stat, {}).setdefault(channels, []).append(result)
-            output.setdefault(CH_IDX_MAP, {}).setdefault(channels, {})[i] = None
-
-    # Concatenate list of channel statistics numpy
-    for stat in output:
-        if stat == CH_IDX_MAP:
-            continue
-        for channel in output[stat]:
-            output[stat][channel] = np.array(output[stat][channel]).T
-
-    for channel in output[CH_IDX_MAP]:
-        output[CH_IDX_MAP][channel] = list(output[CH_IDX_MAP][channel].keys())
-
-    return StatsOutput(**populate_defaults(output, StatsOutput))

dataeval/flags/__init__.py

@@ -1,3 +0,0 @@
-from dataeval._internal.flags import ImageStat
-
-__all__ = ["ImageStat"]

dataeval/tensorflow/__init__.py

@@ -1,3 +0,0 @@
-from . import loss, models, recon
-
-__all__ = ["loss", "models", "recon"]

dataeval/torch/__init__.py

@@ -1,3 +0,0 @@
-from . import models, trainer
-
-__all__ = ["models", "trainer"]

dataeval-0.69.4.dist-info/RECORD

@@ -1,74 +0,0 @@
-dataeval/__init__.py,sha256=KOZnb9SovSSuD2UrqV-NS_b5vpfWdQlsweB55fned58,590
-dataeval/_internal/datasets.py,sha256=MwN6xgZW1cA5yIxXZ05qBBz4aO3bjKzIEbZZfa1HkQo,9790
-dataeval/_internal/detectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/detectors/clusterer.py,sha256=hJwELUeAdZZ3OVLIfwalw2P7Zz13q2ZqrV6gx90s44E,20695
-dataeval/_internal/detectors/drift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/detectors/drift/base.py,sha256=XSX1VVUxvFFKVFQVsc2WWeaRRmIxuYaIgD_c5H4OraA,15930
-dataeval/_internal/detectors/drift/cvm.py,sha256=xiyZlf0rAQGG8Z6ZBLPVri805aPRkERrUySwRN8cTZQ,4010
-dataeval/_internal/detectors/drift/ks.py,sha256=aoDx7ps-5vrSI8Q9ii6cwmKnAyaD8tjG69wI-7R3MVQ,4098
-dataeval/_internal/detectors/drift/mmd.py,sha256=j85bwzCiFLNS27WlUFlgpHDMD9yga41ILt-yAr-LABc,7493
-dataeval/_internal/detectors/drift/torch.py,sha256=YhIN85MbUV3C4IJcRvqYdXSWLj5lUeEOb05T5DgB3xo,11552
-dataeval/_internal/detectors/drift/uncertainty.py,sha256=Ot8L42AnFbkij4J3Tis7VzXLv3hfBxoOWBP4UoCEnVs,5125
-dataeval/_internal/detectors/duplicates.py,sha256=qkzbdWuJuUozFLqpnD6CYAGXQb7-aWw2mHr_cxXAfPo,4922
-dataeval/_internal/detectors/merged_stats.py,sha256=WVPxz7n5fUkFKW3kobD_TkKkof51YjfIz4M_4CHh-1s,2517
-dataeval/_internal/detectors/ood/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/detectors/ood/ae.py,sha256=k8pZP7oPwVyQlv6YcoacNMzpmQZy7W222yYrdXGTYZI,2031
-dataeval/_internal/detectors/ood/aegmm.py,sha256=pffThqXRoLx3GuZXEQBd-xEy5DjAZHV7WSeP2HgM_TI,2403
-dataeval/_internal/detectors/ood/base.py,sha256=Pw34uFEWOJZiG4ciM0ArUkqhiM8WCGl2rc0BwFPu3xM,8240
-dataeval/_internal/detectors/ood/llr.py,sha256=tCo8G7V8VaVuIZ09rg0ZXZmdE0N_zGm7vCfFUnGbGvo,10102
-dataeval/_internal/detectors/ood/vae.py,sha256=WbQugS-bBUTTqQ9PRLHBmSUtk7O2_PN4PBLJE9ieMjw,2921
-dataeval/_internal/detectors/ood/vaegmm.py,sha256=pVUSlVF2jo8uokyks2QzfBJnNtcFWmcF8EQl-azs2Bg,2832
-dataeval/_internal/detectors/outliers.py,sha256=oS8lsCPIM6WtLzUjpMZDfiopZA2fJhsHakmSzZUhqHU,7614
-dataeval/_internal/flags.py,sha256=5hZ5AHXjXRKbWtFC45-J7M9NvJHsT4LKRsPzPMksgfQ,2323
-dataeval/_internal/interop.py,sha256=x4qj4EiBt5NthSxe8prSLrPDAEcipAdyyLwbNyCBaFk,1059
-dataeval/_internal/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/metrics/balance.py,sha256=eAHvgjiGCH893XSQLqh9j9wgvAECoNPVT8k0u_9Ijzg,6097
-dataeval/_internal/metrics/ber.py,sha256=Onsi47AbT9rMvng-Pbu8LIrYRfLpI13En1FxkFoMKQs,4668
-dataeval/_internal/metrics/coverage.py,sha256=EZVES1rbZW2j_CtQv1VFfSO-UmWcrt5nmqxDErtrG14,3473
-dataeval/_internal/metrics/divergence.py,sha256=nmMUfr9FGnH798eb6xzEiMj4C42rQVthh5HeexiY6EE,4119
-dataeval/_internal/metrics/diversity.py,sha256=_oT0FHsgfLOoe_TLD2Aax4r4jmH6WnOPVIkcl_YjaoY,7582
-dataeval/_internal/metrics/parity.py,sha256=VszQNbHWjct2bCqrIXUZC_qFi4ZIq2Lm-vs-DiarBFo,16244
-dataeval/_internal/metrics/stats.py,sha256=ILKteVMGjrp1s2CECPL_hbLsijIKR2d6II2-8w9oxW8,18105
-dataeval/_internal/metrics/uap.py,sha256=w-wvXXnX16kUq-weaZD2SrJi22LJ8EjOFbOhPxeGejI,2043
-dataeval/_internal/metrics/utils.py,sha256=mSYa-3cHGcsQwPr7zbdpzrnK_8jIXCiAcu2HCcvrtaY,13007
-dataeval/_internal/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/models/pytorch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/models/pytorch/autoencoder.py,sha256=gmnAHUzzn-fXTUU63SR4ZBjGBLEALWPxmZ_wPzvF_dg,8365
-dataeval/_internal/models/pytorch/blocks.py,sha256=pm2xwsDZjZJYXrhhiz8husvh2vHmrkFMSYEn-EDUD5Q,1354
-dataeval/_internal/models/pytorch/utils.py,sha256=Qgwym1PxGuwxbXCKUT-8r6Iyrxqm7x94oj45Vf5_CjE,1675
-dataeval/_internal/models/tensorflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/models/tensorflow/autoencoder.py,sha256=Ryn11jDbpZJOM5De-kMGPdbJBQEdwip6B20ajS8HqpE,10354
-dataeval/_internal/models/tensorflow/gmm.py,sha256=QoEgbeax1GETqRmUF7A2ih9uFOZfFAjGzgH2ljExlAc,3669
-dataeval/_internal/models/tensorflow/losses.py,sha256=pZH5RnlM9R0RrBde9Lgq32muwAp7_PWc56Mu4u8RVvo,3976
-dataeval/_internal/models/tensorflow/pixelcnn.py,sha256=lRpRNebMgkCJUnEk1xouVaTfS_YGMQgQhI01wNKAjeM,48420
-dataeval/_internal/models/tensorflow/trainer.py,sha256=xNY0Iw7Qa1TnCuy9N1b77_VduFoW_BhbZjfQCxOVby4,4082
-dataeval/_internal/models/tensorflow/utils.py,sha256=l6jXKMWyQAEI4LpAONq95Xwr7CPgrs408ypf9TuNxkY,8732
-dataeval/_internal/output.py,sha256=bFC2qJxXUc_daQwJHHa9KfFNLuxZANGb7Dpget_TXYs,3049
-dataeval/_internal/utils.py,sha256=gK0z4buuQoUYblkrCiRV9pIESzyikcY-3a08XsQkD7E,1585
-dataeval/_internal/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/workflows/sufficiency.py,sha256=0k7Dbk3QmEGkZp2IW4OcZBcrxb4zAp9hC9nXGN1v1cY,18199
-dataeval/detectors/__init__.py,sha256=WVlwapZtKXVvrW41Sq30sFd8j2phS8JMsCaLeXfbQ7k,204
-dataeval/detectors/drift/__init__.py,sha256=XtSjoTy6P_lwRzC9Klmd9BYZ3v4qZrATJ-p7gvvHPGk,598
-dataeval/detectors/drift/kernels/__init__.py,sha256=qV_r740iRPw39_kHOttmk3VNikDFKCvF9i1IGbgjf3A,186
-dataeval/detectors/drift/updates/__init__.py,sha256=uwkRV-4WVg0XFX_9futvQ0ggGOEvduDedgCno_eIi4U,149
-dataeval/detectors/linters/__init__.py,sha256=1yxsJw8CFpHsZwn_YUlWpb-4YBet5U6uB--MeRgB6io,234
-dataeval/detectors/ood/__init__.py,sha256=ybWhwbMmWygIwE1A-nYihDfugrj3j0GiuABmVvD7264,583
-dataeval/flags/__init__.py,sha256=qo06_Tk0ul4lOhKSEs0HE2G6WBFvMwNJq77vRX1ynww,72
-dataeval/metrics/__init__.py,sha256=42szGyZrLekNU-T-rwJu-pUoDBdOoStuScB-mnGzjw4,81
-dataeval/metrics/bias/__init__.py,sha256=xqpxCttgzz-hMZQI7_IlaNn4OGZaGVz3KKRd26GbSKE,335
-dataeval/metrics/estimators/__init__.py,sha256=fWQZUIxu88u5POYXN1yoFc-Hxx5B1fveEiiSXmK5kPk,210
-dataeval/metrics/stats/__init__.py,sha256=N5UvO7reDkYX1xFdAQjwALyJwcC2FAbruzd7ZYYW_4I,123
-dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/tensorflow/__init__.py,sha256=IH_ELFP9CwKPk_br8_dKi6HeAlwmmV2vgsWdD8IFKXU,72
-dataeval/tensorflow/loss/__init__.py,sha256=E9eB87LNh0o5nUCqssB027EXBsOfEayNHPcNW0QGFdA,101
-dataeval/tensorflow/models/__init__.py,sha256=OVpmHF8itDcgOlfw6N9jr7IphZPbMJoiu7OdqYhU9fs,291
-dataeval/tensorflow/recon/__init__.py,sha256=xe6gAQqK9tyAoDQTtaJAxIPK1humt5QzsG_9NPsqx58,116
-dataeval/torch/__init__.py,sha256=ZNGSJJmatdGzbrazw86yNveEXm8smmW63xD-ReA8Nfg,63
-dataeval/torch/models/__init__.py,sha256=YnDnePYpRIKHyYn3F5qR1OObMSb-g0FGvI8X-uTB09E,162
-dataeval/torch/trainer/__init__.py,sha256=Te-qElt8h-Zv8NN0r-VJOEdCPHTQ2yO3rd2MhRiZGZs,93
-dataeval/utils/__init__.py,sha256=ExQ1xj62MjcM9uIu1-g1P2fW0EPJpcIofnvxjQ908c4,172
-dataeval/workflows/__init__.py,sha256=gkU2B6yUiefexcYrBwqfZKNl8BvX8abUjfeNvVBXF4E,186
-dataeval-0.69.4.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
-dataeval-0.69.4.dist-info/METADATA,sha256=R_YlthIsAkOizGWkgXiOCEsD_6F5wJm8qjU4hjhL_c8,4292
-dataeval-0.69.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-dataeval-0.69.4.dist-info/RECORD,,