dataeval 0.72.1__py3-none-any.whl → 0.73.0__py3-none-any.whl

dataeval/utils/torch/models.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+__all__ = ["AriaAutoencoder", "Encoder", "Decoder"]
+
+from typing import Any
+
+import torch.nn as nn
+
+
+class AriaAutoencoder(nn.Module):
+    """
+    An autoencoder model with a separate encoder and decoder.
+
+    Parameters
+    ----------
+    channels : int, default 3
+        Number of input channels
+    """
+
+    def __init__(self, channels: int = 3) -> None:
+        super().__init__()
+        self.encoder: Encoder = Encoder(channels)
+        self.decoder: Decoder = Decoder(channels)
+
+    def forward(self, x: Any) -> Any:
+        """
+        Perform a forward pass through the encoder and decoder.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor
+
+        Returns
+        -------
+        torch.Tensor
+            The reconstructed output tensor.
+        """
+        x = self.encoder(x)
+        x = self.decoder(x)
+        return x
+
+    def encode(self, x: Any) -> Any:
+        """
+        Encode the input tensor using the encoder.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor
+
+        Returns
+        -------
+        torch.Tensor
+            The encoded representation of the input tensor.
+        """
+        return self.encoder(x)
+
+
+class Encoder(nn.Module):
+    """
+    A simple encoder to be used in an autoencoder model.
+
+    This is the encoder used by the AriaAutoencoder model.
+
+    Parameters
+    ----------
+    channels : int, default 3
+        Number of input channels
+    """
+
+    def __init__(self, channels: int = 3) -> None:
+        super().__init__()
+        self.encoder: nn.Sequential = nn.Sequential(
+            nn.Conv2d(channels, 256, 2, stride=1, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(256, 128, 2, stride=1, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(128, 64, 2, stride=1),
+        )
+
+    def forward(self, x: Any) -> Any:
+        """
+        Perform a forward pass through the encoder.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor
+
+        Returns
+        -------
+        torch.Tensor
+            The encoded representation of the input tensor.
+        """
+        return self.encoder(x)
+
+
+class Decoder(nn.Module):
+    """
+    A simple decoder to be used in an autoencoder model.
+
+    This is the decoder used by the AriaAutoencoder model.
+
+    Parameters
+    ----------
+    channels : int
+        Number of output channels
+    """
+
+    def __init__(self, channels: int) -> None:
+        super().__init__()
+        self.decoder: nn.Sequential = nn.Sequential(
+            nn.ConvTranspose2d(64, 128, 2, stride=1),
+            nn.ReLU(),
+            nn.ConvTranspose2d(128, 256, 2, stride=2),
+            nn.ReLU(),
+            nn.ConvTranspose2d(256, channels, 2, stride=2),
+            nn.Sigmoid(),
+        )
+
+    def forward(self, x: Any) -> Any:
+        """
+        Perform a forward pass through the decoder.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            The encoded tensor.
+
+        Returns
+        -------
+        torch.Tensor
+            The reconstructed output tensor.
+        """
+        return self.decoder(x)

dataeval/{_internal/models/pytorch/autoencoder.py → utils/torch/trainer.py}

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+__all__ = ["AETrainer"]
+
 from typing import Any
 
 import torch
@@ -38,11 +40,11 @@ class AETrainer:
     ):
         if device == "auto":
             device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.device = device
-        self.model = model.to(device)
+        self.device: torch.device = torch.device(device)
+        self.model: nn.Module = model.to(device)
         self.batch_size = batch_size
 
-    def train(self, dataset: Dataset, epochs: int = 25) -> list[float]:
+    def train(self, dataset: Dataset[Any], epochs: int = 25) -> list[float]:
         """
         Basic image reconstruction training function for :term:`Autoencoder` models
 
@@ -101,7 +103,7 @@ class AETrainer:
         return loss_history
 
     @torch.no_grad
-    def eval(self, dataset: Dataset) -> float:
+    def eval(self, dataset: Dataset[Any]) -> float:
         """
         Basic image reconstruction evaluation function for :term:`autoencoder<Autoencoder>` models
 
@@ -137,7 +139,7 @@ class AETrainer:
         return total_loss / len(dataloader)
 
     @torch.no_grad
-    def encode(self, dataset: Dataset) -> torch.Tensor:
+    def encode(self, dataset: Dataset[Any]) -> torch.Tensor:
         """
         Create image :term:`embeddings<Embeddings>` for the dataset using the model's encoder.
 
@@ -174,134 +176,3 @@ class AETrainer:
             encodings = torch.vstack((encodings, embeddings)) if len(encodings) else embeddings
 
         return encodings
-
-
-class AriaAutoencoder(nn.Module):
-    """
-    An :term:`autoencoder<Autoencoder>` model with a separate encoder and decoder.
-
-    Parameters
-    ----------
-    channels : int, default 3
-        Number of input channels
-    """
-
-    def __init__(self, channels=3):
-        super().__init__()
-        self.encoder = Encoder(channels)
-        self.decoder = Decoder(channels)
-
-    def forward(self, x):
-        """
-        Perform a forward pass through the encoder and decoder.
-
-        Parameters
-        ----------
-        x : torch.Tensor
-            Input tensor
-
-        Returns
-        -------
-        torch.Tensor
-            The reconstructed output tensor.
-        """
-        x = self.encoder(x)
-        x = self.decoder(x)
-        return x
-
-    def encode(self, x):
-        """
-        Encode the input tensor using the encoder.
-
-        Parameters
-        ----------
-        x : torch.Tensor
-            Input tensor
-
-        Returns
-        -------
-        torch.Tensor
-            The encoded representation of the input tensor.
-        """
-        return self.encoder(x)
-
-
-class Encoder(nn.Module):
-    """
-    A simple encoder to be used in an :term:`autoencoder<Autoencoder>` model.
-
-    This is the encoder used by the AriaAutoencoder model.
-
-    Parameters
-    ----------
-    channels : int, default 3
-        Number of input channels
-    """
-
-    def __init__(self, channels=3):
-        super().__init__()
-        self.encoder = nn.Sequential(
-            nn.Conv2d(channels, 256, 2, stride=1, padding=1),
-            nn.ReLU(),
-            nn.MaxPool2d(2),
-            nn.Conv2d(256, 128, 2, stride=1, padding=1),
-            nn.ReLU(),
-            nn.MaxPool2d(2),
-            nn.Conv2d(128, 64, 2, stride=1),
-        )
-
-    def forward(self, x):
-        """
-        Perform a forward pass through the encoder.
-
-        Parameters
-        ----------
-        x : torch.Tensor
-            Input tensor
-
-        Returns
-        -------
-        torch.Tensor
-            The encoded representation of the input tensor.
-        """
-        return self.encoder(x)
-
-
-class Decoder(nn.Module):
-    """
-    A simple decoder to be used in an :term:`autoencoder<Autoencoder>` model.
-
-    This is the decoder used by the AriaAutoencoder model.
-
-    Parameters
-    ----------
-    channels : int
-        Number of output channels
-    """
-
-    def __init__(self, channels):
-        super().__init__()
-        self.decoder = nn.Sequential(
-            nn.ConvTranspose2d(64, 128, 2, stride=1),
-            nn.ReLU(),
-            nn.ConvTranspose2d(128, 256, 2, stride=2),
-            nn.ReLU(),
-            nn.ConvTranspose2d(256, channels, 2, stride=2),
-            nn.Sigmoid(),
-        )
-
-    def forward(self, x):
-        """
-        Perform a forward pass through the decoder.
-
-        Parameters
-        ----------
-        x : torch.Tensor
-            The encoded tensor.
-
-        Returns
-        -------
-        torch.Tensor
-            The reconstructed output tensor.
-        """
-        return self.decoder(x)

dataeval/{_internal → utils/torch}/utils.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
+__all__ = ["read_dataset"]
+
 from collections import defaultdict
 from typing import Any
 
 from torch.utils.data import Dataset
 
 
-def read_dataset(dataset: Dataset) -> list[list[Any]]:
+def read_dataset(dataset: Dataset[Any]) -> list[list[Any]]:
     """
     Extract information from a dataset at each index into individual lists of each information position
 

dataeval/workflows/__init__.py

@@ -5,6 +5,6 @@ Workflows perform a sequence of actions to analyze the dataset and make predicti
 from dataeval import _IS_TORCH_AVAILABLE
 
 if _IS_TORCH_AVAILABLE:  # pragma: no cover
-    from dataeval._internal.workflows.sufficiency import Sufficiency, SufficiencyOutput
+    from dataeval.workflows.sufficiency import Sufficiency, SufficiencyOutput
 
     __all__ = ["Sufficiency", "SufficiencyOutput"]

dataeval/{_internal/workflows → workflows}/sufficiency.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+__all__ = ["SufficiencyOutput", "Sufficiency"]
+
 import warnings
 from dataclasses import dataclass
-from typing import Any, Callable, Iterable, Mapping, Sequence, cast
+from typing import Any, Callable, Generic, Iterable, Mapping, Sequence, TypeVar, cast
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -13,8 +15,8 @@ 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
+from dataeval.interop import as_numpy
+from dataeval.output import OutputMetadata, set_metadata
 
 
 @dataclass(frozen=True)
@@ -36,7 +38,7 @@ class SufficiencyOutput(OutputMetadata):
     params: dict[str, NDArray[np.float64]]
     measures: dict[str, NDArray[np.float64]]
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         c = len(self.steps)
         if set(self.params) != set(self.measures):
             raise ValueError("params and measures have a key mismatch")
@@ -45,7 +47,7 @@ class SufficiencyOutput(OutputMetadata):
             if c != c_v:
                 raise ValueError(f"{m} does not contain the expected number ({c}) of data points.")
 
-    @set_metadata("dataeval.workflows.SufficiencyOutput")
+    @set_metadata()
     def project(
         self,
         projection: int | Iterable[int],
@@ -170,7 +172,7 @@ class SufficiencyOutput(OutputMetadata):
         return projection
 
 
-def f_out(n_i: NDArray, x: NDArray) -> NDArray:
+def f_out(n_i: NDArray[Any], x: NDArray[Any]) -> NDArray[Any]:
     """
     Calculates the line of best fit based on its free parameters
 
@@ -189,7 +191,7 @@ def f_out(n_i: NDArray, x: NDArray) -> NDArray:
     return x[0] * n_i ** (-x[1]) + x[2]
 
 
-def f_inv_out(y_i: NDArray, x: NDArray) -> NDArray[np.uint64]:
+def f_inv_out(y_i: NDArray[Any], x: NDArray[Any]) -> NDArray[np.uint64]:
     """
     Inverse function for f_out()
 
@@ -209,7 +211,7 @@ def f_inv_out(y_i: NDArray, x: NDArray) -> NDArray[np.uint64]:
     return np.asarray(n_i, dtype=np.uint64)
 
 
-def calc_params(p_i: NDArray, n_i: NDArray, niter: int) -> NDArray:
+def calc_params(p_i: NDArray[Any], n_i: NDArray[Any], niter: int) -> NDArray[Any]:
     """
     Retrieves the inverse power curve coefficients for the line of best fit.
     Global minimization is done via basin hopping. More info on this algorithm
@@ -254,7 +256,7 @@ def calc_params(p_i: NDArray, n_i: NDArray, niter: int) -> NDArray:
     return res.x
 
 
-def reset_parameters(model: nn.Module):
+def reset_parameters(model: nn.Module) -> nn.Module:
     """
     Re-initializes each layer in the model using
     the layer's defined weight_init function
@@ -272,7 +274,7 @@ def reset_parameters(model: nn.Module):
     return model.apply(fn=weight_reset)
 
 
-def validate_dataset_len(dataset: Dataset) -> int:
+def validate_dataset_len(dataset: Dataset[Any]) -> int:
     if not hasattr(dataset, "__len__"):
         raise TypeError("Must provide a dataset with a length attribute")
     length: int = dataset.__len__()  # type: ignore
@@ -281,7 +283,7 @@ def validate_dataset_len(dataset: Dataset) -> int:
     return length
 
 
-def project_steps(params: NDArray, projection: NDArray) -> NDArray:
+def project_steps(params: NDArray[Any], projection: NDArray[Any]) -> NDArray[Any]:
     """Projects the measures for each value of X
 
     Parameters
@@ -300,7 +302,7 @@ def project_steps(params: NDArray, projection: NDArray) -> NDArray:
     return 1 - f_out(projection, params)
 
 
-def inv_project_steps(params: NDArray, targets: NDArray) -> NDArray[np.uint64]:
+def inv_project_steps(params: NDArray[Any], targets: NDArray[Any]) -> NDArray[np.uint64]:
     """Inverse function for project_steps()
 
     Parameters
@@ -320,7 +322,7 @@ def inv_project_steps(params: NDArray, targets: NDArray) -> NDArray[np.uint64]:
     return np.ceil(steps)
 
 
-def get_curve_params(measures: dict[str, NDArray], ranges: NDArray, niter: int) -> dict[str, NDArray]:
+def get_curve_params(measures: dict[str, NDArray[Any]], ranges: NDArray[Any], niter: int) -> dict[str, NDArray[Any]]:
     """Calculates and aggregates parameters for both single and multi-class metrics"""
     output = {}
     for name, measure in measures.items():
@@ -337,10 +339,10 @@ def get_curve_params(measures: dict[str, NDArray], ranges: NDArray, niter: int)
 
 def plot_measure(
     name: str,
-    steps: NDArray,
-    measure: NDArray,
-    params: NDArray,
-    projection: NDArray,
+    steps: NDArray[Any],
+    measure: NDArray[Any],
+    params: NDArray[Any],
+    projection: NDArray[Any],
 ) -> Figure:
     fig = plt.figure()
     fig = cast(Figure, fig)
@@ -367,7 +369,10 @@ def plot_measure(
     return fig
 
 
-class Sufficiency:
+T = TypeVar("T")
+
+
+class Sufficiency(Generic[T]):
     """
     Project dataset :term:`sufficiency<Sufficiency>` using given a model and evaluation criteria
 
@@ -401,10 +406,10 @@ class Sufficiency:
     def __init__(
         self,
         model: nn.Module,
-        train_ds: Dataset,
-        test_ds: Dataset,
-        train_fn: Callable[[nn.Module, Dataset, Sequence[int]], None],
-        eval_fn: Callable[[nn.Module, Dataset], Mapping[str, float] | Mapping[str, ArrayLike]],
+        train_ds: Dataset[T],
+        test_ds: Dataset[T],
+        train_fn: Callable[[nn.Module, Dataset[T], Sequence[int]], None],
+        eval_fn: Callable[[nn.Module, Dataset[T]], Mapping[str, float] | Mapping[str, ArrayLike]],
         runs: int = 1,
         substeps: int = 5,
         train_kwargs: Mapping[str, Any] | None = None,
@@ -421,29 +426,29 @@ class Sufficiency:
         self.eval_kwargs = eval_kwargs
 
     @property
-    def train_ds(self):
+    def train_ds(self) -> Dataset[T]:
         return self._train_ds
 
     @train_ds.setter
-    def train_ds(self, value: Dataset):
+    def train_ds(self, value: Dataset[T]) -> None:
         self._train_ds = value
         self._length = validate_dataset_len(value)
 
     @property
-    def test_ds(self):
+    def test_ds(self) -> Dataset[T]:
         return self._test_ds
 
     @test_ds.setter
-    def test_ds(self, value: Dataset):
+    def test_ds(self, value: Dataset[T]) -> None:
         validate_dataset_len(value)
         self._test_ds = value
 
     @property
-    def train_fn(self) -> Callable[[nn.Module, Dataset, Sequence[int]], None]:
+    def train_fn(self) -> Callable[[nn.Module, Dataset[T], Sequence[int]], None]:
         return self._train_fn
 
     @train_fn.setter
-    def train_fn(self, value: Callable[[nn.Module, Dataset, Sequence[int]], None]):
+    def train_fn(self, value: Callable[[nn.Module, Dataset[T], Sequence[int]], None]) -> None:
         if not callable(value):
             raise TypeError("Must provide a callable for train_fn.")
         self._train_fn = value
@@ -451,14 +456,14 @@ class Sufficiency:
     @property
     def eval_fn(
         self,
-    ) -> Callable[[nn.Module, Dataset], dict[str, float] | Mapping[str, ArrayLike]]:
+    ) -> Callable[[nn.Module, Dataset[T]], 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] | Mapping[str, ArrayLike]],
-    ):
+        value: Callable[[nn.Module, Dataset[T]], dict[str, float] | Mapping[str, ArrayLike]],
+    ) -> None:
         if not callable(value):
             raise TypeError("Must provide a callable for eval_fn.")
         self._eval_fn = value
@@ -468,7 +473,7 @@ class Sufficiency:
         return self._train_kwargs
 
     @train_kwargs.setter
-    def train_kwargs(self, value: Mapping[str, Any] | None):
+    def train_kwargs(self, value: Mapping[str, Any] | None) -> None:
         self._train_kwargs = {} if value is None else value
 
     @property
@@ -476,10 +481,10 @@ class Sufficiency:
         return self._eval_kwargs
 
     @eval_kwargs.setter
-    def eval_kwargs(self, value: Mapping[str, Any] | None):
+    def eval_kwargs(self, value: Mapping[str, Any] | None) -> None:
         self._eval_kwargs = {} if value is None else value
 
-    @set_metadata("dataeval.workflows", ["runs", "substeps"])
+    @set_metadata(["runs", "substeps"])
     def evaluate(self, eval_at: int | Iterable[int] | None = None, niter: int = 1000) -> SufficiencyOutput:
         """
         Creates data indices, trains models, and returns plotting data

{dataeval-0.72.1.dist-info → dataeval-0.73.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.72.1
+Version: 0.73.0
 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
@@ -31,11 +31,12 @@ Requires-Dist: pillow (>=10.3.0)
 Requires-Dist: scikit-learn (>=1.5.0)
 Requires-Dist: scipy (>=1.10)
 Requires-Dist: tensorflow (>=2.16,<2.18) ; extra == "tensorflow" or extra == "all"
-Requires-Dist: tensorflow_probability (>=0.24) ; extra == "tensorflow" or extra == "all"
-Requires-Dist: tf-keras (>=2.16) ; extra == "tensorflow" or extra == "all"
+Requires-Dist: tensorflow_probability (>=0.24,<0.25) ; extra == "tensorflow" or extra == "all"
+Requires-Dist: tf-keras (>=2.16,<2.18) ; 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"
 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/

dataeval-0.73.0.dist-info/RECORD

@@ -0,0 +1,73 @@
+dataeval/__init__.py,sha256=cAgMAbawI3EC6HdLfV_g_mMpH5Y-zy-n2qzrRKBH_6s,641
+dataeval/detectors/__init__.py,sha256=xdp8LYOFjV5tVbAwu0Y03KU9EajHkSFy_M3raqbxpDc,383
+dataeval/detectors/drift/__init__.py,sha256=MRPWFOaoVoqAHW36nA5F3wk7QXJU4oecND2RbtgG9oY,757
+dataeval/detectors/drift/base.py,sha256=0S-0MFpIFaJ4_8IGreFKSmyna2L50FBn7DVaoNWmw8E,14509
+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=TqGOnUNYKwpS0GQPV3dSl-_qRa0g2flmoQ-dxzW_JfY,7586
+dataeval/detectors/drift/torch.py,sha256=D46J72OPW8-PpP3w9ODMBfcDSdailIgVjgHVFpbYfws,11649
+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=OtBE5rglAGdTTQRmKUHP6J-uWmnh2E3lZxeqJCnc87U,21014
+dataeval/detectors/linters/duplicates.py,sha256=tOD43rJkvheIA3mznbUqHhft2yD3xRZQdCt61daIca4,5665
+dataeval/detectors/linters/merged_stats.py,sha256=X-bDTwjyR8RuVmzxLaHZmQ5nI3oOWvsqVlitdSncapk,1355
+dataeval/detectors/linters/outliers.py,sha256=BUVvtbKHo04KnRmrgb84MBr0l1gtcY3-xNCHjetFrEQ,10117
+dataeval/detectors/ood/__init__.py,sha256=FVyVuaxVKAOgSTaaBf-j2OXXDarSBFcJ7CTlMV6w88s,661
+dataeval/detectors/ood/ae.py,sha256=XQ_rCsf0VWg_2YXt33XGe6ZgxEud1PfIl7TmBVP1GkM,2347
+dataeval/detectors/ood/aegmm.py,sha256=6UKv0uJYWAzu1F-cITFGly4w9y_t7wqg3OmVyCN365o,2041
+dataeval/detectors/ood/base.py,sha256=a_d52pJMWVmduSt8OvUWYwHE8mpCaI6pIAE4_ib_GOs,8841
+dataeval/detectors/ood/llr.py,sha256=TwUk1RsZhnM5tUssGVMBhWggCW2izs_Asy9QPHkTJaU,10615
+dataeval/detectors/ood/metadata_ks_compare.py,sha256=jH7uDwyyBIIcTrRhQEdnLAdrwf7LfNczKBw0CpJyF5c,4282
+dataeval/detectors/ood/metadata_least_likely.py,sha256=nxMCXUOjOfWHDTGT2SLE7OYBCydRq8zHLd8t17k7hMM,5193
+dataeval/detectors/ood/metadata_ood_mi.py,sha256=KLay2BmgHrStBV92VpIs_B1yEfQKllsMTgzOQEng01I,4065
+dataeval/detectors/ood/vae.py,sha256=UKrQNFdHcnxAY0fAFbLrXasY8Z6qg138BXxqwc1hlts,3154
+dataeval/detectors/ood/vaegmm.py,sha256=_wwmT37URs0MyhbORk91XJExClv-4e15LH_Bj60Pw1w,2409
+dataeval/interop.py,sha256=TZCkZo844DvzHoxuRo-YsBhT6GvKmyQTHtUEQZPly1M,1728
+dataeval/metrics/__init__.py,sha256=fPBNLd-T6mCErZBBJrxWmXIL0jCk7fNUYIcNEBkMa80,238
+dataeval/metrics/bias/__init__.py,sha256=puf645-hAO5hFHNHlZ239TPopqWIoN-uLGXFB8-hA_o,599
+dataeval/metrics/bias/balance.py,sha256=Uz7RHf3UuiAxfYlZpKMg4jMzXwXcEfYj7BUnUjzgkw0,8579
+dataeval/metrics/bias/coverage.py,sha256=eB8PacN_uJ19pMd5SVI3N98NC2KJMgE3tgI-DJFNHYs,4497
+dataeval/metrics/bias/diversity.py,sha256=v9fiuySovMajW9Re0EH_FdbuJryAAdVKkvOuNngO5nc,9618
+dataeval/metrics/bias/metadata.py,sha256=OZB9BzPW6JMq2kTp_a9ucqRNcPpfqOexINax1jH5vVQ,11318
+dataeval/metrics/bias/parity.py,sha256=vfGnt_GoGMjMfWgY1FjqNV-gjqVq13tsTTmVkNtRfDM,17120
+dataeval/metrics/estimators/__init__.py,sha256=O6ocxJq8XDkfJWwXeJnnnzbOyRnFPKF4kTIVTTZYOA8,380
+dataeval/metrics/estimators/ber.py,sha256=SVT-BIC_GLs0l2l2NhWu4OpRbgn96w-OwTSoPHTnQbE,5037
+dataeval/metrics/estimators/divergence.py,sha256=pImaa216-YYTgGWDCSTcpJrC-dfl7150yVrPfW_TyGc,4293
+dataeval/metrics/estimators/uap.py,sha256=Tz1VZOyUa68HlTh94Rl-wnXCWdTAVjTQc3LtSPEWVu4,2175
+dataeval/metrics/stats/__init__.py,sha256=igLRaAt1nX6yRwC4xI0zNPBADi3u7EsSxWP3OZ8AqcU,1086
+dataeval/metrics/stats/base.py,sha256=9M5g2FAWvd50HT-T2h-MCmYLpvk--em_yWro1qWGHFs,12177
+dataeval/metrics/stats/boxratiostats.py,sha256=iNr-FdppiJ7XAeeLY-o7gL_PSxvT8j86iwRijKca2Eg,6465
+dataeval/metrics/stats/datasetstats.py,sha256=LAMFCIS9v0RjLrdKUFuo8nY-3HLVvRlqQIXGMKtsHEw,6255
+dataeval/metrics/stats/dimensionstats.py,sha256=xdTp2AbGH3xefUUsB4sDjgSKiojJ73DCHyuCOPKsErc,4056
+dataeval/metrics/stats/hashstats.py,sha256=X6aSouaMhDcGZMLuCTje3G4QOr2i-Td6H3SyBFDF6mA,4960
+dataeval/metrics/stats/labelstats.py,sha256=BKwSmyxCr2wYq8IMraCUS-b5wqacfT_BukJUYNfqeCo,4114
+dataeval/metrics/stats/pixelstats.py,sha256=x90O10IqVjEORtYwueFLvJnVYTxhPBOOx5HMweBQnJY,4578
+dataeval/metrics/stats/visualstats.py,sha256=y0xIvst7epcajk8vz2jngiAiz0T7DZC-M97Rs1-vV9I,4950
+dataeval/output.py,sha256=jWXXNxFNBEaY1rN7Z-6LZl6bQT-I7z_wqr91Rhrdt_0,3061
+dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/utils/__init__.py,sha256=Qr-D0yHnDE8qit0-Wf6xmdMX9Wle2p_mXKgTueTy5GA,753
+dataeval/utils/image.py,sha256=KgC_1nW__nGN5q6bVZNvG4U_qIBdjcPATz9qe8f2XuA,1928
+dataeval/utils/lazy.py,sha256=M0iBHuJh4UPrSJPHZ0jhFwRSZhyjHJQx_KEf1OCkHD8,588
+dataeval/utils/metadata.py,sha256=A6VN7KbdiOA6rUQvUGKwDcvtOyjBer8bRW_wFxNhmW0,8556
+dataeval/utils/shared.py,sha256=BvEeYPMNQTmx4LSaImGeC0VkvcbEY3Byqtxa-jQ3xgc,3623
+dataeval/utils/split_dataset.py,sha256=IopyxwC3FaZwgVriW4OXze-mDMpOlvRr83OADA5Jydk,19454
+dataeval/utils/tensorflow/__init__.py,sha256=l4OjIA75JJXeNWDCkST1xtDMVYsw97lZ-9JXFBlyuYg,539
+dataeval/utils/tensorflow/_internal/gmm.py,sha256=RIFx8asEpi2kMf8JVzq9M3aAvNe9fjpJPf3BzWE-aeE,3787
+dataeval/utils/tensorflow/_internal/loss.py,sha256=TFhoNPgqeJtdpIHYobZPyzMpeWjzlFqzu5LCtthEUi4,4463
+dataeval/utils/tensorflow/_internal/models.py,sha256=TzQYRrFe5XomhnPw05v-HBODQdFIqWg21WH1xS0XBlg,59868
+dataeval/utils/tensorflow/_internal/trainer.py,sha256=uBFTnAy9o2T_FoT3RSX-AA7T-2FScyOdYEg9_7Dpd28,4314
+dataeval/utils/tensorflow/_internal/utils.py,sha256=lr5hKkAPbjMCUNIzMUIqbEddwbWQfMdL6hcazTHU3Uc,9541
+dataeval/utils/tensorflow/loss/__init__.py,sha256=Q-66vt91Oe1ByYfo28tW32zXDq2MqQ2gngWgmIVmof8,227
+dataeval/utils/torch/__init__.py,sha256=lpkqfgyARUxgrV94cZESQv8PIP2p-UnwItZ_wIr0XzQ,675
+dataeval/utils/torch/blocks.py,sha256=HVhBTMMD5NA4qheMUgyol1KWiKZDIuc8k5j4RcMKmhk,1466
+dataeval/utils/torch/datasets.py,sha256=9YV9-Uhq6NCMuu1hPhMnQXjmeI-Ld8ve1z_haxre88o,15023
+dataeval/utils/torch/models.py,sha256=0BsXmLK8W1OZ8nnEGb1f9LzIeCgtevQC37dvKS1v1vA,3236
+dataeval/utils/torch/trainer.py,sha256=EraOKiXxiMNiycStZNMR5yRz3ehgp87d9ewR9a9dV4w,5559
+dataeval/utils/torch/utils.py,sha256=FI4LJ6DvXFQJVff8fxSCP7LRkp8H9BIUgYX0kk7_Cuo,1537
+dataeval/workflows/__init__.py,sha256=x2JnOoKmLUCZOsB6RNPqMdVvxEb6Hpda5GPJnD_k0v0,310
+dataeval/workflows/sufficiency.py,sha256=1jSYhH9i4oesmJYs5PZvWS1LGXf8ekOgNhpFtMPLPXk,18552
+dataeval-0.73.0.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.73.0.dist-info/METADATA,sha256=YVw0z5C5BZs-9gCxCmbo4aNIN7Ph3rZsel7FofFrMKY,4714
+dataeval-0.73.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dataeval-0.73.0.dist-info/RECORD,,