dataeval 0.63.0__py3-none-any.whl → 0.64.0__py3-none-any.whl

dataeval/_internal/metrics/uap.py

@@ -4,39 +4,47 @@ FR Test Statistic based estimate for the upperbound
 average precision using empirical mean precision
 """
 
-from typing import Dict
+from typing import NamedTuple
 
-from dataeval._internal.functional.uap import uap
-from dataeval._internal.interop import ArrayLike, to_numpy
-from dataeval._internal.metrics.base import EvaluateMixin
+from numpy.typing import ArrayLike
+from sklearn.metrics import average_precision_score
 
+from dataeval._internal.interop import to_numpy
 
-class UAP(EvaluateMixin):
+
+class UAPOutput(NamedTuple):
+    """
+    Attributes
+    ----------
+    uap : float
+        The empirical mean precision estimate
     """
-    FR Test Statistic based estimate of the empirical mean precision
 
+    uap: float
+
+
+def uap(labels: ArrayLike, scores: ArrayLike) -> UAPOutput:
+    """
+    FR Test Statistic based estimate of the empirical mean precision for
+    the upperbound average precision
+
+    Parameters
+    ----------
+    labels : ArrayLike
+        A numpy array of n_samples of class labels with M unique classes.
+    scores : ArrayLike
+        A 2D array of class probabilities per image
+
+    Returns
+    -------
+    Dict[str, float]
+        uap : The empirical mean precision estimate
+
+    Raises
+    ------
+    ValueError
+        If unique classes M < 2
     """
 
-    def evaluate(self, labels: ArrayLike, scores: ArrayLike) -> Dict[str, float]:
-        """
-        Estimates the upperbound average precision
-
-        Parameters
-        ----------
-        labels : ArrayLike
-            A numpy array of n_samples of class labels with M unique classes.
-        scores : ArrayLike
-            A 2D array of class probabilities per image
-
-        Returns
-        -------
-        Dict[str, float]
-            uap : The empirical mean precision estimate
-
-        Raises
-        ------
-        ValueError
-            If unique classes M < 2
-        """
-
-        return {"uap": uap(to_numpy(labels), to_numpy(scores))}
+    precision = float(average_precision_score(to_numpy(labels), to_numpy(scores), average="weighted"))
+    return UAPOutput(precision)

dataeval/_internal/metrics/utils.py

@@ -0,0 +1,393 @@
+from typing import Any, Callable, Dict, List, Literal, NamedTuple, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import xxhash as xxh
+from PIL import Image
+from scipy.fftpack import dct
+from scipy.signal import convolve2d
+from scipy.sparse import csr_matrix
+from scipy.sparse.csgraph import minimum_spanning_tree as mst
+from scipy.spatial.distance import pdist, squareform
+from scipy.stats import entropy as sp_entropy
+from sklearn.neighbors import NearestNeighbors
+
+EPSILON = 1e-5
+EDGE_KERNEL = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]], dtype=np.int8)
+BIT_DEPTH = (1, 8, 12, 16, 32)
+HASH_SIZE = 8
+MAX_FACTOR = 4
+
+
+def get_method(method_map: Dict[str, Callable], method: str) -> Callable:
+    if method not in method_map:
+        raise ValueError(f"Specified method {method} is not a valid method: {method_map}.")
+    return method_map[method]
+
+
+def get_counts(
+    data: np.ndarray, names: List[str], is_categorical: List[bool], subset_mask: Optional[np.ndarray] = None
+) -> tuple[Dict, Dict]:
+    """
+    Initialize dictionary of histogram counts --- treat categorical values
+    as histogram bins.
+
+    Parameters
+    ----------
+    subset_mask: Optional[np.ndarray[bool]]
+        Boolean mask of samples to bin (e.g. when computing per class).  True -> include in histogram counts
+
+    Returns
+    -------
+    counts: Dict
+        histogram counts per metadata factor in `factors`.  Each
+        factor will have a different number of bins.  Counts get reused
+        across metrics, so hist_counts are cached but only if computed
+        globally, i.e. without masked samples.
+    """
+
+    hist_counts, hist_bins = {}, {}
+    # np.where needed to satisfy linter
+    mask = np.where(subset_mask if subset_mask is not None else np.ones(data.shape[0], dtype=bool))
+
+    for cdx, fn in enumerate(names):
+        # linter doesn't like double indexing
+        col_data = data[mask, cdx].squeeze()
+        if is_categorical[cdx]:
+            # if discrete, use unique values as bins
+            bins, cnts = np.unique(col_data, return_counts=True)
+        else:
+            bins = hist_bins.get(fn, "auto")
+            cnts, bins = np.histogram(col_data, bins=bins, density=True)
+
+        hist_counts[fn] = cnts
+        hist_bins[fn] = bins
+
+    return hist_counts, hist_bins
+
+
+def entropy(
+    data: np.ndarray,
+    names: List[str],
+    is_categorical: List[bool],
+    normalized: bool = False,
+    subset_mask: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    """
+    Meant for use with Bias metrics, Balance, Diversity, ClasswiseBalance,
+    and Classwise Diversity.
+
+    Compute entropy for discrete/categorical variables and, through standard
+    histogram binning, for continuous variables.
+
+    Parameters
+    ----------
+    normalized: bool
+        Flag that determines whether or not to normalize entropy by log(num_bins)
+    subset_mask: Optional[np.ndarray[bool]]
+        Boolean mask of samples to bin (e.g. when computing per class).  True -> include in histogram counts
+
+    Notes
+    -----
+    For continuous variables, histogram bins are chosen automatically.  See
+    numpy.histogram for details.
+
+    Returns
+    -------
+    ent: np.ndarray[float]
+        Entropy estimate per column of X
+
+    See Also
+    --------
+    numpy.histogram
+    scipy.stats.entropy
+    """
+
+    num_factors = len(names)
+    hist_counts, _ = get_counts(data, names, is_categorical, subset_mask)
+
+    ev_index = np.empty(num_factors)
+    for col, cnts in enumerate(hist_counts.values()):
+        # entropy in nats, normalizes counts
+        ev_index[col] = sp_entropy(cnts)
+        if normalized:
+            if len(cnts) == 1:
+                # log(0)
+                ev_index[col] = 0
+            else:
+                ev_index[col] /= np.log(len(cnts))
+    return ev_index
+
+
+def get_num_bins(
+    data: np.ndarray, names: List[str], is_categorical: List[bool], subset_mask: Optional[np.ndarray] = None
+) -> np.ndarray:
+    """
+    Number of bins or unique values for each metadata factor, used to
+    normalize entropy/diversity.
+
+    Parameters
+    ----------
+    subset_mask: Optional[np.ndarray[bool]]
+        Boolean mask of samples to bin (e.g. when computing per class).  True -> include in histogram counts
+    """
+    # likely cached
+    hist_counts, _ = get_counts(data, names, is_categorical, subset_mask)
+    num_bins = np.empty(len(hist_counts))
+    for idx, cnts in enumerate(hist_counts.values()):
+        num_bins[idx] = len(cnts)
+
+    return num_bins
+
+
+def infer_categorical(X: np.ndarray, threshold: float = 0.5) -> np.ndarray:
+    """
+    Compute fraction of feature values that are unique --- intended to be used
+    for inferring whether variables are categorical.
+    """
+    if X.ndim == 1:
+        X = np.expand_dims(X, axis=1)
+    num_samples = X.shape[0]
+    pct_unique = np.empty(X.shape[1])
+    for col in range(X.shape[1]):  # type: ignore
+        uvals = np.unique(X[:, col], axis=0)
+        pct_unique[col] = len(uvals) / num_samples
+    return pct_unique < threshold
+
+
+def preprocess_metadata(class_labels: Sequence[int], metadata: List[Dict]) -> Tuple[np.ndarray, List[str], List[bool]]:
+    # convert class_labels and list of metadata dicts to dict of ndarrays
+    metadata_dict: Dict[str, np.ndarray] = {
+        "class_label": np.asarray(class_labels, dtype=int),
+        **{k: np.array([d[k] for d in metadata]) for k in metadata[0]},
+    }
+
+    # map columns of dict that are not numeric (e.g. string) to numeric values
+    # that mutual information and diversity functions can accommodate.  Each
+    # unique string receives a unique integer value.
+    for k, v in metadata_dict.items():
+        # if not numeric
+        if not np.issubdtype(v.dtype, np.number):
+            _, mapped_vals = np.unique(v, return_inverse=True)
+            metadata_dict[k] = mapped_vals
+
+    data = np.stack(list(metadata_dict.values()), axis=-1)
+    names = list(metadata_dict.keys())
+    is_categorical = [infer_categorical(metadata_dict[var], 0.25)[0] for var in names]
+
+    return data, names, is_categorical
+
+
+def minimum_spanning_tree(X: np.ndarray) -> Any:
+    """
+    Returns the minimum spanning tree from a NumPy image array.
+
+    Parameters
+    ----------
+    X: np.ndarray
+        Numpy image array
+
+    Returns
+    -------
+        Data representing the minimum spanning tree
+    """
+    # All features belong on second dimension
+    X = X.reshape((X.shape[0], -1))
+    # We add a small constant to the distance matrix to ensure scipy interprets
+    # the input graph as fully-connected.
+    dense_eudist = squareform(pdist(X)) + EPSILON
+    eudist_csr = csr_matrix(dense_eudist)
+    return mst(eudist_csr)
+
+
+def get_classes_counts(labels: np.ndarray) -> Tuple[int, int]:
+    """
+    Returns the classes and counts of from an array of labels
+
+    Parameters
+    ----------
+    label: np.ndarray
+        Numpy labels array
+
+    Returns
+    -------
+        Classes and counts
+
+    Raises
+    ------
+    ValueError
+        If the number of unique classes is less than 2
+    """
+    classes, counts = np.unique(labels, return_counts=True)
+    M = len(classes)
+    if M < 2:
+        raise ValueError("Label vector contains less than 2 classes!")
+    N = np.sum(counts).astype(int)
+    return M, N
+
+
+def compute_neighbors(
+    A: np.ndarray,
+    B: np.ndarray,
+    k: int = 1,
+    algorithm: Literal["auto", "ball_tree", "kd_tree"] = "auto",
+) -> np.ndarray:
+    """
+    For each sample in A, compute the nearest neighbor in B
+
+    Parameters
+    ----------
+    A, B : np.ndarray
+        The n_samples and n_features respectively
+    k : int
+        The number of neighbors to find
+    algorithm : Literal
+        Tree method for nearest neighbor (auto, ball_tree or kd_tree)
+
+    Note
+    ----
+        Do not use kd_tree if n_features > 20
+
+    Returns
+    -------
+    List:
+        Closest points to each point in A and B
+
+    See Also
+    --------
+    sklearn.neighbors.NearestNeighbors
+    """
+
+    nbrs = NearestNeighbors(n_neighbors=k + 1, algorithm=algorithm).fit(B)
+    nns = nbrs.kneighbors(A)[1]
+    nns = nns[:, 1:].squeeze()
+
+    return nns
+
+
+class BitDepth(NamedTuple):
+    depth: int
+    pmin: Union[float, int]
+    pmax: Union[float, int]
+
+
+def get_bitdepth(image: np.ndarray) -> BitDepth:
+    """
+    Approximates the bit depth of the image using the
+    min and max pixel values.
+    """
+    pmin, pmax = np.min(image), np.max(image)
+    if pmin < 0:
+        return BitDepth(0, pmin, pmax)
+    else:
+        depth = ([x for x in BIT_DEPTH if 2**x > pmax] or [max(BIT_DEPTH)])[0]
+        return BitDepth(depth, 0, 2**depth - 1)
+
+
+def rescale(image: np.ndarray, depth: int = 1) -> np.ndarray:
+    """
+    Rescales the image using the bit depth provided.
+    """
+    bitdepth = get_bitdepth(image)
+    if bitdepth.depth == depth:
+        return image
+    else:
+        normalized = (image + bitdepth.pmin) / (bitdepth.pmax - bitdepth.pmin)
+        return normalized * (2**depth - 1)
+
+
+def normalize_image_shape(image: np.ndarray) -> np.ndarray:
+    """
+    Normalizes the image shape into (C,H,W).
+    """
+    ndim = image.ndim
+    if ndim == 2:
+        return np.expand_dims(image, axis=0)
+    elif ndim == 3:
+        return image
+    elif ndim > 3:
+        # Slice all but the last 3 dimensions
+        return image[(0,) * (ndim - 3)]
+    else:
+        raise ValueError("Images must have 2 or more dimensions.")
+
+
+def edge_filter(image: np.ndarray, offset: float = 0.5) -> np.ndarray:
+    """
+    Returns the image filtered using a 3x3 edge detection kernel:
+    [[ -1, -1, -1 ],
+     [ -1,  8, -1 ],
+     [ -1, -1, -1 ]]
+    """
+    edges = convolve2d(image, EDGE_KERNEL, mode="same", boundary="symm") + offset
+    np.clip(edges, 0, 255, edges)
+    return edges
+
+
+def pchash(image: np.ndarray) -> str:
+    """
+    Performs a perceptual hash on an image by resizing to a square NxN image
+    using the Lanczos algorithm where N is 32x32 or the largest multiple of
+    8 that is smaller than the input image dimensions.  The resampled image
+    is compressed using a discrete cosine transform and the lowest frequency
+    component is encoded as a bit array of greater or less than median value
+    and returned as a hex string.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        An image as a numpy array in CxHxW format
+
+    Returns
+    -------
+    str
+        The hex string hash of the image using perceptual hashing
+    """
+    # Verify that the image is at least larger than an 8x8 image
+    min_dim = min(image.shape[-2:])
+    if min_dim < HASH_SIZE + 1:
+        raise ValueError(f"Image must be larger than {HASH_SIZE}x{HASH_SIZE} for fuzzy hashing.")
+
+    # Calculates the dimensions of the resized square image
+    resize_dim = HASH_SIZE * min((min_dim - 1) // HASH_SIZE, MAX_FACTOR)
+
+    # Normalizes the image to CxHxW and takes the mean over all the channels
+    normalized = np.mean(normalize_image_shape(image), axis=0).squeeze()
+
+    # Rescales the pixel values to an 8-bit 0-255 image
+    rescaled = rescale(normalized, 8).astype(np.uint8)
+
+    # Resizes the image using the Lanczos algorithm to a square image
+    im = np.array(Image.fromarray(rescaled).resize((resize_dim, resize_dim), Image.Resampling.LANCZOS))
+
+    # Performs discrete cosine transforms to compress the image information and takes the lowest frequency component
+    transform = dct(dct(im.T).T)[:HASH_SIZE, :HASH_SIZE]
+
+    # Encodes the transform as a bit array over the median value
+    diff = transform > np.median(transform)
+
+    # Pads the front of the bit array to a multiple of 8 with False
+    padded = np.full(int(np.ceil(diff.size / 8) * 8), False)
+    padded[-diff.size :] = diff.ravel()
+
+    # Converts the bit array to a hex string and strips leading 0s
+    hash_hex = np.packbits(padded).tobytes().hex().lstrip("0")
+    return hash_hex if hash_hex else "0"
+
+
+def xxhash(image: np.ndarray) -> str:
+    """
+    Performs a fast non-cryptographic hash using the xxhash algorithm
+    (xxhash.com) against the image as a flattened bytearray.  The hash
+    is returned as a hex string.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        An image as a numpy array
+
+    Returns
+    -------
+    str
+        The hex string hash of the image using the xxHash algorithm
+    """
+    return xxh.xxh3_64_hexdigest(image.ravel().tobytes())

dataeval/_internal/utils.py

@@ -0,0 +1,64 @@
+from collections import defaultdict
+from typing import Any, Dict, List
+
+from torch.utils.data import Dataset
+
+
+def read_dataset(dataset: Dataset) -> List[List[Any]]:
+    """
+    Extract information from a dataset at each index into a individual lists of each information position
+
+    Parameters
+    ----------
+    dataset : torch.utils.data.Dataset
+        Input dataset
+
+    Returns
+    -------
+    List[List[Any]]
+        All objects in individual lists based on return position from dataset
+
+    Warning
+    -------
+    No type checking is done between lists or data inside lists
+
+    See Also
+    --------
+    torch.utils.data.Dataset
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    >>> data = np.ones((10, 3, 3))
+    >>> labels = np.ones((10,))
+    >>> class ICDataset:
+    ...     def __init__(self, data, labels):
+    ...         self.data = data
+    ...         self.labels = labels
+
+    ...     def __getitem__(self, idx):
+    ...         return self.data[idx], self.labels[idx]
+
+    >>> ds = ICDataset(data, labels)
+
+    >>> result = read_dataset(ds)
+    >>> assert len(result) == 2
+    True
+    >>> assert result[0].shape == (10, 3, 3)  # 10 3x3 images
+    True
+    >>> assert result[1].shape == (10,)  # 10 labels
+    True
+    """
+
+    ddict: Dict[int, List] = defaultdict(list)
+
+    for data in dataset:
+        # Convert to tuple if single return (e.g. images only)
+        if not isinstance(data, tuple):
+            data = (data,)
+
+        for i, d in enumerate(data):
+            ddict[i].append(d)
+
+    return list(ddict.values())

dataeval/metrics/__init__.py

@@ -1,8 +1,27 @@
-from dataeval._internal.metrics.ber import BER
-from dataeval._internal.metrics.coverage import Coverage
-from dataeval._internal.metrics.divergence import Divergence
-from dataeval._internal.metrics.parity import Parity
+from typing import List
+
+__all__: List[str] = []
+
+from dataeval._internal.metrics.balance import balance, balance_classwise
+from dataeval._internal.metrics.ber import ber
+from dataeval._internal.metrics.coverage import coverage
+from dataeval._internal.metrics.divergence import divergence
+from dataeval._internal.metrics.diversity import diversity, diversity_classwise
+from dataeval._internal.metrics.parity import parity, parity_metadata
 from dataeval._internal.metrics.stats import ChannelStats, ImageStats
-from dataeval._internal.metrics.uap import UAP
+from dataeval._internal.metrics.uap import uap
 
-__all__ = ["BER", "Coverage", "Divergence", "Parity", "ChannelStats", "ImageStats", "UAP"]
+__all__ += [
+    "balance",
+    "balance_classwise",
+    "ber",
+    "coverage",
+    "divergence",
+    "diversity",
+    "diversity_classwise",
+    "parity",
+    "parity_metadata",
+    "ChannelStats",
+    "ImageStats",
+    "uap",
+]

dataeval/utils/__init__.py

@@ -0,0 +1,9 @@
+from importlib.util import find_spec
+from typing import List
+
+__all__: List[str] = []
+
+if find_spec("torch") is not None:  # pragma: no cover
+    from dataeval._internal.utils import read_dataset
+
+    __all__ += ["read_dataset"]

{dataeval-0.63.0.dist-info → dataeval-0.64.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.63.0
+Version: 0.64.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

dataeval-0.64.0.dist-info/RECORD

@@ -0,0 +1,60 @@
+dataeval/__init__.py,sha256=5krxzT8KNetiYE6ByxRgCTbHG7EHH-Fm9Fof6Ta3fUo,424
+dataeval/_internal/detectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/clusterer.py,sha256=6VklhUH8FvS2ATUAgb-7Q4XYHvQrDMZtkYeFnEznMfU,20328
+dataeval/_internal/detectors/drift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/drift/base.py,sha256=TRm-FcSM7Nv6nxqfyIzVZ_ysGdUmyqa5okNp7-gVZAY,9127
+dataeval/_internal/detectors/drift/cvm.py,sha256=cnAJZsBrvLsRaAUSgFvhX-ZNzE6V-s5irySvRW5-dOs,4025
+dataeval/_internal/detectors/drift/ks.py,sha256=Bfv-hVbghfGbRGEp_aGpkP5G2TnW6E5wIGdfx7nmZT0,4028
+dataeval/_internal/detectors/drift/mmd.py,sha256=RX_djx_rC9NQNdapTeNplP6x-4-JiMBYfIUNarakjNg,7056
+dataeval/_internal/detectors/drift/torch.py,sha256=NsQYfDVRcCGmU8k6oBG_aVzmML1zre-xUKBVK1W680o,10872
+dataeval/_internal/detectors/drift/uncertainty.py,sha256=jiqibgOmk37n2qBP-fEAE0Z-dUxyBRptQdT1V52yCxg,5323
+dataeval/_internal/detectors/duplicates.py,sha256=0m7E7EAvUHGfaVzQ_KgKbqDBW1jo8XrRd82uKRn1Gf0,2155
+dataeval/_internal/detectors/linter.py,sha256=Dmy5Rfuxf3jlGNK6DO6qo3puN_X1yh8N4svSem1vysE,5278
+dataeval/_internal/detectors/ood/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/ood/ae.py,sha256=FjqMucicFsDIKJMAOjWpKBohrPM4F1ubFLJk91GVqio,2681
+dataeval/_internal/detectors/ood/aegmm.py,sha256=Kf9R5q-hoRg6RUHlJG-2oo52ZKeQmJQbxG0kFtHh6zA,2416
+dataeval/_internal/detectors/ood/base.py,sha256=AfbNF_l8h1lDQ41SKlCHYWFjJ9YfAXuMMG3z9f973fM,6973
+dataeval/_internal/detectors/ood/llr.py,sha256=alel7l8hhvBNErAkDtcpjL1IzWRDNcIwWV1eX6KDjEI,10172
+dataeval/_internal/detectors/ood/vae.py,sha256=ntabTTTmPhJ18giZ7A64mxpJvTH9pIHmHPGGnu-gA8g,2987
+dataeval/_internal/detectors/ood/vaegmm.py,sha256=opBfFLuXEAIMa8E6scwf-GWbZbuXnsqXlXTbLN4MoYg,2861
+dataeval/_internal/flags.py,sha256=dRApeFkdSXFbYHSmvzgUP78zH8jUGtfzKFfLQtX0Q18,883
+dataeval/_internal/interop.py,sha256=wkNsLlmYYSHZqq0T204x8j9DIGIue9V2S0WQGPKQD6Y,1030
+dataeval/_internal/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/metrics/balance.py,sha256=i6m7qHSiY2TrKGneQtEpLWDPBkoqxCZsbVhoKnkwv1E,6421
+dataeval/_internal/metrics/base.py,sha256=TIreZWP1ynntqmDUu7-UED_Y3WpVrF28vGb6gZfqMIg,318
+dataeval/_internal/metrics/ber.py,sha256=9NxMCS78KsCLag2ZYJ-G16pgReSrkEfWm1hl-S5h_yU,4560
+dataeval/_internal/metrics/coverage.py,sha256=UKfvtAPIl043qCxfrLaWrEzyJGgrLdPM3AIvNi6wl8k,3744
+dataeval/_internal/metrics/divergence.py,sha256=JNQVRHt363iEZucQ3Fq3Re2PbA0I1dR7a0TJSkMRX64,3238
+dataeval/_internal/metrics/diversity.py,sha256=Lnc5QD6LcxLrFR9wHWg1FspD2KuKZTVht_MUzgN1EKs,6965
+dataeval/_internal/metrics/parity.py,sha256=6c0WpIoyM7hRsPELnyT2Qi_UYNcRVbXd_e7-i3-kuYI,11637
+dataeval/_internal/metrics/stats.py,sha256=T7VM4g5zhJIhfpw4XGDgleojhEqUI3NwsabYuzZ_g8w,12581
+dataeval/_internal/metrics/uap.py,sha256=9oMG_MhTYiNf2KCZ-fHlCUGBzsdXEVpvakHqVVMsM2s,1174
+dataeval/_internal/metrics/utils.py,sha256=f1-R0yCUb0r7Fb0H25o7MGRFrseX4WkJDdzgPuYMfoc,12302
+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=iK3Z9claesU_pJkRaiFJIZ9zKZg-Qj8ugzVYTTokDbE,6123
+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=rErnOfDFTd7e4brSGQ2Lr1x1kNjSEHdbOREOtUfIhIM,9975
+dataeval/_internal/models/tensorflow/gmm.py,sha256=wnqQKm3fURuvBROUd2fitCqzKViDo-g0-Djr3TBHZ3U,3640
+dataeval/_internal/models/tensorflow/losses.py,sha256=3y6tHm7PTQ7hmasJDwTXjdARjCUWycoXqSyXJ1uT2mM,3766
+dataeval/_internal/models/tensorflow/pixelcnn.py,sha256=B5cwB2IGPw-7b8klt82j_60g_IvqSiDELxvbiBYJtAo,48068
+dataeval/_internal/models/tensorflow/trainer.py,sha256=2KHtMRniVselCaDXeb8QEfX-wMRsPfT1xiG2gUQgelg,4090
+dataeval/_internal/models/tensorflow/utils.py,sha256=uK_fQ1JXUSVi0kgnhd9eRArlr36OzXUEdL4inJZCs-8,8579
+dataeval/_internal/utils.py,sha256=umvc_vN5c5IR0lz2F1U2YjA3VZloKTAEp9BQx8rSk6g,1561
+dataeval/_internal/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/workflows/sufficiency.py,sha256=QZQdhERVr3EmPA2sAFFudSDL4KLM0eAvYgV38jhjzaI,18374
+dataeval/detectors/__init__.py,sha256=I2e7YWb55RRlKQll85Z6KdN5wdBa53smn-_fcZIsCwA,1507
+dataeval/flags/__init__.py,sha256=1-HmwmtfPkHWwqXUjDwWko396qAKBeaSvqVsQZLrzD0,170
+dataeval/metrics/__init__.py,sha256=pY6E04nEkbSTQsWJ4rNFlkvcT3-aWSEO1dOctynSotg,787
+dataeval/models/__init__.py,sha256=onevPb5wznCggowBnVT0OUa8uBJXZCbrkFuek1UFvOs,293
+dataeval/models/tensorflow/__init__.py,sha256=A1XRxVGHefuvh_WpaKE1x95pRD1FecuFp66iuNPA_5U,424
+dataeval/models/torch/__init__.py,sha256=su7P9DF9LChlVCNHWG6d7s_yeIfWQbhCYWIkzJe0Qig,190
+dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/utils/__init__.py,sha256=bgUXeumTEspt2Q76YyEliGrnS-_incswY-pDexPdSCc,229
+dataeval/workflows/__init__.py,sha256=ObgS1cVYFRzFZWbNzGs2OcU02IVkJkAMHNnlnSNTMCE,208
+dataeval-0.64.0.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.64.0.dist-info/METADATA,sha256=HUYwlnRhnTLqcZQ9wDo0ZVpzpeak0CiQgKMKdg39MHE,4217
+dataeval-0.64.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+dataeval-0.64.0.dist-info/RECORD,,