dataeval 0.74.2__py3-none-any.whl → 0.76.0__py3-none-any.whl

dataeval/detectors/ood/base_torch.py

@@ -1,109 +0,0 @@
-"""
-Source code derived from Alibi-Detect 0.11.4
-https://github.com/SeldonIO/alibi-detect/tree/v0.11.4
-
-Original code Copyright (c) 2023 Seldon Technologies Ltd
-Licensed under Apache Software License (Apache 2.0)
-"""
-
-from __future__ import annotations
-
-from typing import Callable, cast
-
-import torch
-from numpy.typing import ArrayLike
-
-from dataeval.detectors.drift.torch import get_device
-from dataeval.detectors.ood.base import OODBaseMixin, OODFitMixin, OODGMMMixin
-from dataeval.interop import to_numpy
-from dataeval.utils.torch.gmm import gmm_params
-from dataeval.utils.torch.trainer import trainer
-
-
-class OODBase(OODBaseMixin[torch.nn.Module], OODFitMixin[Callable[..., torch.nn.Module], torch.optim.Optimizer]):
-    def __init__(self, model: torch.nn.Module, device: str | torch.device | None = None) -> None:
-        self.device: torch.device = get_device(device)
-        super().__init__(model)
-
-    def fit(
-        self,
-        x_ref: ArrayLike,
-        threshold_perc: float,
-        loss_fn: Callable[..., torch.nn.Module] | None,
-        optimizer: torch.optim.Optimizer | None,
-        epochs: int,
-        batch_size: int,
-        verbose: bool,
-    ) -> None:
-        """
-        Train the model and infer the threshold value.
-
-        Parameters
-        ----------
-        x_ref : ArrayLike
-            Training data.
-        threshold_perc : float, default 100.0
-            Percentage of reference data that is normal.
-        loss_fn : Callable | None, default None
-            Loss function used for training.
-        optimizer : Optimizer, default keras.optimizers.Adam
-            Optimizer used for training.
-        epochs : int, default 20
-            Number of training epochs.
-        batch_size : int, default 64
-            Batch size used for training.
-        verbose : bool, default True
-            Whether to print training progress.
-        """
-
-        # Train the model
-        trainer(
-            model=self.model,
-            x_train=to_numpy(x_ref),
-            y_train=None,
-            loss_fn=loss_fn,
-            optimizer=optimizer,
-            preprocess_fn=None,
-            epochs=epochs,
-            batch_size=batch_size,
-            device=self.device,
-            verbose=verbose,
-        )
-
-        # Infer the threshold values
-        self._ref_score = self.score(x_ref, batch_size)
-        self._threshold_perc = threshold_perc
-
-
-class OODBaseGMM(OODBase, OODGMMMixin[torch.Tensor]):
-    def fit(
-        self,
-        x_ref: ArrayLike,
-        threshold_perc: float,
-        loss_fn: Callable[..., torch.nn.Module] | None,
-        optimizer: torch.optim.Optimizer | None,
-        epochs: int,
-        batch_size: int,
-        verbose: bool,
-    ) -> None:
-        # Train the model
-        trainer(
-            model=self.model,
-            x_train=to_numpy(x_ref),
-            y_train=None,
-            loss_fn=loss_fn,
-            optimizer=optimizer,
-            preprocess_fn=None,
-            epochs=epochs,
-            batch_size=batch_size,
-            device=self.device,
-            verbose=verbose,
-        )
-
-        # Calculate the GMM parameters
-        _, z, gamma = cast(tuple[torch.Tensor, torch.Tensor, torch.Tensor], self.model(x_ref))
-        self._gmm_params = gmm_params(z, gamma)
-
-        # Infer the threshold values
-        self._ref_score = self.score(x_ref, batch_size)
-        self._threshold_perc = threshold_perc

dataeval/metrics/bias/metadata_preprocessing.py

@@ -1,285 +0,0 @@
-from __future__ import annotations
-
-__all__ = ["MetadataOutput", "metadata_preprocessing"]
-
-import warnings
-from dataclasses import dataclass
-from typing import Any, Iterable, Literal, Mapping, TypeVar
-
-import numpy as np
-from numpy.typing import ArrayLike, NDArray
-from scipy.stats import wasserstein_distance as wd
-
-from dataeval.interop import as_numpy, to_numpy
-from dataeval.output import Output, set_metadata
-from dataeval.utils.metadata import merge_metadata
-
-TNum = TypeVar("TNum", int, float)
-DISCRETE_MIN_WD = 0.054
-CONTINUOUS_MIN_SAMPLE_SIZE = 20
-
-
-@dataclass(frozen=True)
-class MetadataOutput(Output):
-    """
-    Output class for :func:`metadata_binning` function
-
-    Attributes
-    ----------
-    discrete_factor_names : list[str]
-        List containing factor names for the original data that was discrete and the binned continuous data
-    discrete_data : NDArray[np.int]
-        Array containing values for the original data that was discrete and the binned continuous data
-    continuous_factor_names : list[str]
-        List containing factor names for the original continuous data
-    continuous_data : NDArray[np.int or np.double] | None
-        Array containing values for the original continuous data or None if there was no continuous data
-    class_labels : NDArray[np.int]
-        Numerical class labels for the images/objects
-    class_names : NDArray[Any]
-        Array of unique class names (for use with plotting)
-    total_num_factors : int
-        Sum of discrete_factor_names and continuous_factor_names plus 1 for class
-    """
-
-    discrete_factor_names: list[str]
-    discrete_data: NDArray[np.int_]
-    continuous_factor_names: list[str]
-    continuous_data: NDArray[np.int_ | np.double] | None
-    class_labels: NDArray[np.int_]
-    class_names: NDArray[Any]
-    total_num_factors: int
-
-
-@set_metadata
-def metadata_preprocessing(
-    raw_metadata: Iterable[Mapping[str, Any]],
-    class_labels: ArrayLike | str,
-    continuous_factor_bins: Mapping[str, int | list[tuple[TNum, TNum]]] | None = None,
-    auto_bin_method: Literal["uniform_width", "uniform_count", "clusters"] = "uniform_width",
-    exclude: Iterable[str] | None = None,
-) -> MetadataOutput:
-    """
-    Restructures the metadata to be in the correct format for the bias functions.
-
-    This identifies whether the incoming metadata is discrete or continuous,
-    and whether the data is already binned or still needs binning.
-    It accepts a list of dictionaries containing the per image metadata and
-    automatically adjusts for multiple targets in an image.
-
-    Parameters
-    ----------
-    raw_metadata : Iterable[Mapping[str, Any]]
-        Iterable collection of metadata dictionaries to flatten and merge.
-    class_labels : ArrayLike or string or None
-        If arraylike, expects the labels for each image (image classification) or each object (object detection).
-        If the labels are included in the metadata dictionary, pass in the key value.
-    continuous_factor_bins : Mapping[str, int] or Mapping[str, list[tuple[TNum, TNum]]] or None, default None
-        User provided dictionary specifying how to bin the continuous metadata factors
-    auto_bin_method : "uniform_width" or "uniform_count" or "clusters", default "uniform_width"
-        Method by which the function will automatically bin continuous metadata factors. It is recommended
-        that the user provide the bins through the `continuous_factor_bins`.
-    exclude : Iterable[str] or None, default None
-        User provided collection of metadata keys to exclude when processing metadata.
-
-    Returns
-    -------
-    MetadataOutput
-        Output class containing the binned metadata
-    """
-    # Transform metadata into single, flattened dictionary
-    metadata, image_repeats = merge_metadata(raw_metadata)
-
-    # Drop any excluded metadata keys
-    if exclude:
-        for k in list(metadata):
-            if k in exclude:
-                metadata.pop(k)
-
-    # Get the class label array in numeric form
-    class_array = as_numpy(metadata.pop(class_labels)) if isinstance(class_labels, str) else as_numpy(class_labels)
-    if class_array.ndim > 1:
-        raise ValueError(
-            f"Got class labels with {class_array.ndim}-dimensional "
-            f"shape {class_array.shape}, but expected a 1-dimensional array."
-        )
-    if not np.issubdtype(class_array.dtype, np.int_):
-        unique_classes, numerical_labels = np.unique(class_array, return_inverse=True)
-    else:
-        numerical_labels = class_array
-        unique_classes = np.unique(class_array)
-
-    # Bin according to user supplied bins
-    continuous_metadata = {}
-    discrete_metadata = {}
-    if continuous_factor_bins is not None and continuous_factor_bins != {}:
-        invalid_keys = set(continuous_factor_bins.keys()) - set(metadata.keys())
-        if invalid_keys:
-            raise KeyError(
-                f"The keys - {invalid_keys} - are present in the `continuous_factor_bins` dictionary "
-                "but are not keys in the `metadata` dictionary. Delete these keys from `continuous_factor_bins` "
-                "or add corresponding entries to the `metadata` dictionary."
-            )
-        for factor, grouping in continuous_factor_bins.items():
-            discrete_metadata[factor] = _user_defined_bin(metadata[factor], grouping)
-            continuous_metadata[factor] = metadata[factor]
-
-    # Determine category of the rest of the keys
-    remaining_keys = set(metadata.keys()) - set(continuous_metadata.keys())
-    for key in remaining_keys:
-        data = to_numpy(metadata[key])
-        if np.issubdtype(data.dtype, np.number):
-            result = _is_continuous(data, image_repeats)
-            if result:
-                continuous_metadata[key] = data
-            unique_samples, ordinal_data = np.unique(data, return_inverse=True)
-            if unique_samples.size <= np.max([20, data.size * 0.01]):
-                discrete_metadata[key] = ordinal_data
-            else:
-                warnings.warn(
-                    f"A user defined binning was not provided for {key}. "
-                    f"Using the {auto_bin_method} method to discretize the data. "
-                    "It is recommended that the user rerun and supply the desired "
-                    "bins using the continuous_factor_bins parameter.",
-                    UserWarning,
-                )
-                discrete_metadata[key] = _binning_function(data, auto_bin_method)
-        else:
-            _, discrete_metadata[key] = np.unique(data, return_inverse=True)
-
-    # splitting out the dictionaries into the keys and values
-    discrete_factor_names = list(discrete_metadata.keys())
-    discrete_data = np.stack(list(discrete_metadata.values()), axis=-1)
-    continuous_factor_names = list(continuous_metadata.keys())
-    continuous_data = np.stack(list(continuous_metadata.values()), axis=-1) if continuous_metadata else None
-    total_num_factors = len(discrete_factor_names + continuous_factor_names) + 1
-
-    return MetadataOutput(
-        discrete_factor_names,
-        discrete_data,
-        continuous_factor_names,
-        continuous_data,
-        numerical_labels,
-        unique_classes,
-        total_num_factors,
-    )
-
-
-def _user_defined_bin(data: list[Any] | NDArray[Any], binning: int | list[tuple[TNum, TNum]]) -> NDArray[np.intp]:
-    """
-    Digitizes a list of values into a given number of bins.
-
-    Parameters
-    ----------
-    data : list | NDArray
-        The values to be digitized.
-    binning :  int | list[tuple[TNum, TNum]]
-        The number of bins for the discrete values that data will be digitized into.
-
-    Returns
-    -------
-    NDArray[np.intp]
-        The digitized values
-    """
-
-    if not np.all([np.issubdtype(type(n), np.number) for n in data]):
-        raise TypeError(
-            "Encountered a data value with non-numeric type when digitizing a factor. "
-            "Ensure all occurrences of continuous factors are numeric types."
-        )
-    if type(binning) is int:
-        _, bin_edges = np.histogram(data, bins=binning)
-        bin_edges[-1] = np.inf
-        bin_edges[0] = -np.inf
-    else:
-        bin_edges = binning
-    return np.digitize(data, bin_edges)
-
-
-def _binning_function(data: NDArray[Any], bin_method: str) -> NDArray[np.int_]:
-    """
-    Bins continuous data through either equal width bins, equal amounts in each bin, or by clusters.
-    """
-    if bin_method == "clusters":
-        # bin_edges = _binning_by_clusters(data)
-        warnings.warn(
-            "Binning by clusters is currently unavailable until changes to the clustering function go through.",
-            UserWarning,
-        )
-        bin_method = "uniform_width"
-
-    if bin_method != "clusters":
-        counts, bin_edges = np.histogram(data, bins="auto")
-        n_bins = counts.size
-        if counts[counts > 0].min() < 10:
-            for _ in range(20):
-                n_bins -= 1
-                counts, bin_edges = np.histogram(data, bins=n_bins)
-                if counts[counts > 0].min() >= 10 or n_bins < 2:
-                    break
-
-        if bin_method == "uniform_count":
-            quantiles = np.linspace(0, 100, n_bins + 1)
-            bin_edges = np.asarray(np.percentile(data, quantiles))
-
-    bin_edges[0] = -np.inf  # type: ignore # until the clusters speed up is merged
-    bin_edges[-1] = np.inf  # type: ignore # and the _binning_by_clusters can be uncommented
-    return np.digitize(data, bin_edges)  # type: ignore
-
-
-def _is_continuous(data: NDArray[np.number], image_indicies: NDArray[np.number]) -> bool:
-    """
-    Determines whether the data is continuous or discrete using the Wasserstein distance.
-
-    Given a 1D sample, we consider the intervals between adjacent points. For a continuous distribution,
-    a point is equally likely to lie anywhere in the interval bounded by its two neighbors. Furthermore,
-    we can put all "between neighbor" locations on the same scale of 0 to 1 by subtracting the smaller
-    neighbor and dividing out the length of the interval. (Duplicates are either assigned to zero or
-    ignored, depending on context). These normalized locations will be much more uniformly distributed
-    for continuous data than for discrete, and this gives us a way to distinguish them. Call this the
-    Normalized Near Neighbor distribution (NNN), defined on the interval [0,1].
-
-    The Wasserstein distance is available in scipy.stats.wasserstein_distance. We can use it to measure
-    how close the NNN is to a uniform distribution over [0,1]. We found that as long as a sample has at
-    least 20 points, and furthermore at least half as many points as there are discrete values, we can
-    reliably distinguish discrete from continuous samples by testing that the Wasserstein distance
-    measured from a uniform distribution is greater or less than 0.054, respectively.
-    """
-    # Check if the metadata is image specific
-    _, data_indicies_unsorted = np.unique(data, return_index=True)
-    if data_indicies_unsorted.size == image_indicies.size:
-        data_indicies = np.sort(data_indicies_unsorted)
-        if (data_indicies == image_indicies).all():
-            data = data[data_indicies]
-
-    # OLD METHOD
-    # uvals = np.unique(data)
-    # pct_unique = uvals.size / data.size
-    # return pct_unique < threshold
-
-    n_examples = len(data)
-
-    if n_examples < CONTINUOUS_MIN_SAMPLE_SIZE:
-        warnings.warn(
-            f"All samples look discrete with so few data points (< {CONTINUOUS_MIN_SAMPLE_SIZE})", UserWarning
-        )
-        return False
-
-    # Require at least 3 unique values before bothering with NNN
-    xu = np.unique(data, axis=None)
-    if xu.size < 3:
-        return False
-
-    Xs = np.sort(data)
-
-    X0, X1 = Xs[0:-2], Xs[2:]  # left and right neighbors
-
-    dx = np.zeros(n_examples - 2)  # no dx at end points
-    gtz = (X1 - X0) > 0  # check for dups; dx will be zero for them
-    dx[np.logical_not(gtz)] = 0.0
-
-    dx[gtz] = (Xs[1:-1] - X0)[gtz] / (X1 - X0)[gtz]  # the core idea: dx is NNN samples.
-
-    shift = wd(dx, np.linspace(0, 1, dx.size))  # how far is dx from uniform, for this feature?
-
-    return shift < DISCRETE_MIN_WD  # if NNN is close enough to uniform, consider the sample continuous.

dataeval/utils/gmm.py

@@ -1,26 +0,0 @@
-from dataclasses import dataclass
-from typing import Generic, TypeVar
-
-TGMMData = TypeVar("TGMMData")
-
-
-@dataclass
-class GaussianMixtureModelParams(Generic[TGMMData]):
-    """
-    phi : TGMMData
-        Mixture component distribution weights.
-    mu : TGMMData
-        Mixture means.
-    cov : TGMMData
-        Mixture covariance.
-    L : TGMMData
-        Cholesky decomposition of `cov`.
-    log_det_cov : TGMMData
-        Log of the determinant of `cov`.
-    """
-
-    phi: TGMMData
-    mu: TGMMData
-    cov: TGMMData
-    L: TGMMData
-    log_det_cov: TGMMData

dataeval-0.74.2.dist-info/METADATA

@@ -1,120 +0,0 @@
-Metadata-Version: 2.1
-Name: dataeval
-Version: 0.74.2
-Summary: DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks
-Home-page: https://dataeval.ai/
-License: MIT
-Author: Andrew Weng
-Author-email: andrew.weng@ariacoustics.com
-Maintainer: ARiA
-Maintainer-email: dataeval@ariacoustics.com
-Requires-Python: >=3.9,<3.13
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Topic :: Scientific/Engineering
-Provides-Extra: all
-Provides-Extra: torch
-Requires-Dist: matplotlib ; extra == "all"
-Requires-Dist: numpy (>=1.24.3)
-Requires-Dist: pillow (>=10.3.0)
-Requires-Dist: scikit-learn (>=1.5.0)
-Requires-Dist: scipy (>=1.10)
-Requires-Dist: torch (>=2.2.0) ; extra == "torch" or extra == "all"
-Requires-Dist: torchvision (>=0.17.0) ; extra == "torch" or extra == "all"
-Requires-Dist: tqdm
-Requires-Dist: typing-extensions (>=4.12) ; python_version >= "3.9" and python_version < "3.10"
-Requires-Dist: xxhash (>=3.3)
-Project-URL: Documentation, https://dataeval.readthedocs.io/
-Project-URL: Repository, https://github.com/aria-ml/dataeval/
-Description-Content-Type: text/markdown
-
-# DataEval
-
-## About DataEval
-
-DataEval focuses on characterizing image data and its impact on model performance across Classification and object-detection tasks.
-
-<!-- start about -->
-
-**Model-agnostic metrics that bound real-world performance**
-- relevance/completeness/coverage
-- metafeatures (data complexity)
-
-**Model-specific metrics that guide model selection and training**
-- dataset sufficiency
-- data/model complexity mismatch
-
-**Metrics for post-deployment monitoring of data with bounds on model performance to guide retraining**
-- dataset-shift metrics
-- model performance bounds under covariate shift
-- guidance on sampling to assess model error and model retraining
-
-<!-- end about -->
-
-## Getting Started
-
-### Requirements
-- Python 3.9-3.11
-
-### Installing DataEval
-
-You can install DataEval directly from pypi.org using the following command.  The optional dependencies of DataEval are `torch`, `tensorflow` and `all`.  Using `torch` enables Sufficiency metrics, and `tensorflow` enables OOD Detection.
-
-```
-pip install dataeval[all]
-```
-
-### Installing DataEval in Conda/Mamba
-
-DataEval can be installed in a Conda/Mamba environment using the provided `environment.yaml` file.  As some dependencies
-are installed from the `pytorch` channel, the channel is specified in the below example.
-
-```
-micromamba create -f environment\environment.yaml -c pytorch
-```
-
-### Installing DataEval from GitHub
-
-To install DataEval from source locally on Ubuntu, you will need `git-lfs` to download larger, binary source files and `poetry` for project dependency management.
-
-```
-sudo apt-get install git-lfs
-pip install poetry
-```
-
-Pull the source down and change to the DataEval project directory.
-```
-git clone https://github.com/aria-ml/dataeval.git
-cd dataeval
-```
-
-
-
-Install DataEval with optional dependencies for development.
-```
-poetry install --all-extras --with dev
-```
-
-Now that DataEval is installed, you can run commands in the poetry virtual environment by prefixing shell commands with `poetry run`, or activate the virtual environment directly in the shell.
-```
-poetry shell
-```
-
-### Documentation and Tutorials
-For more ideas on getting started using DataEval in your workflow, additional information and tutorials are in our Sphinx documentation hosted on [Read the Docs](https://dataeval.readthedocs.io/).
-
-## Attribution
-This project uses code from the [Alibi-Detect](https://github.com/SeldonIO/alibi-detect) python library developed by SeldonIO.  Additional documentation from the developers are also available [here](https://docs.seldon.io/projects/alibi-detect/en/stable/).
-
-## POCs
-- **POC**: Scott Swan @scott.swan
-- **DPOC**: Andrew Weng @aweng
-

dataeval-0.74.2.dist-info/RECORD

@@ -1,66 +0,0 @@
-dataeval/__init__.py,sha256=w_On8sJ5o_f8PboMo6LLErdFSqDAQ1Jg_e0mcp-5FRU,959
-dataeval/detectors/__init__.py,sha256=Y-0bbyWyuMvZU80bCx6WPt3IV_r2hu9ymzpA8uzMqoI,206
-dataeval/detectors/drift/__init__.py,sha256=BSXm21y7cAawHep-ZldCJ5HOvzYjPzYGKGrmoEs3i0E,737
-dataeval/detectors/drift/base.py,sha256=QDGHMu1WADD-38MEIOwjQMEQM3DE7B0yFHO3hsMbV-E,14481
-dataeval/detectors/drift/cvm.py,sha256=kc59w2_wtxFGNnLcaJRvX5v_38gPXiebSGNiFVdunEQ,4142
-dataeval/detectors/drift/ks.py,sha256=gcpe1WIQeNeZdLYkdMZCFLXUp1bHMQUxwJE6-RLVOXs,4229
-dataeval/detectors/drift/mmd.py,sha256=C0FX5v9ZJzmKNYEcYUaC7sDtMpJ2dZpwikNDu-AEWiI,7584
-dataeval/detectors/drift/torch.py,sha256=igEQ2DV9JmcpTdUKCOHBi5LxtoNeCAslJS2Ldulg1hw,7585
-dataeval/detectors/drift/uncertainty.py,sha256=Xz2yzJjtJfw1vLag234jwRvaa_HK36nMajGx8bQaNRs,5322
-dataeval/detectors/drift/updates.py,sha256=UJ0z5hlunRi7twnkLABfdJG3tT2EqX4y9IGx8_USYvo,1780
-dataeval/detectors/linters/__init__.py,sha256=BvpaB1RUpkEhhXk3Mqi5NYoOcJKZRFSBOJCmQOIfYRU,483
-dataeval/detectors/linters/clusterer.py,sha256=hK-ak02GaxwWuufesZMKDsvoE5fMdXO7UWsLiK8hfY0,21008
-dataeval/detectors/linters/duplicates.py,sha256=2bmPTFqoefeiAQV9y4CGlHV_mJNrysJSEFLXLd2DO4I,5661
-dataeval/detectors/linters/merged_stats.py,sha256=X-bDTwjyR8RuVmzxLaHZmQ5nI3oOWvsqVlitdSncapk,1355
-dataeval/detectors/linters/outliers.py,sha256=X48bzTfTr1LqC6WKVKBRfvpjcQRgmb93cNLT7Oipe3M,10113
-dataeval/detectors/ood/__init__.py,sha256=-D4Fq-ysFylNNMqjHG1ALbB9qBCm_UinkCAgsK9HGg0,408
-dataeval/detectors/ood/ae_torch.py,sha256=pO9w5221bXR9lEBkE7oakXeE7PXUUR--xcTpmHvOCSk,2142
-dataeval/detectors/ood/base.py,sha256=UzcDbXl8Gv43VFzjrOegTnKSIoEYmfDP7fAySeWyWPw,6955
-dataeval/detectors/ood/base_torch.py,sha256=yFbSfQsBMwZeVf8mrixmkZYBGChhV5oAHtkgzWnMzsA,3405
-dataeval/detectors/ood/metadata_ks_compare.py,sha256=LNDNWGEDKTW8_-djgmK53sn9EZzzXq1Sgwc47k0QI-Y,5380
-dataeval/detectors/ood/metadata_least_likely.py,sha256=nxMCXUOjOfWHDTGT2SLE7OYBCydRq8zHLd8t17k7hMM,5193
-dataeval/detectors/ood/metadata_ood_mi.py,sha256=KLay2BmgHrStBV92VpIs_B1yEfQKllsMTgzOQEng01I,4065
-dataeval/interop.py,sha256=5lACbR7bZYGCagiwbXzAWvWeHRj8kWBmsTC9oEjFh78,2249
-dataeval/logging.py,sha256=uGxXPqGpn5guQjuHtm25rzILaz7nCQUsy2o7tFo91OI,343
-dataeval/metrics/__init__.py,sha256=fPBNLd-T6mCErZBBJrxWmXIL0jCk7fNUYIcNEBkMa80,238
-dataeval/metrics/bias/__init__.py,sha256=dYiPHenS8J7pgRMMW2jNkTBmTbPoYTxT04fZu9PFats,747
-dataeval/metrics/bias/balance.py,sha256=_TZEe17AT-qOvPp-QFrQfTqNwh8uVVCYjC4Sv6JBx9o,9118
-dataeval/metrics/bias/coverage.py,sha256=o65_IgrWSlGnYeYZFABjwKaxq09uqyy5esHJM67PJ-k,4528
-dataeval/metrics/bias/diversity.py,sha256=WL1NbZiRrv0SIq97FY3womZNCSl_EBMVlBWQZAUtjk8,7701
-dataeval/metrics/bias/metadata_preprocessing.py,sha256=ekUFiirkmaHDiH7nJjkNpiUQD7OolAPhHorjLxpXv_Y,12248
-dataeval/metrics/bias/metadata_utils.py,sha256=HmTjlRRTdM9566oKUDDdVMJ8luss4DYykFOiS2FQzhM,6558
-dataeval/metrics/bias/parity.py,sha256=hnA7qQH4Uy3tl_krluZ9BPD5zYjjagUxZt2fEiIa2yE,12745
-dataeval/metrics/estimators/__init__.py,sha256=O6ocxJq8XDkfJWwXeJnnnzbOyRnFPKF4kTIVTTZYOA8,380
-dataeval/metrics/estimators/ber.py,sha256=fs3_e9pgu7I50QIALWtF2aidkBZhTCKVE2pA7PyB5Go,5019
-dataeval/metrics/estimators/divergence.py,sha256=r_SKSurf1TdI5E1ivENqDnz8cQ3_sxVGKAqmF9cqcT4,4275
-dataeval/metrics/estimators/uap.py,sha256=Aw5ReoWNK73Tq96r__qN_-cvHrELauqtDX3Af_QxX4s,2157
-dataeval/metrics/stats/__init__.py,sha256=igLRaAt1nX6yRwC4xI0zNPBADi3u7EsSxWP3OZ8AqcU,1086
-dataeval/metrics/stats/base.py,sha256=_C05KUAuDrfX3N-19o25V3vmXr0-45A5fc57cXyV8qs,12161
-dataeval/metrics/stats/boxratiostats.py,sha256=bZunY-b8Y2IQqHlTusQN77ujLOHftogEQIARDpdVv6A,6463
-dataeval/metrics/stats/datasetstats.py,sha256=rZUDiciHwEpnXmkI8-uJNiYwUuTL9ssZMKMx73hVX-Y,6219
-dataeval/metrics/stats/dimensionstats.py,sha256=xITgQF_oomb6Ty_dJcbT3ARGGNp4QRcYSgnkjB4f-YE,4054
-dataeval/metrics/stats/hashstats.py,sha256=vxw_K74EJM9CZy-EV617vdrysFO8nEspVWqIYsIHC-c,4958
-dataeval/metrics/stats/labelstats.py,sha256=K0hJTphMe7htSjyss8GPtKDiHepTuU60_hX0xRA-uAg,4096
-dataeval/metrics/stats/pixelstats.py,sha256=2zr9i3GLNx1i_SCtbfdtZNxXBEc_9wCe4qDpmXLVbKY,4576
-dataeval/metrics/stats/visualstats.py,sha256=vLIC4sMo796axWl-4e4RzT33ll-_6ki54Dirn3V-EL8,4948
-dataeval/output.py,sha256=hR5TJ67f7FgrZO9Du46aw-jvRpMjOimSgJSau4ZNK44,3565
-dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/utils/__init__.py,sha256=z7HxSijjycey-rGdQkgVOdpvT0oO2pKAuT4uYyxYGMs,555
-dataeval/utils/gmm.py,sha256=YuLsJKsVWgH_wHr1u_hSRH5Yeexdj8exht8h99L7bLo,561
-dataeval/utils/image.py,sha256=KgC_1nW__nGN5q6bVZNvG4U_qIBdjcPATz9qe8f2XuA,1928
-dataeval/utils/metadata.py,sha256=0A--iru0zEmi044mKz5P35q69KrI30yoiRSlvs7TSdQ,9418
-dataeval/utils/shared.py,sha256=xvF3VLfyheVwJtdtDrneOobkKf7t-JTmf_w91FWXmqo,3616
-dataeval/utils/split_dataset.py,sha256=KYIl2ueLN0BeBoEvbUP5FdwVcMYW_l-ES1nQf_zKpQA,18776
-dataeval/utils/torch/__init__.py,sha256=lpkqfgyARUxgrV94cZESQv8PIP2p-UnwItZ_wIr0XzQ,675
-dataeval/utils/torch/blocks.py,sha256=HVhBTMMD5NA4qheMUgyol1KWiKZDIuc8k5j4RcMKmhk,1466
-dataeval/utils/torch/datasets.py,sha256=10elNgLuH_FDX_CHE3y2Z215JN4-PQovQm5brcIJOeM,15021
-dataeval/utils/torch/gmm.py,sha256=VbLlUQohwToApT493_tjQBWy2UM5R-3ppS9Dp-eP7BA,3240
-dataeval/utils/torch/models.py,sha256=sdGeo7a8vshCTGA4lYyVxxb_aDWUlxdtIVxrddS-_ls,8542
-dataeval/utils/torch/trainer.py,sha256=8BEXr6xtk-CHJTcNxOBnWgkFWfJUAiBy28cEdBhLMRU,7883
-dataeval/utils/torch/utils.py,sha256=nWRcT6z6DbFVrL1RyxCOX3DPoCrv9G0B-VI_9LdGCQQ,5784
-dataeval/workflows/__init__.py,sha256=ef1MiVL5IuhlDXXbwsiAfafhnr7tD3TXF9GRusy9_O8,290
-dataeval/workflows/sufficiency.py,sha256=v9AV3BZT0NW-zD2VNIL_5aWspvoscrxRIUKcUdpy7HI,18540
-dataeval-0.74.2.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
-dataeval-0.74.2.dist-info/METADATA,sha256=Rcnn55cRPZ2JZ1jn8YamuVDxmQVDKEItK4oqZyAYkHM,4298
-dataeval-0.74.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-dataeval-0.74.2.dist-info/RECORD,,