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

dataeval/_internal/workflows/sufficiency.py

@@ -2,23 +2,26 @@ from __future__ import annotations
 
 import warnings
 from dataclasses import dataclass
-from typing import Any, Callable, Sequence, cast
+from typing import Any, Callable, Iterable, Mapping, Sequence, cast
 
 import matplotlib.pyplot as plt
 import numpy as np
 import torch
 import torch.nn as nn
 from matplotlib.figure import Figure
-from numpy.typing import NDArray
+from numpy.typing import ArrayLike, NDArray
 from scipy.optimize import basinhopping
 from torch.utils.data import Dataset
 
+from dataeval._internal.interop import as_numpy
 from dataeval._internal.output import OutputMetadata, set_metadata
 
 
 @dataclass(frozen=True)
 class SufficiencyOutput(OutputMetadata):
     """
+    Output class for :class:`Sufficiency` workflow
+
     Attributes
     ----------
     steps : NDArray
@@ -45,13 +48,13 @@ class SufficiencyOutput(OutputMetadata):
     @set_metadata("dataeval.workflows.SufficiencyOutput")
     def project(
         self,
-        projection: int | Sequence[int] | NDArray[np.uint],
+        projection: int | Iterable[int],
     ) -> SufficiencyOutput:
         """Projects the measures for each value of X
 
         Parameters
         ----------
-        projection : int | Sequence[int] | NDArray[np.uint]
+        projection : int | Iterable[int]
             Step or steps to project
 
         Returns
@@ -63,12 +66,12 @@ class SufficiencyOutput(OutputMetadata):
         ------
         ValueError
             If the length of data points in the measures do not match
-            If the steps are not int, Sequence[int] or an ndarray
+            If `projection` is not numerical
         """
-        projection = [projection] if isinstance(projection, int) else projection
-        projection = np.array(projection) if isinstance(projection, Sequence) else projection
-        if not isinstance(projection, np.ndarray):
-            raise ValueError("'steps' must be an int, Sequence[int] or ndarray")
+        projection = np.asarray(list(projection) if isinstance(projection, Iterable) else [projection])
+
+        if not np.issubdtype(projection.dtype, np.number):
+            raise ValueError("'projection' must consist of numerical values")
 
         output = {}
         for name, measures in self.measures.items():
@@ -92,7 +95,7 @@ class SufficiencyOutput(OutputMetadata):
 
         Returns
         -------
-        List[plt.Figure]
+        list[plt.Figure]
             List of Figures for each measure
 
         Raises
@@ -130,19 +133,19 @@ class SufficiencyOutput(OutputMetadata):
 
         return plots
 
-    def inv_project(self, targets: dict[str, NDArray]) -> dict[str, NDArray]:
+    def inv_project(self, targets: Mapping[str, ArrayLike]) -> dict[str, NDArray[np.float64]]:
         """
         Calculate training samples needed to achieve target model metric values.
 
         Parameters
         ----------
-        targets : Dict[str, NDArray]
-            Dictionary of target metric scores (from 0.0 to 1.0) that we want
+        targets : Mapping[str, ArrayLike]
+            Mapping of target metric scores (from 0.0 to 1.0) that we want
             to achieve, where the key is the name of the metric.
 
         Returns
         -------
-        Dict[str, NDArray]
+        dict[str, NDArray]
             List of the number of training samples needed to achieve each
             corresponding entry in targets
         """
@@ -150,18 +153,19 @@ class SufficiencyOutput(OutputMetadata):
         projection = {}
 
         for name, target in targets.items():
+            tarray = as_numpy(target)
             if name not in self.measures:
                 continue
 
             measure = self.measures[name]
             if measure.ndim > 1:
-                projection[name] = np.zeros((len(measure), len(target)))
+                projection[name] = np.zeros((len(measure), len(tarray)))
                 for i in range(len(measure)):
                     projection[name][i] = inv_project_steps(
-                        self.params[name][i], target[i] if target.ndim == measure.ndim else target
+                        self.params[name][i], tarray[i] if tarray.ndim == measure.ndim else tarray
                     )
             else:
-                projection[name] = inv_project_steps(self.params[name], target)
+                projection[name] = inv_project_steps(self.params[name], tarray)
 
         return projection
 
@@ -379,18 +383,18 @@ class Sufficiency:
         Function which takes a model (torch.nn.Module), a dataset
         (torch.utils.data.Dataset), indices to train on and executes model
         training against the data.
-    eval_fn : Callable[[nn.Module, Dataset], Dict[str, float | NDArray]]
+    eval_fn : Callable[[nn.Module, Dataset], Mapping[str, float | ArrayLike]]
         Function which takes a model (torch.nn.Module), a dataset
         (torch.utils.data.Dataset) and returns a dictionary of metric
-        values (Dict[str, float]) which is used to assess model performance
+        values (Mapping[str, float]) which is used to assess model performance
         given the model and data.
     runs : int, default 1
         Number of models to run over all subsets
     substeps : int, default 5
         Total number of dataset partitions that each model will train on
-    train_kwargs : Dict | None, default None
+    train_kwargs : Mapping | None, default None
         Additional arguments required for custom training function
-    eval_kwargs : Dict | None, default None
+    eval_kwargs : Mapping | None, default None
         Additional arguments required for custom evaluation function
     """
 
@@ -400,11 +404,11 @@ class Sufficiency:
         train_ds: Dataset,
         test_ds: Dataset,
         train_fn: Callable[[nn.Module, Dataset, Sequence[int]], None],
-        eval_fn: Callable[[nn.Module, Dataset], dict[str, float] | dict[str, NDArray]],
+        eval_fn: Callable[[nn.Module, Dataset], Mapping[str, float] | Mapping[str, ArrayLike]],
         runs: int = 1,
         substeps: int = 5,
-        train_kwargs: dict[str, Any] | None = None,
-        eval_kwargs: dict[str, Any] | None = None,
+        train_kwargs: Mapping[str, Any] | None = None,
+        eval_kwargs: Mapping[str, Any] | None = None,
     ):
         self.model = model
         self.train_ds = train_ds
@@ -447,42 +451,42 @@ class Sufficiency:
     @property
     def eval_fn(
         self,
-    ) -> Callable[[nn.Module, Dataset], dict[str, float] | dict[str, NDArray]]:
+    ) -> Callable[[nn.Module, Dataset], dict[str, float] | Mapping[str, ArrayLike]]:
         return self._eval_fn
 
     @eval_fn.setter
     def eval_fn(
         self,
-        value: Callable[[nn.Module, Dataset], dict[str, float] | dict[str, NDArray]],
+        value: Callable[[nn.Module, Dataset], dict[str, float] | Mapping[str, ArrayLike]],
     ):
         if not callable(value):
             raise TypeError("Must provide a callable for eval_fn.")
         self._eval_fn = value
 
     @property
-    def train_kwargs(self) -> dict[str, Any]:
+    def train_kwargs(self) -> Mapping[str, Any]:
         return self._train_kwargs
 
     @train_kwargs.setter
-    def train_kwargs(self, value: dict[str, Any] | None):
+    def train_kwargs(self, value: Mapping[str, Any] | None):
         self._train_kwargs = {} if value is None else value
 
     @property
-    def eval_kwargs(self) -> dict[str, Any]:
+    def eval_kwargs(self) -> Mapping[str, Any]:
         return self._eval_kwargs
 
     @eval_kwargs.setter
-    def eval_kwargs(self, value: dict[str, Any] | None):
+    def eval_kwargs(self, value: Mapping[str, Any] | None):
         self._eval_kwargs = {} if value is None else value
 
     @set_metadata("dataeval.workflows", ["runs", "substeps"])
-    def evaluate(self, eval_at: NDArray | None = None, niter: int = 1000) -> SufficiencyOutput:
+    def evaluate(self, eval_at: int | Iterable[int] | None = None, niter: int = 1000) -> SufficiencyOutput:
         """
         Creates data indices, trains models, and returns plotting data
 
         Parameters
         ----------
-        eval_at : NDArray | None, default None
+        eval_at : int | Iterable[int] | None, default None
             Specify this to collect accuracies over a specific set of dataset lengths, rather
             than letting Sufficiency internally create the lengths to evaluate at.
         niter : int, default 1000
@@ -493,6 +497,11 @@ class Sufficiency:
         SufficiencyOutput
             Dataclass containing the average of each measure per substep
 
+        Raises
+        ------
+        ValueError
+            If `eval_at` is not numerical
+
         Examples
         --------
         >>> suff = Sufficiency(
@@ -502,7 +511,9 @@ class Sufficiency:
         SufficiencyOutput(steps=array([  1,   3,  10,  31, 100], dtype=uint32), params={'test': array([ 0., 42.,  0.])}, measures={'test': array([1., 1., 1., 1., 1.])})
         """  # noqa: E501
         if eval_at is not None:
-            ranges = eval_at
+            ranges = np.asarray(list(eval_at) if isinstance(eval_at, Iterable) else [eval_at])
+            if not np.issubdtype(ranges.dtype, np.number):
+                raise ValueError("'eval_at' must consist of numerical values")
         else:
             geomshape = (
                 0.01 * self._length,

dataeval/detectors/__init__.py

@@ -1,3 +1,7 @@
+"""
+Detectors can determine if a dataset or individual images in a dataset are indicative of a specific issue.
+"""
+
 from dataeval import _IS_TENSORFLOW_AVAILABLE
 
 from . import drift, linters

dataeval/detectors/drift/__init__.py

@@ -1,16 +1,21 @@
+"""
+Drift detectors identify if the statistical properties of the data has changed.
+"""
+
 from dataeval import _IS_TORCH_AVAILABLE
+from dataeval._internal.detectors.drift.base import DriftOutput
 from dataeval._internal.detectors.drift.cvm import DriftCVM
 from dataeval._internal.detectors.drift.ks import DriftKS
 
 from . import updates
 
-__all__ = ["DriftCVM", "DriftKS", "updates"]
+__all__ = ["DriftCVM", "DriftKS", "DriftOutput", "updates"]
 
 if _IS_TORCH_AVAILABLE:  # pragma: no cover
-    from dataeval._internal.detectors.drift.mmd import DriftMMD
+    from dataeval._internal.detectors.drift.mmd import DriftMMD, DriftMMDOutput
     from dataeval._internal.detectors.drift.torch import preprocess_drift
     from dataeval._internal.detectors.drift.uncertainty import DriftUncertainty
 
     from . import kernels
 
-    __all__ += ["DriftMMD", "DriftUncertainty", "kernels", "preprocess_drift"]
+    __all__ += ["DriftMMD", "DriftMMDOutput", "DriftUncertainty", "kernels", "preprocess_drift"]

dataeval/detectors/drift/kernels/__init__.py

@@ -1,3 +1,7 @@
+"""
+Kernels are used to map non-linear data to a higher dimensional space.
+"""
+
 from dataeval import _IS_TORCH_AVAILABLE
 
 if _IS_TORCH_AVAILABLE:  # pragma: no cover

dataeval/detectors/drift/updates/__init__.py

@@ -1,3 +1,7 @@
+"""
+Update strategies inform how the drift detector classes update the reference data when monitoring for drift.
+"""
+
 from dataeval._internal.detectors.drift.base import LastSeenUpdate, ReservoirSamplingUpdate
 
 __all__ = ["LastSeenUpdate", "ReservoirSamplingUpdate"]

dataeval/detectors/linters/__init__.py

@@ -1,5 +1,16 @@
-from dataeval._internal.detectors.clusterer import Clusterer
-from dataeval._internal.detectors.duplicates import Duplicates
-from dataeval._internal.detectors.outliers import Outliers
+"""
+Linters help identify potential issues in training and test data and are an important aspect of data cleaning.
+"""
 
-__all__ = ["Clusterer", "Duplicates", "Outliers"]
+from dataeval._internal.detectors.clusterer import Clusterer, ClustererOutput
+from dataeval._internal.detectors.duplicates import Duplicates, DuplicatesOutput
+from dataeval._internal.detectors.outliers import Outliers, OutliersOutput
+
+__all__ = [
+    "Clusterer",
+    "ClustererOutput",
+    "Duplicates",
+    "DuplicatesOutput",
+    "Outliers",
+    "OutliersOutput",
+]

dataeval/detectors/ood/__init__.py

@@ -1,11 +1,23 @@
+"""
+Out-of-distribution detectors identify data that is different from the data used to train a particular model.
+"""
+
 from dataeval import _IS_TENSORFLOW_AVAILABLE
 
 if _IS_TENSORFLOW_AVAILABLE:  # pragma: no cover
     from dataeval._internal.detectors.ood.ae import OOD_AE
     from dataeval._internal.detectors.ood.aegmm import OOD_AEGMM
-    from dataeval._internal.detectors.ood.base import OODOutput, OODScore
+    from dataeval._internal.detectors.ood.base import OODOutput, OODScoreOutput
     from dataeval._internal.detectors.ood.llr import OOD_LLR
     from dataeval._internal.detectors.ood.vae import OOD_VAE
     from dataeval._internal.detectors.ood.vaegmm import OOD_VAEGMM
 
-    __all__ = ["OODOutput", "OODScore", "OOD_AE", "OOD_AEGMM", "OOD_LLR", "OOD_VAE", "OOD_VAEGMM"]
+    __all__ = [
+        "OOD_AE",
+        "OOD_AEGMM",
+        "OOD_LLR",
+        "OOD_VAE",
+        "OOD_VAEGMM",
+        "OODOutput",
+        "OODScoreOutput",
+    ]

dataeval/metrics/__init__.py

@@ -1,3 +1,8 @@
+"""
+Metrics are a way to measure the performance of your models or datasets that
+can then be analyzed in the context of a given problem.
+"""
+
 from . import bias, estimators, stats
 
 __all__ = ["bias", "estimators", "stats"]

dataeval/metrics/bias/__init__.py

@@ -1,7 +1,12 @@
-from dataeval._internal.metrics.balance import balance
-from dataeval._internal.metrics.coverage import coverage
-from dataeval._internal.metrics.diversity import diversity
-from dataeval._internal.metrics.parity import label_parity, parity
+"""
+Bias metrics check for skewed or imbalanced datasets and incomplete feature
+representation which may impact model performance.
+"""
+
+from dataeval._internal.metrics.balance import BalanceOutput, balance
+from dataeval._internal.metrics.coverage import CoverageOutput, coverage
+from dataeval._internal.metrics.diversity import DiversityOutput, diversity
+from dataeval._internal.metrics.parity import ParityOutput, label_parity, parity
 
 __all__ = [
     "balance",
@@ -9,4 +14,8 @@ __all__ = [
     "diversity",
     "label_parity",
     "parity",
+    "BalanceOutput",
+    "CoverageOutput",
+    "DiversityOutput",
+    "ParityOutput",
 ]

dataeval/metrics/estimators/__init__.py

@@ -1,9 +1,9 @@
-from dataeval._internal.metrics.ber import ber
-from dataeval._internal.metrics.divergence import divergence
-from dataeval._internal.metrics.uap import uap
+"""
+Estimators calculate performance bounds and the statistical distance between datasets.
+"""
 
-__all__ = [
-    "ber",
-    "divergence",
-    "uap",
-]
+from dataeval._internal.metrics.ber import BEROutput, ber
+from dataeval._internal.metrics.divergence import DivergenceOutput, divergence
+from dataeval._internal.metrics.uap import UAPOutput, uap
+
+__all__ = ["ber", "divergence", "uap", "BEROutput", "DivergenceOutput", "UAPOutput"]

dataeval/metrics/stats/__init__.py

@@ -1,10 +1,15 @@
+"""
+Statistics metrics calculate a variety of image properties and pixel statistics
+and label statistics against the images and labels of a dataset.
+"""
+
 from dataeval._internal.metrics.stats.boxratiostats import boxratiostats
-from dataeval._internal.metrics.stats.datasetstats import datasetstats
-from dataeval._internal.metrics.stats.dimensionstats import dimensionstats
-from dataeval._internal.metrics.stats.hashstats import hashstats
-from dataeval._internal.metrics.stats.labelstats import labelstats
-from dataeval._internal.metrics.stats.pixelstats import pixelstats
-from dataeval._internal.metrics.stats.visualstats import visualstats
+from dataeval._internal.metrics.stats.datasetstats import DatasetStatsOutput, datasetstats
+from dataeval._internal.metrics.stats.dimensionstats import DimensionStatsOutput, dimensionstats
+from dataeval._internal.metrics.stats.hashstats import HashStatsOutput, hashstats
+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
 
 __all__ = [
     "boxratiostats",
@@ -14,4 +19,10 @@ __all__ = [
     "labelstats",
     "pixelstats",
     "visualstats",
+    "DatasetStatsOutput",
+    "DimensionStatsOutput",
+    "HashStatsOutput",
+    "LabelStatsOutput",
+    "PixelStatsOutput",
+    "VisualStatsOutput",
 ]

dataeval/utils/__init__.py

@@ -1,6 +1,19 @@
-from dataeval import _IS_TORCH_AVAILABLE
+"""
+The utility classes and functions are provided by DataEval to assist users
+in setting up architectures that are guaranteed to work with applicable DataEval
+metrics. Currently DataEval supports both Tensorflow and PyTorch backends.
+"""
+
+from dataeval import _IS_TENSORFLOW_AVAILABLE, _IS_TORCH_AVAILABLE
+
+__all__ = []
 
 if _IS_TORCH_AVAILABLE:  # pragma: no cover
-    from dataeval._internal.utils import read_dataset
+    from . import torch
+
+    __all__ += ["torch"]
+
+if _IS_TENSORFLOW_AVAILABLE:  # pragma: no cover
+    from . import tensorflow
 
-    __all__ = ["read_dataset"]
+    __all__ += ["tensorflow"]

dataeval/utils/tensorflow/__init__.py

@@ -0,0 +1,11 @@
+"""
+Tensorflow models are used in out-of-distribution detectors in the :mod:`dataeval.detectors.ood` module.
+
+DataEval provides both basic default models through the utility :func:`dataeval.utils.tensorflow.models.create_model`
+as well as constructors which allow for customization of the encoder, decoder and any other applicable
+layers used by the model.
+"""
+
+from . import loss, models, recon
+
+__all__ = ["loss", "models", "recon"]

dataeval/utils/torch/__init__.py

@@ -0,0 +1,12 @@
+"""
+PyTorch is the primary backend for metrics that require neural networks.
+
+While these metrics can take in custom models, DataEval provides utility classes
+to create a seamless integration between custom models and DataEval's metrics.
+"""
+
+from dataeval._internal.utils import read_dataset
+
+from . import models, trainer
+
+__all__ = ["read_dataset", "models", "trainer"]

dataeval/utils/torch/datasets/__init__.py

@@ -0,0 +1,7 @@
+"""
+Provide access to common Torch datasets used for computer vision
+"""
+
+from dataeval._internal.datasets import CIFAR10, MNIST, VOCDetection
+
+__all__ = ["CIFAR10", "MNIST", "VOCDetection"]

dataeval/workflows/__init__.py

@@ -1,3 +1,7 @@
+"""
+Workflows perform a sequence of actions to analyze the dataset and make predictions.
+"""
+
 from dataeval import _IS_TORCH_AVAILABLE
 
 if _IS_TORCH_AVAILABLE:  # pragma: no cover

{dataeval-0.70.0.dist-info → dataeval-0.70.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.70.0
+Version: 0.70.1
 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
@@ -30,7 +30,6 @@ Requires-Dist: pillow (>=10.3.0)
 Requires-Dist: scikit-learn (>=1.5.0)
 Requires-Dist: scipy (>=1.10)
 Requires-Dist: tensorflow (>=2.14.1,<2.16) ; extra == "tensorflow" or extra == "all"
-Requires-Dist: tensorflow-io-gcs-filesystem (>=0.35.0,<0.37) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: tensorflow_probability (>=0.22.1,<0.24) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: torch (>=2.2.0) ; extra == "torch" or extra == "all"
 Requires-Dist: torchvision (>=0.17.0) ; extra == "torch" or extra == "all"
@@ -75,6 +74,15 @@ You can install DataEval directly from pypi.org using the following command.  Th
 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.

dataeval-0.70.1.dist-info/RECORD

@@ -0,0 +1,80 @@
+dataeval/__init__.py,sha256=AIHxRS7PYlqg4s7fZJTPKuTtyWFWoVROw4knVoSBH6E,555
+dataeval/_internal/datasets.py,sha256=KbXSR-vOAzFamfXHRnI9mhhqUzEPyGpK47fZsirQn1I,14638
+dataeval/_internal/detectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/clusterer.py,sha256=srqTHzh9kIy7Ty4VYaptwuQlBh8emFeiEAeS_mYFKro,20750
+dataeval/_internal/detectors/drift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/drift/base.py,sha256=9EIb4eHVnZ8j6ms_kxRs6fOWbHkYKeHPPHWVGD4ikZo,15984
+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=ztQSdSlpD66z9xFKqvNo3QHR1vEvf6X-m0LvxNckQgc,7517
+dataeval/_internal/detectors/drift/torch.py,sha256=YhIN85MbUV3C4IJcRvqYdXSWLj5lUeEOb05T5DgB3xo,11552
+dataeval/_internal/detectors/drift/uncertainty.py,sha256=Ot8L42AnFbkij4J3Tis7VzXLv3hfBxoOWBP4UoCEnVs,5125
+dataeval/_internal/detectors/duplicates.py,sha256=wggaIl3uFxihNBQhPv5JcreZbhVaFKoMAJMv_9-aaHU,5324
+dataeval/_internal/detectors/merged_stats.py,sha256=okXGrqAgsqfANMxfIjiUQlZWlaIh5TVvIB9UPsOJZ7k,1351
+dataeval/_internal/detectors/ood/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/ood/ae.py,sha256=AIffh11UKZX-3oocDDp8-t-uDUm8aQKvrV0nIE3BLQo,2140
+dataeval/_internal/detectors/ood/aegmm.py,sha256=q2kRXZM5X0PoA10mRsi8Gh-W5FdFzEsnM1yDq3GFzn0,2518
+dataeval/_internal/detectors/ood/base.py,sha256=qYSmcN74x5-qL0_I7uNo4eQ8X8pr7M4cwjs2qvkJt5g,8561
+dataeval/_internal/detectors/ood/llr.py,sha256=VgZtMrMgI8zDVUzsqm2l4tqsULFIhdQeDd4lzdo_G7U,10217
+dataeval/_internal/detectors/ood/vae.py,sha256=iXEltu5pATWr42-28hZ3ARZavJrptLwUM5P9c8omA_s,3030
+dataeval/_internal/detectors/ood/vaegmm.py,sha256=ujp6UN0wpZcmPDPkVfTHZxgka5kuTOSzgXMmbKdmK2U,2947
+dataeval/_internal/detectors/outliers.py,sha256=JmAXoMO0Od7tc9RVFGJsDyOnByciPFG5FdS54Iu0BII,10396
+dataeval/_internal/interop.py,sha256=FLXJY-5hwJcKCtruyvaarqynXCMfcLbQSFvGnrWQDPo,1338
+dataeval/_internal/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/metrics/balance.py,sha256=8KwuR5HvytJtS1YW9KkNrCu2dPn_gP4FSbXrxQ-9kK8,6182
+dataeval/_internal/metrics/ber.py,sha256=RLRC3ouKYCLYJsA0sqS1gLjE_WFLq7dHElRfVVabvWA,4719
+dataeval/_internal/metrics/coverage.py,sha256=jxvzWpVQrfmN3S9rpXvyb35vpRn1ovV2IdXdB6aU2-w,3560
+dataeval/_internal/metrics/divergence.py,sha256=gKQt9rxmhW8RnODCoLgFSPnCUWEMjmNIPlCV2w6E6oU,4211
+dataeval/_internal/metrics/diversity.py,sha256=ZSlq1KBvkMRVAvlznils2QmlPC73TTpHs1ux7PoFrio,7664
+dataeval/_internal/metrics/parity.py,sha256=eTjltNBJOTFH6T_t9V9-1EFr_U0vqlU642o3x2RWgz0,16527
+dataeval/_internal/metrics/stats/base.py,sha256=HyjgHTQZqgkkCWDzOF-aNZBr88IAjnao8VSbHC5ZtbI,8554
+dataeval/_internal/metrics/stats/boxratiostats.py,sha256=Ac6nB41q43xHCJRDEXHNgsJF80VE8MpH8_kySxA84BE,6342
+dataeval/_internal/metrics/stats/datasetstats.py,sha256=6DFl3TE7t2ggDD8WBVgPH7F2bRvae7NR2PVoEWL92dw,3759
+dataeval/_internal/metrics/stats/dimensionstats.py,sha256=MUQJgrWmRoQFap7gPf8vTFXJ_z7G7bAQpZ7kCPRtNkA,3847
+dataeval/_internal/metrics/stats/hashstats.py,sha256=xH0k_wOeGO5UC7-0fhAIg4WV2fO8fnF0Jdn18gYhW88,2087
+dataeval/_internal/metrics/stats/labelstats.py,sha256=BNxI2flvKhSps2o4-TPbN9nf52ctatI2SuDZ07hah5E,4058
+dataeval/_internal/metrics/stats/pixelstats.py,sha256=LxoDQ6afsNuzB0WnOgmzkEUV7s534MrAYkzS6Be7PPQ,4419
+dataeval/_internal/metrics/stats/visualstats.py,sha256=3uET0N3WgV5dcxst8Xb9DhcATiNfAXsx1OKbPz2mU4Q,4712
+dataeval/_internal/metrics/uap.py,sha256=RumSQey6vNoz9CtOG2_Inb-TurKJrAHqwhkyWBirxhk,2128
+dataeval/_internal/metrics/utils.py,sha256=vW3mQHjF0AvYlml27X5dZgd0YBk3zyBvvztLEfdRkvI,13475
+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=nPyLjLZrPNla-lMnym3fUW-O1F00JbIrVUrUFU4C4UQ,8364
+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=keI1gTNjBk18YD91Cp4exfuGYWU9lt-wapvhSazhcVs,48319
+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=qVbOi41dvfQICQ4uxysHPWBRKo1XR61kXHPL_vKOPm0,2545
+dataeval/_internal/utils.py,sha256=jo6bGJZAgyuZqRpAAC4gwhAHYE12316na19ZuFwMqes,1504
+dataeval/_internal/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/workflows/sufficiency.py,sha256=5N07nV5Oi4kUCm_3rJoj0SeIy1iRC3LciEgrR7E9m7Q,18240
+dataeval/detectors/__init__.py,sha256=8nJk2U99_SQD7RtEKjyS4WJct8gX1HgjEm4oHTnRhTI,320
+dataeval/detectors/drift/__init__.py,sha256=9TbJok7fH3mcXcM7c2vT3WZnZr2wanY_8TUwu-8JX58,800
+dataeval/detectors/drift/kernels/__init__.py,sha256=djIbmvYoHWpWxfdYtiouEC2KqzvgmtEqlg1i5p-UCgM,266
+dataeval/detectors/drift/updates/__init__.py,sha256=tiYSA1-AsTiFgC3LuxM8iYFsWUX0Fr8hElzWvU8ovig,267
+dataeval/detectors/linters/__init__.py,sha256=m5F5JgGBcqGb3J_qXQ3PBkKyePjOklrYbM9dGUsgxFA,489
+dataeval/detectors/ood/__init__.py,sha256=K5QrSJg2QePs6Pa3Cg80ZwXu7BELLrSlbEpTdxuL3Ys,777
+dataeval/metrics/__init__.py,sha256=U0sRw5eiqeeDLbLPxT_rznZsvtNwONVxKVwfC0qVOgo,223
+dataeval/metrics/bias/__init__.py,sha256=Wn1Ui_g-9cR4c4IS7RFKJ6UH5DLXKjEBoXTuEYPXSBc,619
+dataeval/metrics/estimators/__init__.py,sha256=4VFMKLPsJdaWiflf84bXGQ2k8ertFQ4WEPhyWqjFFvE,377
+dataeval/metrics/stats/__init__.py,sha256=UcD41gFwFhcQMtqwWkPQlg6cFA2_gdj6yGRCDrKYXM8,1055
+dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/utils/__init__.py,sha256=cW_5-DIZG2OFRs3FVLOz0uCv4JWdaoVO7C9rOlR7ZEA,526
+dataeval/utils/tensorflow/__init__.py,sha256=XgjqrMtI00ERPPpdokbO1lDyc_H3CZ1TTqUXIj0B6PI,435
+dataeval/utils/tensorflow/loss/__init__.py,sha256=E9eB87LNh0o5nUCqssB027EXBsOfEayNHPcNW0QGFdA,101
+dataeval/utils/tensorflow/models/__init__.py,sha256=OVpmHF8itDcgOlfw6N9jr7IphZPbMJoiu7OdqYhU9fs,291
+dataeval/utils/tensorflow/recon/__init__.py,sha256=xe6gAQqK9tyAoDQTtaJAxIPK1humt5QzsG_9NPsqx58,116
+dataeval/utils/torch/__init__.py,sha256=bYUm-nNlNVU3bqDz7dQHFmaRWgLy3lLrD4cSDumDlxQ,373
+dataeval/utils/torch/datasets/__init__.py,sha256=S6C4OaxEjJJaIpHSZcZfkl4U5iS5YtZ9N5GYHqvbzvM,191
+dataeval/utils/torch/models/__init__.py,sha256=YnDnePYpRIKHyYn3F5qR1OObMSb-g0FGvI8X-uTB09E,162
+dataeval/utils/torch/trainer/__init__.py,sha256=Te-qElt8h-Zv8NN0r-VJOEdCPHTQ2yO3rd2MhRiZGZs,93
+dataeval/workflows/__init__.py,sha256=VFeJyMhZxvj8WnU5Un32mwO8lNfBQOBjD9IdOqexnAE,320
+dataeval-0.70.1.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.70.1.dist-info/METADATA,sha256=B2slR1eY_xRR4QcUTpV8EJh5Z_plWmHFqTT5j4r2Vvk,4502
+dataeval-0.70.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dataeval-0.70.1.dist-info/RECORD,,

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"]