dataeval 0.73.1__py3-none-any.whl → 0.74.0__py3-none-any.whl

dataeval/utils/torch/gmm.py

@@ -0,0 +1,98 @@
+"""
+Adapted for Pytorch from:
+
+Source code derived from Alibi-Detect 0.11.4
+https://github.com/SeldonIO/alibi-detect/tree/v0.11.4
+
+Original code Copyright (c) 2023 Seldon Technologies Ltd
+Licensed under Apache Software License (Apache 2.0)
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import torch
+
+from dataeval.utils.gmm import GaussianMixtureModelParams
+
+
+def gmm_params(z: torch.Tensor, gamma: torch.Tensor) -> GaussianMixtureModelParams[torch.Tensor]:
+    """
+    Compute parameters of Gaussian Mixture Model.
+
+    Parameters
+    ----------
+    z : torch.Tensor
+        Observations.
+    gamma : torch.Tensor
+        Mixture probabilities to derive mixture distribution weights from.
+
+    Returns
+    -------
+    GaussianMixtureModelParams(phi, mu, cov, L, log_det_cov)
+        The parameters used to calculate energy.
+    """
+
+    # compute gmm parameters phi, mu and cov
+    N = gamma.shape[0]  # nb of samples in batch
+    sum_gamma = torch.sum(gamma, 0)  # K
+    phi = sum_gamma / N  # K
+    # K x D (D = latent_dim)
+    mu = torch.sum(torch.unsqueeze(gamma, -1) * torch.unsqueeze(z, 1), 0) / torch.unsqueeze(sum_gamma, -1)
+    z_mu = torch.unsqueeze(z, 1) - torch.unsqueeze(mu, 0)  # N x K x D
+    z_mu_outer = torch.unsqueeze(z_mu, -1) * torch.unsqueeze(z_mu, -2)  # N x K x D x D
+
+    # K x D x D
+    cov = torch.sum(torch.unsqueeze(torch.unsqueeze(gamma, -1), -1) * z_mu_outer, 0) / torch.unsqueeze(
+        torch.unsqueeze(sum_gamma, -1), -1
+    )
+
+    # cholesky decomposition of covariance and determinant derivation
+    D = cov.shape[1]
+    eps = 1e-6
+    L = torch.linalg.cholesky(cov + torch.eye(D) * eps)  # K x D x D
+    log_det_cov = 2.0 * torch.sum(torch.log(torch.diagonal(L, dim1=-2, dim2=-1)), 1)  # K
+
+    return GaussianMixtureModelParams(phi, mu, cov, L, log_det_cov)
+
+
+def gmm_energy(
+    z: torch.Tensor,
+    params: GaussianMixtureModelParams[torch.Tensor],
+    return_mean: bool = True,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """
+    Compute sample energy from Gaussian Mixture Model.
+
+    Parameters
+    ----------
+    params : GaussianMixtureModelParams
+        The gaussian mixture model parameters.
+    return_mean : bool, default True
+        Take mean across all sample energies in a batch.
+
+    Returns
+    -------
+    sample_energy
+        The sample energy of the GMM.
+    cov_diag
+        The inverse sum of the diagonal components of the covariance matrix.
+    """
+    D = params.cov.shape[1]
+    z_mu = torch.unsqueeze(z, 1) - torch.unsqueeze(params.mu, 0)  # N x K x D
+    z_mu_T = torch.permute(z_mu, dims=[1, 2, 0])  # K x D x N
+    v = torch.linalg.solve_triangular(params.L, z_mu_T, upper=False)  # K x D x D
+
+    # rewrite sample energy in logsumexp format for numerical stability
+    logits = torch.log(torch.unsqueeze(params.phi, -1)) - 0.5 * (
+        torch.sum(torch.square(v), 1) + float(D) * np.log(2.0 * np.pi) + torch.unsqueeze(params.log_det_cov, -1)
+    )  # K x N
+    sample_energy = -torch.logsumexp(logits, 0)  # N
+
+    if return_mean:
+        sample_energy = torch.mean(sample_energy)
+
+    # inverse sum of variances
+    cov_diag = torch.sum(torch.divide(torch.tensor(1), torch.diagonal(params.cov, dim1=-2, dim2=-1)))
+
+    return sample_energy, cov_diag

dataeval/utils/torch/models.py

@@ -2,8 +2,10 @@ from __future__ import annotations
 
 __all__ = ["AriaAutoencoder", "Encoder", "Decoder"]
 
+import math
 from typing import Any
 
+import torch
 import torch.nn as nn
 
 
@@ -136,3 +138,193 @@ class Decoder(nn.Module):
             The reconstructed output tensor.
         """
         return self.decoder(x)
+
+
+class AE(nn.Module):
+    """
+    An autoencoder model with a separate encoder and decoder. Meant to replace the TensorFlow model called AE, which we
+      used as the core of an autoencoder-based OOD detector, i.e. as an argument to OOD_AE().
+
+    Parameters
+    ----------
+    input_shape : tuple[int, int, int]
+        Number of input channels, number of rows, number of columns.() Number of examples per batch will be inferred
+          at runtime.)
+    """
+
+    def __init__(self, input_shape: tuple[int, int, int]) -> None:
+        super().__init__()
+
+        input_dim = math.prod(input_shape)
+
+        # following is lifted from src/dataeval/utils/tensorflow/_internal/utils.py. It makes an odd staircase that is
+        #  basically proportional to the number of numbers in the image to the 0.8 power. '
+        encoding_dim = int(math.pow(2, int(input_dim.bit_length() * 0.8)))
+
+        self.encoder: Encoder_AE = Encoder_AE(input_shape, encoding_dim)
+
+        self.decoder: Decoder_AE = Decoder_AE(input_shape, encoding_dim, self.encoder.post_op_shape)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        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: torch.Tensor) -> torch.Tensor:
+        """
+        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_AE(nn.Module):
+    """
+    A simple encoder to be used in an autoencoder model.
+
+    This is the encoder used to replicate AE, which was a TF function. It consists of a CNN followed by a fully
+      connected layer.
+
+    Parameters
+    ----------
+    channels : int
+        Number of input channels
+
+    input_shape : tuple[int, int, int]
+        number of channels, number of rows, number of columns in input images.
+
+    encoding_dim : the size of the 1D array that emerges from the fully connected layer.
+
+    """
+
+    def __init__(
+        self,
+        input_shape: tuple[int, int, int],
+        encoding_dim: int,
+    ) -> None:
+        super().__init__()
+
+        channels = input_shape[0]
+        nc_in, nc_mid, nc_done = 256, 128, 64
+
+        conv_in = nn.Conv2d(channels, nc_in, 2, stride=1, padding=1)
+        conv_mid = nn.Conv2d(nc_in, nc_mid, 2, stride=1, padding=1)
+        conv_done = nn.Conv2d(nc_mid, nc_done, 2, stride=1)
+
+        self.encoding_ops: nn.Sequential = nn.Sequential(
+            conv_in,
+            nn.LeakyReLU(),
+            nn.MaxPool2d(2),
+            conv_mid,
+            nn.LeakyReLU(),
+            nn.MaxPool2d(2),
+            conv_done,
+        )
+
+        ny, nx = input_shape[1:]
+        self.post_op_shape: tuple[int, int, int] = (nc_done, ny // 4 - 1, nx // 4 - 1)
+        self.flatcon: int = math.prod(self.post_op_shape)
+        self.flatten: nn.Sequential = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(
+                self.flatcon,
+                encoding_dim,
+            ),
+        )
+
+    def forward(self, x: Any) -> Any:
+        """
+        Perform a forward pass through the AE_torch encoder.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor
+
+        Returns
+        -------
+        torch.Tensor
+            The encoded representation of the input tensor.
+        """
+        x = self.encoding_ops(x)
+
+        x = self.flatten(x)
+
+        return x
+
+
+class Decoder_AE(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,
+        input_shape: tuple[int, int, int],
+        encoding_dim: int,
+        post_op_shape: tuple[int, int, int],
+    ) -> None:
+        super().__init__()
+
+        self.post_op_shape = post_op_shape
+        self.input_shape = input_shape  # need to store this for use in forward().
+        channels = input_shape[0]
+
+        self.input: nn.Linear = nn.Linear(encoding_dim, math.prod(post_op_shape))
+
+        self.decoder: nn.Sequential = nn.Sequential(
+            nn.ConvTranspose2d(64, 128, 2, stride=1),
+            nn.LeakyReLU(),
+            nn.ConvTranspose2d(128, 256, 2, stride=2),
+            nn.LeakyReLU(),
+            nn.ConvTranspose2d(256, channels, 2, stride=2),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Perform a forward pass through the decoder.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            The encoded tensor.
+
+        Returns
+        -------
+        torch.Tensor
+            The reconstructed output tensor.
+        """
+        x = self.input(x)
+        x = x.reshape((-1, *self.post_op_shape))
+        x = self.decoder(x)
+        x = x.reshape((-1, *self.input_shape))
+        return x

dataeval/utils/torch/trainer.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
-__all__ = ["AETrainer"]
-
-from typing import Any
+from typing import Any, Callable
 
 import torch
 import torch.nn as nn
+from numpy.typing import NDArray
 from torch.optim import Adam
-from torch.utils.data import DataLoader, Dataset
+from torch.utils.data import DataLoader, Dataset, TensorDataset
+from tqdm import tqdm
 
-torch.manual_seed(0)
+__all__ = ["AETrainer", "trainer"]
 
 
 def get_images_from_batch(batch: Any) -> Any:
@@ -176,3 +176,82 @@ class AETrainer:
             encodings = torch.vstack((encodings, embeddings)) if len(encodings) else embeddings
 
         return encodings
+
+
+def trainer(
+    model: torch.nn.Module,
+    x_train: NDArray[Any],
+    y_train: NDArray[Any] | None,
+    loss_fn: Callable[..., torch.Tensor | torch.nn.Module] | None,
+    optimizer: torch.optim.Optimizer | None,
+    preprocess_fn: Callable[[torch.Tensor], torch.Tensor] | None,
+    epochs: int,
+    batch_size: int,
+    device: torch.device,
+    verbose: bool,
+) -> None:
+    """
+    Train Pytorch model.
+
+    Parameters
+    ----------
+    model
+        Model to train.
+    loss_fn
+        Loss function used for training.
+    x_train
+        Training data.
+    y_train
+        Training labels.
+    optimizer
+        Optimizer used for training.
+    preprocess_fn
+        Preprocessing function applied to each training batch.
+    epochs
+        Number of training epochs.
+    reg_loss_fn
+        Allows an additional regularisation term to be defined as reg_loss_fn(model)
+    batch_size
+        Batch size used for training.
+    buffer_size
+        Maximum number of elements that will be buffered when prefetching.
+    verbose
+        Whether to print training progress.
+    """
+    if optimizer is None:
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+
+    if y_train is None:
+        dataset = TensorDataset(torch.from_numpy(x_train).to(torch.float32))
+
+    else:
+        dataset = TensorDataset(
+            torch.from_numpy(x_train).to(torch.float32), torch.from_numpy(y_train).to(torch.float32)
+        )
+
+    loader = DataLoader(dataset=dataset)
+
+    model = model.to(device)
+
+    # iterate over epochs
+    loss = torch.nan
+    disable_tqdm = not verbose
+    for epoch in (pbar := tqdm(range(epochs), disable=disable_tqdm)):
+        epoch_loss = loss
+        for step, data in enumerate(loader):
+            if step % 250 == 0:
+                pbar.set_description(f"Epoch: {epoch} ({epoch_loss:.3f}), loss: {loss:.3f}")
+
+            x, y = [d.to(device) for d in data] if len(data) > 1 else (data[0].to(device), None)
+
+            if isinstance(preprocess_fn, Callable):
+                x = preprocess_fn(x)
+
+            y_hat = model(x)
+            y = x if y is None else y
+
+            loss = loss_fn(y, y_hat)  # type: ignore
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()

dataeval/utils/torch/utils.py

@@ -3,8 +3,12 @@ from __future__ import annotations
 __all__ = ["read_dataset"]
 
 from collections import defaultdict
-from typing import Any
+from functools import partial
+from typing import Any, Callable
 
+import numpy as np
+import torch
+from numpy.typing import NDArray
 from torch.utils.data import Dataset
 
 
@@ -61,3 +65,105 @@ def read_dataset(dataset: Dataset[Any]) -> list[list[Any]]:
             ddict[i].append(d)
 
     return list(ddict.values())
+
+
+def get_device(device: str | torch.device | None = None) -> torch.device:
+    """
+    Instantiates a PyTorch device object.
+
+    Parameters
+    ----------
+    device : str | torch.device | None, default None
+        Either ``None``, a str ('gpu' or 'cpu') indicating the device to choose, or an
+        already instantiated device object. If ``None``, the GPU is selected if it is
+        detected, otherwise the CPU is used as a fallback.
+
+    Returns
+    -------
+    The instantiated device object.
+    """
+    if isinstance(device, torch.device):  # Already a torch device
+        return device
+    else:  # Instantiate device
+        if device is None or device.lower() in ["gpu", "cuda"]:
+            torch_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        else:
+            torch_device = torch.device("cpu")
+    return torch_device
+
+
+def predict_batch(
+    x: NDArray[Any] | torch.Tensor,
+    model: Callable | torch.nn.Module | torch.nn.Sequential,
+    device: torch.device | None = None,
+    batch_size: int = int(1e10),
+    preprocess_fn: Callable | None = None,
+    dtype: type[np.generic] | torch.dtype = np.float32,
+) -> NDArray[Any] | torch.Tensor | tuple[Any, ...]:
+    """
+    Make batch predictions on a model.
+
+    Parameters
+    ----------
+    x : np.ndarray | torch.Tensor
+        Batch of instances.
+    model : Callable | nn.Module | nn.Sequential
+        PyTorch model.
+    device : torch.device | None, default None
+        Device type used. The default None tries to use the GPU and falls back on CPU.
+        Can be specified by passing either torch.device('cuda') or torch.device('cpu').
+    batch_size : int, default 1e10
+        Batch size used during prediction.
+    preprocess_fn : Callable | None, default None
+        Optional preprocessing function for each batch.
+    dtype : np.dtype | torch.dtype, default np.float32
+        Model output type, either a :term:`NumPy` or torch dtype, e.g. np.float32 or torch.float32.
+
+    Returns
+    -------
+    NDArray | torch.Tensor | tuple
+        Numpy array, torch tensor or tuples of those with model outputs.
+    """
+    device = get_device(device)
+    if isinstance(x, np.ndarray):
+        x = torch.from_numpy(x).to(device)
+    n = len(x)
+    n_minibatch = int(np.ceil(n / batch_size))
+    return_np = not isinstance(dtype, torch.dtype)
+    preds = []
+    with torch.no_grad():
+        for i in range(n_minibatch):
+            istart, istop = i * batch_size, min((i + 1) * batch_size, n)
+            x_batch = x[istart:istop]
+            if isinstance(preprocess_fn, Callable):
+                x_batch = preprocess_fn(x_batch)
+
+            preds_tmp = model(x_batch.to(torch.float32).to(device))
+            if isinstance(preds_tmp, (list, tuple)):
+                if len(preds) == 0:  # init tuple with lists to store predictions
+                    preds = tuple([] for _ in range(len(preds_tmp)))
+                for j, p in enumerate(preds_tmp):
+                    if isinstance(p, torch.Tensor):
+                        p = p.cpu()
+                    preds[j].append(p if not return_np or isinstance(p, np.ndarray) else p.numpy())
+            elif isinstance(preds_tmp, (np.ndarray, torch.Tensor)):
+                if isinstance(preds_tmp, torch.Tensor):
+                    preds_tmp = preds_tmp.cpu()
+                if isinstance(preds, tuple):
+                    preds = list(preds)
+                preds.append(
+                    preds_tmp
+                    if not return_np or isinstance(preds_tmp, np.ndarray)  # type: ignore
+                    else preds_tmp.numpy()
+                )
+            else:
+                raise TypeError(
+                    f"Model output type {type(preds_tmp)} not supported. The model \
+                    output type needs to be one of list, tuple, NDArray or \
+                    torch.Tensor."
+                )
+    concat = partial(np.concatenate, axis=0) if return_np else partial(torch.cat, dim=0)
+    out: tuple | np.ndarray | torch.Tensor = (
+        tuple(concat(p) for p in preds) if isinstance(preds, tuple) else concat(preds)  # type: ignore
+    )
+    return out

{dataeval-0.73.1.dist-info → dataeval-0.74.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.73.1
+Version: 0.74.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
@@ -23,7 +23,6 @@ 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)

{dataeval-0.73.1.dist-info → dataeval-0.74.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-dataeval/__init__.py,sha256=SdXxst_wmjSoQkYzGdR-JXSV-iJmKynWsiwkpmGDDPE,601
+dataeval/__init__.py,sha256=bwKFegCsdGFydqDvza_wSvJgRGr-0pQ59UpcePQ1mNs,601
 dataeval/detectors/__init__.py,sha256=mwAyY54Hvp6N4D57cde3_besOinK8jVF43k0Mw4XZi8,363
 dataeval/detectors/drift/__init__.py,sha256=BSXm21y7cAawHep-ZldCJ5HOvzYjPzYGKGrmoEs3i0E,737
 dataeval/detectors/drift/base.py,sha256=xwI6C-PEH0ZjpSqP6No6WDZp42DnE16OHi_mXe2JSvI,14499
 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/torch.py,sha256=igEQ2DV9JmcpTdUKCOHBi5LxtoNeCAslJS2Ldulg1hw,7585
 dataeval/detectors/drift/uncertainty.py,sha256=Xz2yzJjtJfw1vLag234jwRvaa_HK36nMajGx8bQaNRs,5322
 dataeval/detectors/drift/updates.py,sha256=UJ0z5hlunRi7twnkLABfdJG3tT2EqX4y9IGx8_USYvo,1780
 dataeval/detectors/linters/__init__.py,sha256=BvpaB1RUpkEhhXk3Mqi5NYoOcJKZRFSBOJCmQOIfYRU,483
@@ -13,24 +13,28 @@ dataeval/detectors/linters/clusterer.py,sha256=sau5A9YcQ6VDjbZGOIaCaRHW_63opaA31
 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=yzvCszJ0KrX9Eu4S_ykC_jwC0uYGPjxY3Vyx9fU3zQk,641
-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/__init__.py,sha256=XckkWVhYbbg9iWVsCPEQN-t7FFSt2a4jmCwAAempkM4,793
+dataeval/detectors/ood/ae.py,sha256=km7buF8LbMmwsyfu1xMOI5CJDnQX1x8_-c04zTGMXRI,2389
+dataeval/detectors/ood/ae_torch.py,sha256=pO9w5221bXR9lEBkE7oakXeE7PXUUR--xcTpmHvOCSk,2142
+dataeval/detectors/ood/aegmm.py,sha256=CI2HEkRMJSEFTVLZEhz4CStkaS7i66yTPtnbkbCqTes,2084
+dataeval/detectors/ood/base.py,sha256=u9S7z7zJ8wuPqrtn63ePdAa8DdI579EbCy8Tn0M3XI8,6983
+dataeval/detectors/ood/base_tf.py,sha256=ppj8rAjXjHEab2oGfQO2olXyN4aGZH8_QHIEghOoeFQ,3297
+dataeval/detectors/ood/base_torch.py,sha256=yFbSfQsBMwZeVf8mrixmkZYBGChhV5oAHtkgzWnMzsA,3405
+dataeval/detectors/ood/llr.py,sha256=IrOam-kqUU4bftolR3MvhcEq-NNj2euyI-lYvMuXYn8,10645
+dataeval/detectors/ood/metadata_ks_compare.py,sha256=Ka6MABdJH5ZlHF66mENpSOLCE8H9xdQ_wWNwMYVO_Q0,5352
 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/detectors/ood/vae.py,sha256=yjK4p-XYhnH3wWPiwAclb3eyZE0wpTazLLuKhzurcWY,3203
+dataeval/detectors/ood/vaegmm.py,sha256=FhPJBzs7wyEPQUUMxOMsdPpCdAZwN82vztjt05cSrds,2459
 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=n4SM2Z46dzps_SPgHV8Q69msZ507AP9neebsQ45cNxc,9170
-dataeval/metrics/bias/coverage.py,sha256=7nDufCmQwZ8QG3Me5UiY0N5YoTByjcwK2zOYuMOHkJ0,4540
-dataeval/metrics/bias/diversity.py,sha256=BKGpyJ1K3S5RS_VxXN5DusB2gfRidOksL7r0L3SFa0Y,11018
-dataeval/metrics/bias/metadata.py,sha256=tPvyfFkfqWBFMX6v8i1ZLAA3DZfF6M4O7qXDdKzhQ6g,15040
-dataeval/metrics/bias/parity.py,sha256=_-WdKRWPlKHLNbjq-4mIhVdR1MI3NEabbMWblAmmVRM,17145
+dataeval/metrics/bias/__init__.py,sha256=dYiPHenS8J7pgRMMW2jNkTBmTbPoYTxT04fZu9PFats,747
+dataeval/metrics/bias/balance.py,sha256=BH644D_xN7rRUdJMNgVcGHWq3TTnehYjSBhSMhmAFyY,9154
+dataeval/metrics/bias/coverage.py,sha256=LBrNG6GIrvMJjZckr72heyCTMCke_p5BT8NJWi-noEY,4546
+dataeval/metrics/bias/diversity.py,sha256=__7I934sVoymXqgHoneXglJhIU5iHRIuklFwC2ks84w,7719
+dataeval/metrics/bias/metadata_preprocessing.py,sha256=DbtzsiHjkCxs411okb6s2B_H2TqfvwJ4xyt9m_OsqJo,12266
+dataeval/metrics/bias/metadata_utils.py,sha256=HmTjlRRTdM9566oKUDDdVMJ8luss4DYykFOiS2FQzhM,6558
+dataeval/metrics/bias/parity.py,sha256=lLa2zN0AK-zWzlXmvLCbMxTZFodAKLs8wSGl_YZdNFo,12765
 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
@@ -47,13 +51,14 @@ dataeval/metrics/stats/visualstats.py,sha256=y0xIvst7epcajk8vz2jngiAiz0T7DZC-M97
 dataeval/output.py,sha256=jWXXNxFNBEaY1rN7Z-6LZl6bQT-I7z_wqr91Rhrdt_0,3061
 dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataeval/utils/__init__.py,sha256=FZLWDA7nMbHOcdg3701cVJpQmUp1Wxxk8h_qIrUQQjY,713
+dataeval/utils/gmm.py,sha256=YuLsJKsVWgH_wHr1u_hSRH5Yeexdj8exht8h99L7bLo,561
 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/metadata.py,sha256=0A--iru0zEmi044mKz5P35q69KrI30yoiRSlvs7TSdQ,9418
 dataeval/utils/shared.py,sha256=xvF3VLfyheVwJtdtDrneOobkKf7t-JTmf_w91FWXmqo,3616
 dataeval/utils/split_dataset.py,sha256=Ot1ZJhbIhVfcShYXF9MkWXak5odBXyuBdRh-noXh-MI,19555
 dataeval/utils/tensorflow/__init__.py,sha256=l4OjIA75JJXeNWDCkST1xtDMVYsw97lZ-9JXFBlyuYg,539
-dataeval/utils/tensorflow/_internal/gmm.py,sha256=RIFx8asEpi2kMf8JVzq9M3aAvNe9fjpJPf3BzWE-aeE,3787
+dataeval/utils/tensorflow/_internal/gmm.py,sha256=XvjhWM3ppP-R9nCZGs80WphmQR3u7wb-VtoCQYeXZlQ,3404
 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
@@ -62,12 +67,13 @@ dataeval/utils/tensorflow/loss/__init__.py,sha256=Q-66vt91Oe1ByYfo28tW32zXDq2MqQ
 dataeval/utils/torch/__init__.py,sha256=lpkqfgyARUxgrV94cZESQv8PIP2p-UnwItZ_wIr0XzQ,675
 dataeval/utils/torch/blocks.py,sha256=HVhBTMMD5NA4qheMUgyol1KWiKZDIuc8k5j4RcMKmhk,1466
 dataeval/utils/torch/datasets.py,sha256=10elNgLuH_FDX_CHE3y2Z215JN4-PQovQm5brcIJOeM,15021
-dataeval/utils/torch/models.py,sha256=0BsXmLK8W1OZ8nnEGb1f9LzIeCgtevQC37dvKS1v1vA,3236
-dataeval/utils/torch/trainer.py,sha256=EraOKiXxiMNiycStZNMR5yRz3ehgp87d9ewR9a9dV4w,5559
-dataeval/utils/torch/utils.py,sha256=FI4LJ6DvXFQJVff8fxSCP7LRkp8H9BIUgYX0kk7_Cuo,1537
+dataeval/utils/torch/gmm.py,sha256=VbLlUQohwToApT493_tjQBWy2UM5R-3ppS9Dp-eP7BA,3240
+dataeval/utils/torch/models.py,sha256=sdGeo7a8vshCTGA4lYyVxxb_aDWUlxdtIVxrddS-_ls,8542
+dataeval/utils/torch/trainer.py,sha256=8BEXr6xtk-CHJTcNxOBnWgkFWfJUAiBy28cEdBhLMRU,7883
+dataeval/utils/torch/utils.py,sha256=nWRcT6z6DbFVrL1RyxCOX3DPoCrv9G0B-VI_9LdGCQQ,5784
 dataeval/workflows/__init__.py,sha256=ef1MiVL5IuhlDXXbwsiAfafhnr7tD3TXF9GRusy9_O8,290
 dataeval/workflows/sufficiency.py,sha256=1jSYhH9i4oesmJYs5PZvWS1LGXf8ekOgNhpFtMPLPXk,18552
-dataeval-0.73.1.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
-dataeval-0.73.1.dist-info/METADATA,sha256=C7xThIWgHNoZEdSiGEZr3VgDLRSzeT3TkFbn4nQgrK0,4714
-dataeval-0.73.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-dataeval-0.73.1.dist-info/RECORD,,
+dataeval-0.74.0.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.74.0.dist-info/METADATA,sha256=OPnkHZTm8R1LHqLxcSnOHjqj5GuHmjUVI3dddTVsBAc,4680
+dataeval-0.74.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dataeval-0.74.0.dist-info/RECORD,,