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

dataeval/interop.py

@@ -1,69 +0,0 @@
-"""Utility functions for interoperability with different array types."""
-
-from __future__ import annotations
-
-__all__ = []
-
-import logging
-from importlib import import_module
-from types import ModuleType
-from typing import Any, Iterable, Iterator
-
-import numpy as np
-from numpy.typing import ArrayLike, NDArray
-
-from dataeval.log import LogMessage
-
-_logger = logging.getLogger(__name__)
-
-_MODULE_CACHE = {}
-
-
-def _try_import(module_name) -> ModuleType | None:
-    if module_name in _MODULE_CACHE:
-        return _MODULE_CACHE[module_name]
-
-    try:
-        module = import_module(module_name)
-    except ImportError:  # pragma: no cover - covered by test_mindeps.py
-        _logger.log(logging.INFO, f"Unable to import {module_name}.")
-        module = None
-
-    _MODULE_CACHE[module_name] = module
-    return module
-
-
-def as_numpy(array: ArrayLike | None) -> NDArray[Any]:
-    """Converts an ArrayLike to Numpy array without copying (if possible)"""
-    return to_numpy(array, copy=False)
-
-
-def to_numpy(array: ArrayLike | None, copy: bool = True) -> NDArray[Any]:
-    """Converts an ArrayLike to new Numpy array"""
-    if array is None:
-        return np.ndarray([])
-
-    if isinstance(array, np.ndarray):
-        return array.copy() if copy else array
-
-    if array.__class__.__module__.startswith("tensorflow"):  # pragma: no cover - removed tf from deps
-        tf = _try_import("tensorflow")
-        if tf and tf.is_tensor(array):
-            _logger.log(logging.INFO, "Converting Tensorflow array to NumPy array.")
-            return array.numpy().copy() if copy else array.numpy()  # type: ignore
-
-    if array.__class__.__module__.startswith("torch"):
-        torch = _try_import("torch")
-        if torch and isinstance(array, torch.Tensor):
-            _logger.log(logging.INFO, "Converting PyTorch array to NumPy array.")
-            numpy = array.detach().cpu().numpy().copy() if copy else array.detach().cpu().numpy()  # type: ignore
-            _logger.log(logging.DEBUG, LogMessage(lambda: f"{str(array)} -> {str(numpy)}"))
-            return numpy
-
-    return np.array(array) if copy else np.asarray(array)
-
-
-def to_numpy_iter(iterable: Iterable[ArrayLike]) -> Iterator[NDArray[Any]]:
-    """Yields an iterator of numpy arrays from an ArrayLike"""
-    for array in iterable:
-        yield to_numpy(array)

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

dataeval/utils/dataset/datasets.py

@@ -1,412 +0,0 @@
-"""Provides access to common Computer Vision datasets."""
-
-from __future__ import annotations
-
-__all__ = ["MNIST", "CIFAR10", "VOCDetection"]
-
-import hashlib
-import os
-import zipfile
-from pathlib import Path
-from typing import Literal, TypeVar
-from warnings import warn
-
-import numpy as np
-import requests
-from numpy.typing import NDArray
-from torch.utils.data import Dataset
-from torchvision.datasets import CIFAR10, VOCDetection
-
-ClassStringMap = Literal["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
-TClassMap = TypeVar("TClassMap", ClassStringMap, int, list[ClassStringMap], list[int])
-CorruptionStringMap = Literal[
-    "identity",
-    "shot_noise",
-    "impulse_noise",
-    "glass_blur",
-    "motion_blur",
-    "shear",
-    "scale",
-    "rotate",
-    "brightness",
-    "translate",
-    "stripe",
-    "fog",
-    "spatter",
-    "dotted_line",
-    "zigzag",
-    "canny_edges",
-]
-
-
-def _validate_file(fpath, file_md5, md5=False, chunk_size=65535):
-    hasher = hashlib.md5() if md5 else hashlib.sha256()
-    with open(fpath, "rb") as fpath_file:
-        while chunk := fpath_file.read(chunk_size):
-            hasher.update(chunk)
-    return hasher.hexdigest() == file_md5
-
-
-def _get_file(
-    root: str | Path,
-    fname: str,
-    origin: str,
-    file_hash: str | None = None,
-    verbose: bool = True,
-    md5: bool = False,
-    timeout: int = 60,
-):
-    fpath = os.path.join(root, fname)
-    download = True
-    if os.path.exists(fpath) and file_hash is not None and _validate_file(fpath, file_hash, md5):
-        download = False
-        if verbose:
-            print("File already downloaded and verified.")
-            if md5:
-                print("Extracting zip file...")
-
-    if download:
-        try:
-            error_msg = "URL fetch failure on {}: {} -- {}"
-            try:
-                with requests.get(origin, stream=True, timeout=timeout) as r:
-                    r.raise_for_status()
-                    with open(fpath, "wb") as f:
-                        for chunk in r.iter_content(chunk_size=8192):
-                            if chunk:
-                                f.write(chunk)
-            except requests.exceptions.HTTPError as e:
-                raise RuntimeError(f"{error_msg.format(origin, e.response.status_code, e.response.reason)}") from e
-            except requests.exceptions.RequestException as e:
-                raise ValueError(f"{error_msg.format(origin, 'Unknown error', str(e))}") from e
-        except (Exception, KeyboardInterrupt):
-            if os.path.exists(fpath):
-                os.remove(fpath)
-            raise
-
-        if os.path.exists(fpath) and file_hash is not None and not _validate_file(fpath, file_hash, md5):
-            raise ValueError(
-                "Incomplete or corrupted file detected. "
-                f"The file hash does not match the provided value "
-                f"of {file_hash}.",
-            )
-
-    return fpath
-
-
-def _check_exists(
-    folder: str | Path,
-    url: str,
-    root: str | Path,
-    fname: str,
-    file_hash: str,
-    download: bool = True,
-    verbose: bool = True,
-    md5: bool = False,
-):
-    """Determine if the dataset has already been downloaded."""
-    location = str(folder)
-    if not os.path.exists(folder):
-        if download:
-            location = _download_dataset(url, root, fname, file_hash, verbose, md5)
-        else:
-            raise RuntimeError("Dataset not found. You can use download=True to download it")
-    else:
-        if verbose:
-            print("Files already downloaded and verified")
-    return location
-
-
-def _download_dataset(
-    url: str, root: str | Path, fname: str, file_hash: str, verbose: bool = True, md5: bool = False
-) -> str:
-    """Code to download mnist and corruptions, originates from tensorflow_datasets (tfds):
-    https://github.com/tensorflow/datasets/blob/master/tensorflow_datasets/image_classification/mnist_corrupted.py
-    """
-    name, _ = os.path.splitext(fname)
-    folder = os.path.join(root, name)
-    os.makedirs(folder, exist_ok=True)
-
-    fpath = _get_file(
-        folder,
-        fname,
-        origin=url + fname,
-        file_hash=file_hash,
-        verbose=verbose,
-        md5=md5,
-    )
-    if md5:
-        folder = _extract_archive(fpath, root, remove_finished=True)
-    return folder
-
-
-def _extract_archive(
-    from_path: str | Path,
-    to_path: str | Path | None = None,
-    remove_finished: bool = False,
-) -> str:
-    """Extract an archive.
-
-    The archive type and a possible compression is automatically detected from the file name.
-    """
-    from_path = Path(from_path)
-    if not from_path.is_absolute():
-        from_path = from_path.resolve()
-
-    if to_path is None or not os.path.exists(to_path):
-        to_path = os.path.dirname(from_path)
-    to_path = Path(to_path)
-    if not to_path.is_absolute():
-        to_path = to_path.resolve()
-
-    # Extracting zip
-    with zipfile.ZipFile(from_path, "r", compression=zipfile.ZIP_STORED) as zzip:
-        zzip.extractall(to_path)
-
-    if remove_finished:
-        os.remove(from_path)
-    return str(to_path)
-
-
-def _subselect(arr: NDArray, count: int, from_back: bool = False):
-    if from_back:
-        return arr[-count:]
-    return arr[:count]
-
-
-class MNIST(Dataset[tuple[NDArray[np.float64], int]]):
-    """MNIST Dataset and Corruptions.
-
-    Args:
-        root : str | ``pathlib.Path``
-            Root directory of dataset where the ``mnist_c/`` folder exists.
-        train : bool, default True
-            If True, creates dataset from ``train_images.npy`` and ``train_labels.npy``.
-        download : bool, default False
-            If True, downloads the dataset from the internet and puts it in root
-            directory. If dataset is already downloaded, it is not downloaded again.
-        size : int, default -1
-            Limit the dataset size, must be a value greater than 0.
-        unit_interval : bool, default False
-            Shift the data values to the unit interval [0-1].
-        dtype : type | None, default None
-            Change the :term:`NumPy` dtype - data is loaded as np.uint8
-        channels : Literal['channels_first' | 'channels_last'] | None, default None
-            Location of channel axis if desired, default has no channels (N, 28, 28)
-        flatten : bool, default False
-            Flatten data into single dimension (N, 784) - cannot use both channels and flatten,
-            channels takes priority over flatten.
-        normalize : tuple[mean, std] | None, default None
-            Normalize images acorrding to provided mean and standard deviation
-        corruption : Literal['identity' | 'shot_noise' | 'impulse_noise' | 'glass_blur' |
-            'motion_blur' | 'shear' | 'scale' | 'rotate' | 'brightness' | 'translate' | 'stripe' |
-            'fog' | 'spatter' | 'dotted_line' | 'zigzag' | 'canny_edges'] | None, default None
-            The desired corruption style or None.
-        classes : Literal["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
-            | int | list[int] | list[Literal["zero", "one", "two", "three", "four", "five", "six", "seven",
-            "eight", "nine"]] | None, default None
-            Option to select specific classes from dataset.
-        balance : bool, default True
-            If True, returns equal number of samples for each class.
-        randomize : bool, default True
-            If True, shuffles the data prior to selection - uses a set seed for reproducibility.
-        slice_back : bool, default False
-            If True and size has a value greater than 0, then grabs selection starting at the last image.
-        verbose : bool, default True
-            If True, outputs print statements.
-    """
-
-    _mirrors: tuple[str, ...] = (
-        "https://storage.googleapis.com/tensorflow/tf-keras-datasets/",
-        "https://zenodo.org/record/3239543/files/",
-    )
-
-    _resources: tuple[tuple[str, str], ...] = (
-        ("mnist.npz", "731c5ac602752760c8e48fbffcf8c3b850d9dc2a2aedcf2cc48468fc17b673d1"),
-        ("mnist_c.zip", "4b34b33045869ee6d424616cd3a65da3"),
-    )
-
-    class_dict: dict[str, int] = {
-        "zero": 0,
-        "one": 1,
-        "two": 2,
-        "three": 3,
-        "four": 4,
-        "five": 5,
-        "six": 6,
-        "seven": 7,
-        "eight": 8,
-        "nine": 9,
-    }
-
-    def __init__(
-        self,
-        root: str | Path,
-        train: bool = True,
-        download: bool = False,
-        size: int = -1,
-        unit_interval: bool = False,
-        dtype: type | None = None,
-        channels: Literal["channels_first", "channels_last"] | None = None,
-        flatten: bool = False,
-        normalize: tuple[float, float] | None = None,
-        corruption: CorruptionStringMap | None = None,
-        classes: TClassMap | None = None,
-        balance: bool = True,
-        randomize: bool = True,
-        slice_back: bool = False,
-        verbose: bool = True,
-    ) -> None:
-        if isinstance(root, str):
-            root = os.path.expanduser(root)
-        self.root = root  # location of stored dataset
-        self.train = train  # training set or test set
-        self.size = size
-        self.unit_interval = unit_interval
-        self.dtype = dtype
-        self.channels = channels
-        self.flatten = flatten
-        self.normalize = normalize
-        self.corruption = corruption
-        self.balance = balance
-        self.randomize = randomize
-        self.from_back = slice_back
-        self.verbose = verbose
-        self.data: NDArray[np.float64]
-        self.targets: NDArray[np.int_]
-        self.size: int
-
-        self._class_set = []
-        if classes is not None:
-            if not isinstance(classes, list):
-                classes = [classes]  # type: ignore
-
-            for val in classes:  # type: ignore
-                if isinstance(val, int) and 0 <= val < 10:
-                    self._class_set.append(val)
-                elif isinstance(val, str):
-                    self._class_set.append(self.class_dict[val])
-            self._class_set = set(self._class_set)
-
-        if not self._class_set:
-            self._class_set = set(self.class_dict.values())
-
-        self._num_classes = len(self._class_set)
-
-        if self.corruption is None:
-            file_resource = self._resources[0]
-            mirror = self._mirrors[0]
-            md5 = False
-        else:
-            if self.corruption == "identity" and verbose:
-                print("Identity is not a corrupted dataset but the original MNIST dataset.")
-            file_resource = self._resources[1]
-            mirror = self._mirrors[1]
-            md5 = True
-        _check_exists(self.mnist_folder, mirror, self.root, file_resource[0], file_resource[1], download, verbose, md5)
-
-        self.data, self.targets = self._load_data()
-
-        self._augmentations()
-
-    def _load_data(self) -> tuple[NDArray[np.float64], NDArray[np.int64]]:
-        if self.corruption is None:
-            image_file = self._resources[0][0]
-            data, targets = self._read_normal_file(os.path.join(self.mnist_folder, image_file))
-        else:
-            image_file = f"{'train' if self.train else 'test'}_images.npy"
-            data = self._read_corrupt_file(os.path.join(self.mnist_folder, image_file))
-            data = data.squeeze()
-
-            label_file = f"{'train' if self.train else 'test'}_labels.npy"
-            targets = self._read_corrupt_file(os.path.join(self.mnist_folder, label_file))
-
-        return data, targets
-
-    def _augmentations(self):
-        if self.size > self.targets.shape[0] and self.verbose:
-            warn(
-                f"Asked for more samples, {self.size}, than the raw dataset contains, {self.targets.shape[0]}. "
-                "Adjusting down to raw dataset size."
-            )
-            self.size = -1
-
-        if self.randomize:
-            rdm_seed = np.random.default_rng(2023)
-            shuffled_indices = rdm_seed.permutation(self.data.shape[0])
-            self.data = self.data[shuffled_indices]
-            self.targets = self.targets[shuffled_indices]
-
-        if not self.balance and self._num_classes > self.size:
-            if self.size > 0:
-                self.data = _subselect(self.data, self.size, self.from_back)
-                self.targets = _subselect(self.targets, self.size, self.from_back)
-        else:
-            label_dict = {label: np.where(self.targets == label)[0] for label in self._class_set}
-            min_label_count = min(len(indices) for indices in label_dict.values())
-
-            self._per_class_count = int(np.ceil(self.size / self._num_classes)) if self.size > 0 else min_label_count
-
-            if self._per_class_count > min_label_count:
-                self._per_class_count = min_label_count
-                if not self.balance and self.verbose:
-                    warn(
-                        f"Because of dataset limitations, only {min_label_count*self._num_classes} samples "
-                        f"will be returned, instead of the desired {self.size}."
-                    )
-
-            all_indices: NDArray[np.int_] = np.empty(shape=(self._num_classes, self._per_class_count), dtype=np.int_)
-            for i, label in enumerate(self._class_set):
-                all_indices[i] = _subselect(label_dict[label], self._per_class_count, self.from_back)
-            self.data = np.vstack(self.data[all_indices.T])  # type: ignore
-            self.targets = np.hstack(self.targets[all_indices.T])  # type: ignore
-
-        if self.unit_interval:
-            self.data = self.data / 255
-
-        if self.normalize:
-            self.data = (self.data - self.normalize[0]) / self.normalize[1]
-
-        if self.dtype:
-            self.data = self.data.astype(self.dtype)
-
-        if self.channels == "channels_first":
-            self.data = self.data[:, np.newaxis, :, :]
-        elif self.channels == "channels_last":
-            self.data = self.data[:, :, :, np.newaxis]
-
-        if self.flatten and self.channels is None:
-            self.data = self.data.reshape(self.data.shape[0], -1)
-
-    def __getitem__(self, index: int) -> tuple[NDArray[np.float64], int]:
-        """
-        Args:
-            index (int): Index
-
-        Returns:
-            tuple: (image, target) where target is index of the target class.
-        """
-        img, target = self.data[index], int(self.targets[index])
-
-        return img, target
-
-    def __len__(self) -> int:
-        return len(self.data)
-
-    @property
-    def mnist_folder(self) -> str:
-        if self.corruption is None:
-            return os.path.join(self.root, "mnist")
-        return os.path.join(self.root, "mnist_c", self.corruption)
-
-    def _read_normal_file(self, path: str) -> tuple[NDArray, NDArray]:
-        with np.load(path, allow_pickle=True) as f:
-            if self.train:
-                x, y = f["x_train"], f["y_train"]
-            else:
-                x, y = f["x_test"], f["y_test"]
-        return x, y
-
-    def _read_corrupt_file(self, path: str) -> NDArray:
-        x = np.load(path, allow_pickle=False)
-        return x

dataeval/utils/dataset/read.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from collections import defaultdict
-from typing import Any
-
-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.
-
-    Parameters
-    ----------
-    dataset : torch.utils.data.Dataset
-        Input dataset
-
-    Returns
-    -------
-    List[List[Any]]
-        All objects in individual lists based on return position from dataset
-
-    Warning
-    -------
-    No type checking is done between lists or data inside lists
-
-    See Also
-    --------
-    torch.utils.data.Dataset
-
-    Examples
-    --------
-    >>> import numpy as np
-    >>> data = np.ones((10, 1, 3, 3))
-    >>> labels = np.ones((10,))
-    >>> class ICDataset:
-    ...     def __init__(self, data, labels):
-    ...         self.data = data
-    ...         self.labels = labels
-    ...
-    ...     def __getitem__(self, idx):
-    ...         return self.data[idx], self.labels[idx]
-
-    >>> ds = ICDataset(data, labels)
-
-    >>> result = read_dataset(ds)
-    >>> len(result)  # images and labels
-    2
-    >>> np.asarray(result[0]).shape  # images
-    (10, 1, 3, 3)
-    >>> np.asarray(result[1]).shape  # labels
-    (10,)
-    """
-
-    ddict: dict[int, list[Any]] = defaultdict(list[Any])
-
-    for data in dataset:
-        for i, d in enumerate(data if isinstance(data, tuple) else (data,)):
-            ddict[i].append(d)
-
-    return list(ddict.values())

dataeval-0.76.1.dist-info/RECORD

@@ -1,67 +0,0 @@
-dataeval/__init__.py,sha256=vqyenyxYGE0OXW3C8PC1YDZRak1uLFIYd45-vh9qafQ,1474
-dataeval/detectors/__init__.py,sha256=iifG-Z08mH5B4QhkKtAieDGJBKldKvmCXpDQJD9qVY8,206
-dataeval/detectors/drift/__init__.py,sha256=wO294Oz--l0GuZTAkBpyGwZphbQsot57HoiEX6kjNOc,652
-dataeval/detectors/drift/base.py,sha256=8zHUnUpmgpWMzDv5C-tUX61lbpDjhJ-eAIiNxaNvWP8,14469
-dataeval/detectors/drift/cvm.py,sha256=TATS6IOE0INO1pkyRkesgrhDawD_kITsRsOOGVRs420,4132
-dataeval/detectors/drift/ks.py,sha256=SAd2T9CdytXD7DegCzAX1pWYJdPuttyL97KAQYF4j7Y,4265
-dataeval/detectors/drift/mmd.py,sha256=z7JPFbW4fmHJhR-Qe1OQ4mM8kW6dNxnd3uHD9oXMETE,7599
-dataeval/detectors/drift/torch.py,sha256=ykD-Nggys5T9FTGXXbYYOi2WRKwEzEjXhL8ZueVmTxU,7659
-dataeval/detectors/drift/uncertainty.py,sha256=zkrqz5euJJtYFKsDiRqFfTnDjVOTbqpZWgZiGMrYxvI,5351
-dataeval/detectors/drift/updates.py,sha256=nKsF4xrMFZd2X84GJ5XnGylUuketX_RcH7UpcdlonIo,1781
-dataeval/detectors/linters/__init__.py,sha256=CZV5naeYQYL3sHXO_CXB26AXkyTeKHI-TMaewtEs8Ag,483
-dataeval/detectors/linters/clusterer.py,sha256=V-bNs4ut2E6SIqU4MR1Y96WBZcs4cavQhvXBB0vFZPw,20937
-dataeval/detectors/linters/duplicates.py,sha256=Ba-Nmbjqg_HDMlEBqlWW1aFO_BA-HSc-uWHc3cmI394,5620
-dataeval/detectors/linters/merged_stats.py,sha256=X-bDTwjyR8RuVmzxLaHZmQ5nI3oOWvsqVlitdSncapk,1355
-dataeval/detectors/linters/outliers.py,sha256=o0LtAHdazLfj5GM2HcVDjVY_AfSU5GpBUjxHPC9VfIc,13728
-dataeval/detectors/ood/__init__.py,sha256=Ws6_un4pFWNknki7Bp7qjrslZVB9pYNE-K72u2lF65k,291
-dataeval/detectors/ood/ae.py,sha256=SL8oKTERhMwaZTQWwDhQQ6H07UKj8ozXqEWO3TaOAos,2151
-dataeval/detectors/ood/base.py,sha256=-ApcC9lyZJAgk-joMpLXF20sJqtvlAugg-W18TcAsEw,3010
-dataeval/detectors/ood/metadata_ks_compare.py,sha256=-hEhDNXFC7X8wmFeoigO7A7Qn90vRLroN_nKDwNgjnE,5204
-dataeval/detectors/ood/metadata_least_likely.py,sha256=rb8GOgsrlrEzc6fxccdmyZQ5PC7HtTsTY8U97D-h5OU,5088
-dataeval/detectors/ood/metadata_ood_mi.py,sha256=7_Sdzf7-x1TlrIQvSyOIB98C8_UQhUwmwFQmZ9_q1Uc,4042
-dataeval/detectors/ood/mixin.py,sha256=Ia-rJF6rtGhE8uavijdbzOha3ueFk2CFfA0Ah_mnF40,4976
-dataeval/detectors/ood/output.py,sha256=yygnsjaIQB6v6sXh7glqX2aoqWdf3_YLINqx7BGKMtk,1710
-dataeval/interop.py,sha256=P9Kwe-vOVgbn1ng60y4giCnJYmHjIOpyGpccuIA7P1g,2322
-dataeval/log.py,sha256=Mn5bRWO0cgtAYd5VGYSFiPgu57ta3zoktrtHAZ1m3dU,357
-dataeval/metrics/__init__.py,sha256=OMntcHmmrsOfIlRsJTZQQaF5qXEuP61Li-ElKy7Ysbk,240
-dataeval/metrics/bias/__init__.py,sha256=SIg4Qxza9BqXyKNQLIY0bpqoFvZfK5-GaejpTH6efVc,601
-dataeval/metrics/bias/balance.py,sha256=B1sPackyodiBct9Hs88BR4nJde_R61JyjwSBIG_CFug,9171
-dataeval/metrics/bias/coverage.py,sha256=igVDWJSrO2MvaTEiDUhVzVWPGNB1QOZvngCi8UF0RwA,5746
-dataeval/metrics/bias/diversity.py,sha256=nF1y2FaQIU0yHQtckoddjqoty2hsVVMqwaXWHRdGfqA,8521
-dataeval/metrics/bias/parity.py,sha256=2gSpXkg6ASnkywRTqqx3b3k1T5Qg1Jm-ihMKNZgEwys,12732
-dataeval/metrics/estimators/__init__.py,sha256=oY_9jX7V-Kg7-4KpvMNB4rUhsk8QTA0DIoM8d2VtVIg,380
-dataeval/metrics/estimators/ber.py,sha256=vcndXr0PNLRlYz7u7K74f-B5g3DnUkaTO_WigGdj0cg,5012
-dataeval/metrics/estimators/divergence.py,sha256=joqqlH0AQFibJkHCCb7i7dMJIGF28fmZIR-tGupQQJQ,4247
-dataeval/metrics/estimators/uap.py,sha256=ZAQUjJCbdulftWk6yjILCbnXGOE8RuDqEINZRtMW3tc,2143
-dataeval/metrics/stats/__init__.py,sha256=pUT84sOxDiCHW6xz6Ml1Mf1bFszQrtd3qPG0Ja3boxA,1088
-dataeval/metrics/stats/base.py,sha256=1ejjwlA0FmllcAw7J9Yv1r7GMmBYKvuGPzmDk9ktASM,12613
-dataeval/metrics/stats/boxratiostats.py,sha256=PS1wvWwhTCMJX56erfPW-BZymXrevvXnKl2PkE0qmLk,6315
-dataeval/metrics/stats/datasetstats.py,sha256=mt5t5WhlVI7mo56dmhqgnk1eH8oBV7dahgmqkFDcKo0,7387
-dataeval/metrics/stats/dimensionstats.py,sha256=AlPor23dUH718jFNiVNedHQVaQzN-6OKQEVDQbnGE50,4027
-dataeval/metrics/stats/hashstats.py,sha256=5nNSJ3Tl8gPqpYlWpxl7EHfW6pJd1BtbXYUiuGgH4Eo,5070
-dataeval/metrics/stats/labelstats.py,sha256=MW6kB7V8pdIc7yHdXzRwlD6xSl6SYZonNsLUPKAVILI,6992
-dataeval/metrics/stats/pixelstats.py,sha256=tfvu0tYPgDS0jCCSY2sZ2Ice5r1nNuKx-LYXxZQCw7s,4220
-dataeval/metrics/stats/visualstats.py,sha256=pEQnAPFg-zQ1U5orwF0-U7kfHuZGjMJDsdEMAoDZd4I,4634
-dataeval/output.py,sha256=Dyfv1xlrwSbCe7HdDyq8t-kiIRJbBeaMEmMROr1FrVQ,4034
-dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/utils/__init__.py,sha256=WW9e_1RbtkvLDRqu1NpDw3-V4su4mA8yJ_P3bgd_7Ho,283
-dataeval/utils/dataset/__init__.py,sha256=IvRauQaa0CzJ5nZrfTSjGoaaKelyJcQDe3OPRw0-NXs,332
-dataeval/utils/dataset/datasets.py,sha256=7tSqN3d8UncqmXh4eiEwarXgVxc4sMuIKPTqBCE0pN8,15080
-dataeval/utils/dataset/read.py,sha256=Q_RaNTFXhkMsx3PrgJEIySdHAA-QxGuih6eq6mnJv-4,1524
-dataeval/utils/dataset/split.py,sha256=1vNy5I1zZx-LIf8B0y57dUaO_UdVd1hyJggUANkwNtM,18958
-dataeval/utils/image.py,sha256=AQljELyMFkYsf2AoNOH5dZG8DYE4hPw0MCk85eIXqAw,1926
-dataeval/utils/metadata.py,sha256=tRcXgJsM1l7vt_naNJj8g8_EHD_AB5MGi1uWxqZsA6M,27431
-dataeval/utils/plot.py,sha256=YyFL1KoJgnl2Bip7m73WVBJa6zbsBnn5c1b3skFfUrA,7068
-dataeval/utils/shared.py,sha256=xvF3VLfyheVwJtdtDrneOobkKf7t-JTmf_w91FWXmqo,3616
-dataeval/utils/torch/__init__.py,sha256=dn5mjCrFp0b1aL_UEURhONU0Ag0cmXoTOBSGagpkTiA,325
-dataeval/utils/torch/blocks.py,sha256=HVhBTMMD5NA4qheMUgyol1KWiKZDIuc8k5j4RcMKmhk,1466
-dataeval/utils/torch/gmm.py,sha256=fQ8CBO4Bf6i9N1CZdeJ8VJP25fsPjgMextQkondwgvo,3693
-dataeval/utils/torch/internal.py,sha256=qAzQTwTI9Qy6f01Olw3d1TIJ4HoWGf0gQzgWVcdD2x4,6653
-dataeval/utils/torch/models.py,sha256=Df3B_9x5uu-Y5ZOyhRZYpKJnDvxt0hgMeJLy1E4oxpU,8519
-dataeval/utils/torch/trainer.py,sha256=Qay0LK63RuyoGYiJ5zI2C5BVym309ORvp6shhpcrIU4,5589
-dataeval/workflows/__init__.py,sha256=L9yfBipNFGnYuN2JbMknIHDvziwfa2XAGFnOwifZbls,216
-dataeval/workflows/sufficiency.py,sha256=jf53J1PAlfRHSjGpMCWRJzImitLtCQvTMCaMm28ZuPM,18675
-dataeval-0.76.1.dist-info/LICENSE.txt,sha256=uAooygKWvX6NbU9Ran9oG2msttoG8aeTeHSTe5JeCnY,1061
-dataeval-0.76.1.dist-info/METADATA,sha256=w02IzEy_S5kgRZFRGbWayMg98uFdn3jJT4Gl6MOQzek,5196
-dataeval-0.76.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-dataeval-0.76.1.dist-info/RECORD,,