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

dataeval/_internal/split_dataset.py

@@ -0,0 +1,421 @@
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+from sklearn.cluster import KMeans
+from sklearn.metrics import silhouette_score
+from sklearn.model_selection import GroupKFold, KFold, StratifiedGroupKFold, StratifiedKFold
+from sklearn.utils.multiclass import type_of_target
+
+
+def check_args(num_folds: int = 1, test_frac: float | None = None, val_frac: float | None = None):
+    """Check input arguments to ensure unambiguous splitting arguments are passed.
+
+    Parameters
+    ----------
+    num_folds : int, default 1
+        number of [train, val] cross-validation folds to generate
+    test_frac : float, optional
+        If specified, also generate a test set containing (test_frac*100)% of the data
+    val_frac  : float, optional
+        Only specify if requesting a single [train, val] split. The validation split will
+        contain (val_frac*100)% of any data not already allocated to the test set
+
+    Raises
+    ------
+    UnboundLocalError
+        Raised if more than one fold AND the fraction of data to be used for validation are
+        both requested. In this case, val_frac is ambiguous, since the validation fraction must be
+        by definition 1/num_folds
+    ValueError
+        Raised if num_folds is 1 (or left blank) AND val_frac is unspecified. When only 1 fold is
+        requested, we need to know how much of the data should be allocated for validation.
+    ValueError
+        Raised if the total fraction of data used for evaluation (val + test) meets or exceeds 1.0
+
+    Returns
+    -------
+    None
+    """
+    if (num_folds > 1) and (val_frac is not None):
+        raise ValueError("If specifying val_frac, num_folds must be None or 1")
+    if (num_folds == 1) and (val_frac is None):
+        raise UnboundLocalError("If num_folds is None or 1, must assign a value to val_frac")
+    t_frac = 0.0 if test_frac is None else test_frac
+    v_frac = 1.0 / num_folds * (1.0 - t_frac) if val_frac is None else val_frac * (1.0 - t_frac)
+    if (t_frac + v_frac) >= 1.0:
+        raise ValueError(f"val_frac + test_frac must be less that 1.0, currently {v_frac+t_frac}")
+
+
+def check_labels(labels: list | np.ndarray, total_partitions: int):
+    """Check to make sure there are more input data than the total number of partitions requested
+    Also converts labels to a numpy array, if it isn't already
+
+    Parameters
+    ----------
+    labels : list or np.ndarray
+        all class labels from the input dataset
+    total_partitions : int
+        number of train-val splits requested (+1 if a test holdout is specified)
+
+    Raises
+    ------
+    IndexError
+        Raised if more partitions are requested than number of labels. This is exceedingly rare and
+        usually means you've specified some argument incorrectly.
+    ValueError
+        Raised if the labels are considered continuous by Scikit-Learn. This does not necessarily
+        mean that floats are not accepted as a label format. Rather, this exception implies that
+        there are too many unique values in the set relative to it's cardinality.
+
+    Returns
+    -------
+    index : np.ndarray
+        Integer index generated based on the total number of labels
+    labels : np.ndarray
+        labels, converted to an ndarray if passed as a list.
+    """
+    if len(labels) <= total_partitions:
+        raise IndexError(f"""
+            Total number of labels must greater than the number of total partitions.
+            Got {len(labels)} labels and {total_partitions} total train/val/test partitions.""")
+    if isinstance(labels, list):
+        labels = np.array(labels)
+    if type_of_target(labels) == "continuous":
+        raise ValueError("Detected continuous labels, labels must be discrete for proper stratification")
+    index = np.arange(len(labels))
+    return index, labels
+
+
+def check_stratifiable(labels: np.ndarray, total_partitions: int):
+    """
+    Very basic check to see if dataset can be stratified by class label. This is not a
+    comprehensive test, as factors such as grouping also affect the ability to stratify by label
+
+    Parameters
+    ----------
+    labels : list or np.ndarray
+        all class labels from the input dataset
+    total_partitions : int
+        number of train-val splits requested (+1 if a test holdout is specified)
+
+    Warns
+    -----
+    UserWarning
+        Warns user if the dataset cannot be stratified due to the number of total (train, val, test)
+        partitions exceeding the number of instances of the rarest class label.
+
+    Returns
+    -------
+    stratifiable : bool
+        True if dataset can be stratified according to the criteria above.
+    """
+
+    stratifiable = True
+    _, label_counts = np.unique(labels, return_counts=True)
+    rarest_label_count = label_counts.min()
+    if rarest_label_count < total_partitions:
+        warnings.warn(f"""
+            Unable to stratify due to label frequency. The rarest label occurs {rarest_label_count},
+            which is fewer than the total number of partitions requested. Setting stratify flag to 
+            false.""")
+        stratifiable = False
+    return stratifiable
+
+
+def check_groups(group_ids: np.ndarray, num_partitions: int):
+    """
+    Warns user if the number of unique group_ids is incompatible with a grouped partition containing
+    num_folds folds. If this is the case, returns groups=None, which tells the partitioner not to
+    group the input data.
+
+    Parameters
+    ----------
+    group_ids : np.ndarray
+        Identifies the group to which a sample at the same index belongs.
+    num_partitions: int
+        How many total (train, val) folds will be generated (+1 if also specifying a test fold).
+
+    Warns
+    -----
+    UserWarning
+        Warns if there are fewer groups than the minimum required to successfully partition the data
+        into num_partitions. The minimum is defined as the number of partitions requested plus one.
+
+    Returns
+    -------
+    groupable : bool
+        True if dataset can be grouped by the given group ids, given the criteria above.
+    """
+
+    groupable = True
+    num_unique_groups = len(np.unique(group_ids))
+    min_unique_groups = num_partitions + 1
+    if num_unique_groups < min_unique_groups:
+        warnings.warn(f"""
+            {min_unique_groups} unique groups required for {num_partitions} partitions. 
+            Found {num_unique_groups} instead. Reverting to ungrouped partitioning""")
+        groupable = False
+    else:
+        groupable = True
+    return groupable
+
+
+def bin_kmeans(array: np.ndarray):
+    """
+    Find bins of continuous data by iteratively applying k-means clustering, and keeping the
+    clustering with the highest silhouette score.
+
+    Parameters
+    ----------
+    array : np.ndarray
+        continuous data to bin
+
+    Returns
+    -------
+        np.ndarray[int]: bin numbers assigned by the kmeans best clusterer.
+    """
+    array = np.array(array)
+    if array.ndim == 1:
+        array = array.reshape([-1, 1])
+        best_score = 0.60
+    else:
+        best_score = 0.50
+    bin_index = np.zeros(len(array))
+    for k in range(2, 20):
+        clusterer = KMeans(n_clusters=k)
+        cluster_labels = clusterer.fit_predict(array)
+        score = silhouette_score(array, cluster_labels, sample_size=25_000)
+        if score > best_score:
+            best_score = score
+            bin_index = cluster_labels
+    return bin_index
+
+
+def angle2xy(angles: np.ndarray):
+    """
+    Converts angle measurements to xy coordinates on the unit circle. Needed for binning angle data.
+
+    Parameters
+    ----------
+    angles : np.ndarray
+        angle data in either radians or degrees
+
+    Returns
+    -------
+    xy : np.ndarray
+        Nx2 array of xy coordinates for each angle (can be radians or degrees)
+    """
+    is_radians = ((angles >= -np.pi) & (angles <= 2 * np.pi)).all()
+    radians = angles if is_radians else np.pi / 180 * angles
+    xy = np.stack([np.cos(radians), np.sin(radians)], axis=1)
+    return xy
+
+
+def get_group_ids(metadata: dict, groupnames: list, num_samples: int):
+    """Returns individual group numbers based on a subset of metadata defined by groupnames
+
+    Parameters
+    ----------
+    metadata : dict
+        dictionary containing all metadata
+    groupnames : list
+        which groups from the metadata dictionary to consider for dataset grouping
+    num_samples : int
+        number of labels. Used to ensure agreement between input data/labels and metadata entries.
+
+    Raises
+    ------
+    IndexError
+        raised if an entry in the metadata dictionary doesn't have the same length as num_samples
+
+    Returns
+    -------
+    group_ids: np.ndarray
+        group identifiers from metadata
+    """
+    features2group = {k: np.array(v) for k, v in metadata.items() if k in groupnames}
+    if not features2group:
+        return np.zeros(num_samples, dtype=int)
+    for name, feature in features2group.items():
+        if len(feature) != num_samples:
+            raise IndexError(f"""Feature length does not match number of labels. 
+                             Got {len(feature)} features and {num_samples} samples""")
+        if type_of_target(feature) == "continuous":
+            if ("ANGLE" in name.upper()) or ("AZIMUTH" in name.upper()):
+                feature = angle2xy(feature)
+            features2group[name] = bin_kmeans(feature)
+    binned_features = np.stack(list(features2group.values()), axis=1)
+    _, group_ids = np.unique(binned_features, axis=0, return_inverse=True)
+    return group_ids
+
+
+def make_splits(
+    index: np.ndarray, labels: np.ndarray, n_folds: int, groups: np.ndarray | None = None, stratified: bool = False
+):
+    """Split data into n_folds partitions of training and validation data.
+
+    Parameters
+    ----------
+    index : np.ndarray
+        index corresponding to each label (see below)
+    labels : np.ndarray
+        classification labels
+    n_folds : int
+        number or train/val folds
+    groups : np.ndarray, Optional
+        group index for grouped partitions. Grouped partitions are split such that no group id is
+        present in both a training and validation split.
+    stratified : bool, default=False
+        If True, maintain dataset class balance within each train/val split
+
+    Returns
+    -------
+    split_defs : list[dict]
+        list of dictionaries, which specifying train index, validation index, and the ratio of
+        validation to all data.
+    """
+    split_defs = []
+    index = index.reshape([-1, 1])
+    if groups is not None:
+        splitter = StratifiedGroupKFold(n_folds) if stratified else GroupKFold(n_folds)
+        splits = splitter.split(index, labels, groups)
+    else:
+        splitter = StratifiedKFold(n_folds) if stratified else KFold(n_folds)
+        splits = splitter.split(index, labels)
+    for train_idx, eval_idx in splits:
+        test_ratio = len(eval_idx) / index.shape[0]
+        split_defs.append({"train": train_idx.astype(int), "eval": eval_idx.astype(int), "eval_frac": test_ratio})
+    return split_defs
+
+
+def single_split(
+    index: np.ndarray, labels: np.ndarray, eval_frac: float, groups: np.ndarray | None = None, stratified: bool = False
+):
+    """Handles the special case where only 1 partition of the data is desired (such as when
+    generating the test holdout split). In this case, the desired fraction of the data to be
+    partitioned into the test data must be specified, and a single [train, eval] pair are returned.
+
+    Parameters
+    ----------
+    index : np.ndarray
+        Input Dataset index corresponding to each label
+    labels : np.ndarray
+        Labels upon which splits are (optionally) stratified
+    eval_frac : float
+        Fraction of incoming data to be set aside for evaluation
+    groups : np.ndarray, Optional
+        Group_ids (same shape as labels) for optional group partitioning
+    stratified : bool, default=False
+        Generates stratified splits if true (recommended)
+
+    Returns
+    -------
+    train_index : np.ndarray
+        indices of data partitioned for training
+    eval_index : np.ndarray
+        indices of data partitioned for evaluation
+    """
+    if eval_frac <= 2 / 3:
+        n_folds = max(2, int(round(1 / (eval_frac + 1e-6))))
+        split_candidates = make_splits(index, labels, n_folds, groups, stratified)
+        best_split = min(split_candidates, key=lambda x: abs(eval_frac - x["eval_frac"]))
+        return best_split["train"], best_split["eval"]
+    else:
+        n_folds = max(2, int(round(1 / (1 - eval_frac + 1e-6))))
+        split_candidates = make_splits(index, labels, n_folds, groups, stratified)
+        best_split = min(split_candidates, key=lambda x: abs(eval_frac - (1 - x["eval_frac"])))
+        return best_split["eval"], best_split["train"]
+
+
+def split_dataset(
+    labels: list | np.ndarray,
+    num_folds: int = 1,
+    stratify: bool = False,
+    split_on: list | None = None,
+    metadata: dict | None = None,
+    test_frac: float | None = None,
+    val_frac: float | None = None,
+):
+    """Top level splitting function. Returns a dict with each key-value pair containing
+    train and validation indices. Indices for a test holdout may also be optionally included
+
+    Parameters
+    ----------
+    labels : Union[list, np.ndarray]
+        Classification Labels used to generate splits. Determines the size of the dataset
+    num_folds : int, optional
+        Number of train/val folds. If None, returns a single train/val split, and val_frac must be
+        specified. Defaults to None.
+    stratify : bool, default=False
+        If true, dataset is split such that the class distribution of the entire dataset is
+        preserved within each train/val partition, which is generally recommended.
+    split_on : list, optional
+        Keys of the metadata dictionary which map to columns upon which to group the dataset.
+        A grouped partition is divided such that no group is present within both the training and
+        validation set. Split_on groups should be selected to mitigate validation bias. Defaults to
+        None, in which groups will not be considered when partitioning the data.
+    metadata : dict, optional
+        Dict containing data for potential dataset grouping. See split_on above. Defaults to None.
+    test_frac : float, optional
+        Fraction of data to be optionally held out for test set. Defaults to None, in which no test
+        set is created.
+    val_frac : float, optional
+        Fraction of training data to be set aside for validation in the case where a single
+        train/val split is desired. Defaults to None.
+
+    Raises
+    ------
+    UnboundLocalError
+        Raised if split_on is passed, but metadata is left as None. This is because split_on
+        defines the keys in which metadata dict must be indexed to determine the group index of the
+        data
+
+    Returns
+    -------
+    split_defs : dict
+        dictionary of folds, each containing indices of training and validation data.
+        ex.
+        {
+            "Fold_00":  {
+                            "train": [1,2,3,5,6,7,9,10,11],
+                            "val": [0, 4, 8, 12]
+                        },
+            "test": [13, 14, 15, 16]
+        }
+    """
+
+    check_args(num_folds, test_frac, val_frac)
+    total_partitions = num_folds + 1 if test_frac else num_folds
+    index, labels = check_labels(labels, total_partitions)
+    stratify &= check_stratifiable(labels, total_partitions)
+    if split_on:
+        if metadata is None:
+            raise UnboundLocalError("If split_on is specified, metadata must also be provided")
+        groups = get_group_ids(metadata, split_on, len(labels))
+        groupable = check_groups(groups, total_partitions)
+        if not groupable:
+            groups = None
+    else:
+        groups = None
+    split_defs = {}
+    if test_frac:
+        tv_idx, test_idx = single_split(index, labels, test_frac, groups, stratify)
+        tv_labels = labels[tv_idx]
+        tv_groups = groups[tv_idx] if groups is not None else None
+        split_defs["test"] = test_idx
+    else:
+        tv_idx = np.arange(len(labels)).reshape((-1, 1))
+        tv_labels = labels
+        tv_groups = groups
+    if num_folds == 1:
+        train_idx, val_idx = single_split(tv_idx, tv_labels, val_frac, tv_groups, stratify)  # type: ignore
+        split_defs["fold_0"] = {"train": tv_idx[train_idx].squeeze(), "val": tv_idx[val_idx].squeeze()}
+    else:
+        tv_splits = make_splits(tv_idx, tv_labels, num_folds, tv_groups, stratify)
+        for i, split in enumerate(tv_splits):
+            train_split = tv_idx[split["train"]]
+            val_split = tv_idx[split["eval"]]
+            split_defs[f"fold_{i}"] = {"train": train_split.squeeze(), "val": val_split.squeeze()}
+    return split_defs

dataeval/_internal/workflows/sufficiency.py

@@ -86,7 +86,7 @@ class SufficiencyOutput(OutputMetadata):
         return SufficiencyOutput(projection, self.params, output)
 
     def plot(self, class_names: Sequence[str] | None = None) -> list[Figure]:
-        """Plotting function for data sufficiency tasks
+        """Plotting function for data :term:`sufficience<Sufficiency>` tasks
 
         Parameters
         ----------
@@ -369,7 +369,7 @@ def plot_measure(
 
 class Sufficiency:
     """
-    Project dataset sufficiency using given a model and evaluation criteria
+    Project dataset :term:`sufficiency<Sufficiency>` using given a model and evaluation criteria
 
     Parameters
     ----------
@@ -488,7 +488,7 @@ class Sufficiency:
         ----------
         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.
+            than letting :term:`sufficiency<Sufficiency>` internally create the lengths to evaluate at.
         niter : int, default 1000
             Iterations to perform when using the basin-hopping method to curve-fit measure(s).
 

dataeval/detectors/drift/__init__.py

@@ -1,5 +1,5 @@
 """
-Drift detectors identify if the statistical properties of the data has changed.
+:term:`Drift` detectors identify if the statistical properties of the data has changed.
 """
 
 from dataeval import _IS_TORCH_AVAILABLE

dataeval/detectors/drift/updates/__init__.py

@@ -1,5 +1,6 @@
 """
-Update strategies inform how the drift detector classes update the reference data when monitoring for drift.
+Update strategies inform how the :term:`drift<Drift>` detector classes update the reference data when monitoring
+for drift.
 """
 
 from dataeval._internal.detectors.drift.base import LastSeenUpdate, ReservoirSamplingUpdate

dataeval/detectors/ood/__init__.py

@@ -1,5 +1,5 @@
 """
-Out-of-distribution detectors identify data that is different from the data used to train a particular model.
+Out-of-distribution (OOD)` detectors identify data that is different from the data used to train a particular model.
 """
 
 from dataeval import _IS_TENSORFLOW_AVAILABLE
@@ -12,12 +12,4 @@ if _IS_TENSORFLOW_AVAILABLE:  # pragma: no cover
     from dataeval._internal.detectors.ood.vae import OOD_VAE
     from dataeval._internal.detectors.ood.vaegmm import OOD_VAEGMM
 
-    __all__ = [
-        "OOD_AE",
-        "OOD_AEGMM",
-        "OOD_LLR",
-        "OOD_VAE",
-        "OOD_VAEGMM",
-        "OODOutput",
-        "OODScoreOutput",
-    ]
+    __all__ = ["OOD_AE", "OOD_AEGMM", "OOD_LLR", "OOD_VAE", "OOD_VAEGMM", "OODOutput", "OODScoreOutput"]

dataeval/utils/__init__.py

@@ -1,7 +1,7 @@
 """
 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.
+metrics. Currently DataEval supports both :term:`TensorFlow` and PyTorch backends.
 """
 
 from dataeval import _IS_TENSORFLOW_AVAILABLE, _IS_TORCH_AVAILABLE

dataeval/utils/tensorflow/__init__.py

@@ -1,5 +1,6 @@
 """
-Tensorflow models are used in out-of-distribution detectors in the :mod:`dataeval.detectors.ood` module.
+TensorFlow models are used in :term:`out of distribution<Out-of-distribution (OOD)>` 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.72.0
+Version: 0.72.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
@@ -8,7 +8,7 @@ Author: Andrew Weng
 Author-email: andrew.weng@ariacoustics.com
 Maintainer: ARiA
 Maintainer-email: dataeval@ariacoustics.com
-Requires-Python: >=3.9,<3.12
+Requires-Python: >=3.9,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
@@ -17,19 +17,20 @@ 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: tensorflow
 Provides-Extra: torch
 Requires-Dist: hdbscan (>=0.8.36)
+Requires-Dist: markupsafe (<3.0.2) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: matplotlib ; extra == "torch" or extra == "all"
 Requires-Dist: numpy (>1.24.3)
-Requires-Dist: nvidia-cudnn-cu11 (>=8.6.0.163) ; extra == "tensorflow" or extra == "torch" or extra == "all"
 Requires-Dist: pillow (>=10.3.0)
 Requires-Dist: scikit-learn (>=1.5.0)
 Requires-Dist: scipy (>=1.10)
-Requires-Dist: tensorflow (>=2.16) ; extra == "tensorflow" or extra == "all"
+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: torch (>=2.2.0) ; extra == "torch" or extra == "all"
@@ -44,7 +45,7 @@ Description-Content-Type: text/markdown
 
 ## About DataEval
 
-DataEval focuses on characterizing image data and its impact on model performance across classification and object-detection tasks.
+DataEval focuses on characterizing image data and its impact on model performance across Classification and object-detection tasks.
 
 <!-- start about -->
 

dataeval-0.72.1.dist-info/RECORD

@@ -0,0 +1,81 @@
+dataeval/__init__.py,sha256=0etPX9QsT5z3_nj5m2TuYfw5PbQOdOj_Il1jgPWjWnw,620
+dataeval/_internal/datasets.py,sha256=wufvhWPMFsTSTq3P1_-k8TBJGGhc8mo5b8NHRW9vgbs,14646
+dataeval/_internal/detectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/clusterer.py,sha256=0c3wGdyBKDkXBgmAJ6Y4jZ44CDDUykgOJTnA9yAD7DA,20830
+dataeval/_internal/detectors/drift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/drift/base.py,sha256=gQKY9ahDpVEAhsAc68j2P75KmEKdLTztiyA2ccSqi9k,16236
+dataeval/_internal/detectors/drift/cvm.py,sha256=p9cbs53Ei5WGaZBtmV5rHRspROmZY1IFDE9EMyA5K00,4105
+dataeval/_internal/detectors/drift/ks.py,sha256=KkkUTa2dnamFK_aYSDSIcYYJFxCWbY8M1lvbFsttnLc,4193
+dataeval/_internal/detectors/drift/mmd.py,sha256=v7KPrbnR0-9TQ-obHAaBa0cEELshuQpfTRSXKHomvSY,7679
+dataeval/_internal/detectors/drift/torch.py,sha256=8Rdcb0Ea7_L_SCHldUD55CKRYd7Em1H_xWCuWFcAzgs,11568
+dataeval/_internal/detectors/drift/uncertainty.py,sha256=CEFjFndDnK1DaWI_fI6Uh49-Guc2WcWmbRJ3jG1uQrI,5194
+dataeval/_internal/detectors/duplicates.py,sha256=HCHq-KlqPbjhif_tyvFloE4ypJjDi1DhdAix-GFh6ic,5344
+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=ufzuxFMj4oJgAi5l1NBrdhbmDXeP2dh62f1K9l-g6tM,2207
+dataeval/_internal/detectors/ood/aegmm.py,sha256=YlVCZ4MBGQZqYAwQxoDuCyzZZ_kEIj5DaxI5Aga7JXI,2558
+dataeval/_internal/detectors/ood/base.py,sha256=p67sFaDmYX-9xUq2CeNup8Pk0VcilJ1MuSs3rmMIF9w,8650
+dataeval/_internal/detectors/ood/llr.py,sha256=HsSJZv8YjLucllR-Rlj9syaE7MqMgPVpJdMJkQjWiS8,10295
+dataeval/_internal/detectors/ood/vae.py,sha256=z5h6E6TmkoCMkG6kRXqf81j4mmB8W_88G7YVITeVABc,3077
+dataeval/_internal/detectors/ood/vaegmm.py,sha256=ax2GE_TXET6N6m3nHnnMWSh8GfJDyl8t0jrV8xt7Ol8,2982
+dataeval/_internal/detectors/outliers.py,sha256=jg9vMnk8xep0SbZFgbCcIpgTwDqdCo4xaLHKrqgVwNc,10214
+dataeval/_internal/interop.py,sha256=FLXJY-5hwJcKCtruyvaarqynXCMfcLbQSFvGnrWQDPo,1338
+dataeval/_internal/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/metrics/balance.py,sha256=IACHTcfmS927fjgEUJEnOCcLQ05hNKeybHAjNNHUw9Q,6314
+dataeval/_internal/metrics/ber.py,sha256=b6BRzIKgPuXTVL4Dk4smaY5WOOlwjsTf2UOUxGAQQL4,4899
+dataeval/_internal/metrics/coverage.py,sha256=ZH57GtMmn0KTaz_eh73kBgLP1tSxAyuS2knzx1-etuw,3630
+dataeval/_internal/metrics/divergence.py,sha256=BeAtKmUL27u8mWGsEqkoANZBrQLRYCybQiIVS_Z9Hg4,4266
+dataeval/_internal/metrics/diversity.py,sha256=XLCT_C3Uq_HKOcfHSnk7h35Jcx0XWY7IF5UJcU82qJ4,7743
+dataeval/_internal/metrics/parity.py,sha256=LMEM08E0ScbT2MLmVN8RIJnPEQQD2zTwMjmpwxOeOKs,16613
+dataeval/_internal/metrics/stats/base.py,sha256=bwQrL4e0dR_8Yoc3QLEs7DxEFEE36OcWsgTyk1o1su8,11267
+dataeval/_internal/metrics/stats/boxratiostats.py,sha256=60lhMeIXvbhZsSJkZAddeHsmez-IFNp5jKZjSk-l5og,6362
+dataeval/_internal/metrics/stats/datasetstats.py,sha256=zTtGnhoVZ2cGpKYThCIPHZkHxc0FhnCyzj4iuaLhETI,6221
+dataeval/_internal/metrics/stats/dimensionstats.py,sha256=ffcrgo90Fc1hxSSjQDziUKKPtYzDT9h1ExjoVAJiakw,3965
+dataeval/_internal/metrics/stats/hashstats.py,sha256=Yxvgxmvwd1ySvrC316dFrgNbugcZzadP1c6T-IsBpIE,2130
+dataeval/_internal/metrics/stats/labelstats.py,sha256=Kd9FCVmyAnyuMTuo26XeJL-hNDG_Nk6175Hbs2WVXC4,4106
+dataeval/_internal/metrics/stats/pixelstats.py,sha256=u_539KGAV7UTZ3px52n13B8vlEm8qHWx9U88EBOM8Ps,4456
+dataeval/_internal/metrics/stats/visualstats.py,sha256=EW-JJSQSLAZOMq3EOwKHPX5z7ymIJajPSeIGEtEk930,4838
+dataeval/_internal/metrics/uap.py,sha256=-vAaqCOEBraaZtc5uLI5wCJoej1hzH6ygRaKbbGX8D0,2181
+dataeval/_internal/metrics/utils.py,sha256=vmurS57HCwriNZnnDqgXzIYLUB1hO2fQJ6mVAbMiJnw,13575
+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=SVfwtqZQtTYtqdALLb_NmQChXctDLPB0wazZMhb-_2c,8505
+dataeval/_internal/models/pytorch/blocks.py,sha256=pm2xwsDZjZJYXrhhiz8husvh2vHmrkFMSYEn-EDUD5Q,1354
+dataeval/_internal/models/pytorch/utils.py,sha256=cJjxrNNKaVbhJknX0nX_HiFd43LtytEpDH7P6BbyYrw,1699
+dataeval/_internal/models/tensorflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/models/tensorflow/autoencoder.py,sha256=-Yhcp3mo3uMqtED0KvFIMpmlf5ogDz8XnqCaukDFlco,10453
+dataeval/_internal/models/tensorflow/gmm.py,sha256=QoEgbeax1GETqRmUF7A2ih9uFOZfFAjGzgH2ljExlAc,3669
+dataeval/_internal/models/tensorflow/losses.py,sha256=aWEb2m3CO-fvPXmYFlZtjry4SyhJcVKIqVodMNmvXxA,3997
+dataeval/_internal/models/tensorflow/pixelcnn.py,sha256=nIDNnhYtSaZeL2Qo15Btm4B67fH9cvjpIPn0Kf3jx-g,48363
+dataeval/_internal/models/tensorflow/trainer.py,sha256=LJ3t6Ud95cofKN-cgb5o5nDrYSFse7LSDOYIBkMgDJk,4094
+dataeval/_internal/models/tensorflow/utils.py,sha256=Rxx5LMXjqpDLS8VFDN6YcCNsbq1Nl1WeITMEZcbIqW4,8749
+dataeval/_internal/output.py,sha256=qVbOi41dvfQICQ4uxysHPWBRKo1XR61kXHPL_vKOPm0,2545
+dataeval/_internal/split_dataset.py,sha256=ReGcreMT2bfcK6UNuGCJmYBLb_ylYLegfshVobd4Vrg,16733
+dataeval/_internal/utils.py,sha256=jo6bGJZAgyuZqRpAAC4gwhAHYE12316na19ZuFwMqes,1504
+dataeval/_internal/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/workflows/sufficiency.py,sha256=B9ABh8kt_PWJmgM8if7VdOmoZdUYlOEZoAr9vpjaE1U,18303
+dataeval/detectors/__init__.py,sha256=8nJk2U99_SQD7RtEKjyS4WJct8gX1HgjEm4oHTnRhTI,320
+dataeval/detectors/drift/__init__.py,sha256=Ncv7Xn9rEme2aPWEAJBSrjV0Yug3jhpCuzVxH3xmnf0,808
+dataeval/detectors/drift/kernels/__init__.py,sha256=djIbmvYoHWpWxfdYtiouEC2KqzvgmtEqlg1i5p-UCgM,266
+dataeval/detectors/drift/updates/__init__.py,sha256=yQexC0K4EQvT5Bmfrb6mtfgnV8iPMcsCdrTkb-_vnUI,282
+dataeval/detectors/linters/__init__.py,sha256=m5F5JgGBcqGb3J_qXQ3PBkKyePjOklrYbM9dGUsgxFA,489
+dataeval/detectors/ood/__init__.py,sha256=tRf7xKjMqTEsa4brT9-VP6Ylwqer8lNYYMEFNhD6-4Q,721
+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=AKlNelORMOM2OA9XIvwZ9nOn6dK6k-r-69ldEAuqgLA,1156
+dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/utils/__init__.py,sha256=EAZyCZsNWnwKPtztjuQQsYN5IA9fXc0z-4cQhT9gZQs,534
+dataeval/utils/tensorflow/__init__.py,sha256=M_W3frQUpfVZFeKGMjZlPtYD55ES9gRf0gL2a0dXqGw,565
+dataeval/utils/tensorflow/loss/__init__.py,sha256=s7tD_5dYWcNDmntGiEHhG7bVDsMAY1UO8FpQFe9cUns,195
+dataeval/utils/tensorflow/models/__init__.py,sha256=1R9Oi5DOYwT0W3JSEfoMsPOvhYFaKqKilwkrUifNnig,385
+dataeval/utils/tensorflow/recon/__init__.py,sha256=xe6gAQqK9tyAoDQTtaJAxIPK1humt5QzsG_9NPsqx58,116
+dataeval/utils/torch/__init__.py,sha256=430fNKbqLByuGSeNhnoIJy3g9Z94ckZsAKWUZ15MVP4,575
+dataeval/utils/torch/datasets/__init__.py,sha256=94k7fMQdxYlQXDYouAHUgrQJ2oBwnvq4koFJpyhlUVA,292
+dataeval/utils/torch/models/__init__.py,sha256=q1BzoLHWA0uBXzT2glWJDrxVA1BN7xnkT2r_d-7Dlyw,246
+dataeval/utils/torch/trainer/__init__.py,sha256=hpcrlCCXPzb8b7FOzEAKqFy6Z7Zl4V_cx3yA7n3L1L4,177
+dataeval/workflows/__init__.py,sha256=VFeJyMhZxvj8WnU5Un32mwO8lNfBQOBjD9IdOqexnAE,320
+dataeval-0.72.1.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.72.1.dist-info/METADATA,sha256=ivnqRxBPNcIoW6g4SPJBdOAnrSlhHra2wcYYVso8egc,4606
+dataeval-0.72.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dataeval-0.72.1.dist-info/RECORD,,