dataeval 0.88.1__py3-none-any.whl → 0.89.0__py3-none-any.whl

dataeval/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.88.1'
-__version_tuple__ = version_tuple = (0, 88, 1)
+__version__ = version = '0.89.0'
+__version_tuple__ = version_tuple = (0, 89, 0)

dataeval/data/_embeddings.py

@@ -5,7 +5,7 @@ __all__ = []
 import logging
 import math
 import os
-from collections.abc import Iterator, Sequence
+from collections.abc import Iterable, Iterator, Sequence
 from pathlib import Path
 from typing import Any, cast
 
@@ -80,7 +80,7 @@ class Embeddings:
         # Technically more permissive than ImageClassificationDataset or ObjectDetectionDataset
         dataset: Dataset[tuple[ArrayLike, Any, Any]] | Dataset[ArrayLike],
         batch_size: int,
-        transforms: Transform[torch.Tensor] | Sequence[Transform[torch.Tensor]] | None = None,
+        transforms: Transform[torch.Tensor] | Iterable[Transform[torch.Tensor]] | None = None,
         model: torch.nn.Module | None = None,
         device: DeviceLike | None = None,
         cache: Path | str | bool = False,

dataeval/data/_metadata.py

@@ -15,6 +15,7 @@ from tqdm.auto import tqdm
 from dataeval.typing import (
     AnnotatedDataset,
     Array,
+    DatumMetadata,
     ObjectDetectionTarget,
 )
 from dataeval.utils._array import as_numpy
@@ -76,7 +77,7 @@ class Metadata:
 
     def __init__(
         self,
-        dataset: AnnotatedDataset[tuple[Any, Any, Mapping[str, Any]]],
+        dataset: AnnotatedDataset[tuple[Any, Any, DatumMetadata]],
         *,
         continuous_factor_bins: Mapping[str, int | Sequence[float]] | None = None,
         auto_bin_method: Literal["uniform_width", "uniform_count", "clusters"] = "uniform_width",

dataeval/detectors/drift/_base.py

@@ -55,6 +55,42 @@ def update_strategy(fn: Callable[..., R]) -> Callable[..., R]:
 
 
 class BaseDrift:
+    """Base class for drift detection algorithms.
+
+    Provides common functionality for drift detectors including reference data
+    management, encoding of input data, and statistical correction methods.
+    Subclasses implement specific drift detection algorithms.
+
+    Parameters
+    ----------
+    data : Embeddings or Array
+        Reference dataset used as baseline for drift detection.
+        Can be image embeddings or raw arrays.
+    p_val : float, default 0.05
+        Significance threshold for drift detection, between 0 and 1.
+        Default 0.05 limits false drift alerts to 5% when no drift exists (Type I error rate).
+    update_strategy : UpdateStrategy or None, default None
+        Strategy for updating reference data when new data arrives.
+        When None, reference data remains fixed throughout detection.
+        Default None maintains stable baseline for consistent comparison.
+    correction : {"bonferroni", "fdr"}, default "bonferroni"
+        Multiple testing correction method for multivariate drift detection.
+        "bonferroni" provides conservative family-wise error control.
+        "fdr" (False Discovery Rate) offers less conservative control.
+        Default "bonferroni" minimizes false positive drift detections.
+
+    Attributes
+    ----------
+    p_val : float
+        Significance threshold for statistical tests.
+    update_strategy : UpdateStrategy or None
+        Reference data update strategy.
+    correction : {"bonferroni", "fdr"}
+        Multiple testing correction method.
+    n : int
+        Number of samples in the reference dataset.
+    """
+
     p_val: float
     update_strategy: UpdateStrategy | None
     correction: Literal["bonferroni", "fdr"]
@@ -83,19 +119,43 @@ class BaseDrift:
 
     @property
     def x_ref(self) -> NDArray[np.float32]:
-        """
-        Retrieve the reference data of the drift detector.
+        """Reference data for drift detection.
+
+        Lazily encodes the reference dataset on first access.
+        Data is flattened and converted to 32-bit floating point for
+        consistent numerical processing across different input types.
 
         Returns
         -------
         NDArray[np.float32]
-            The reference data as a 32-bit floating point numpy array.
+            Reference data as flattened 32-bit floating point array.
+            Shape is (n_samples, n_features_flattened).
+
+        Notes
+        -----
+        Data is cached after first access to avoid repeated encoding overhead.
         """
         if self._x_ref is None:
             self._x_ref = self._encode(self._data)
         return self._x_ref
 
     def _encode(self, data: Embeddings | Array) -> NDArray[np.float32]:
+        """
+        Encode input data to consistent numpy format.
+
+        Handles different input types (Embeddings, Arrays) and converts
+        them to flattened 32-bit floating point arrays for drift detection.
+
+        Parameters
+        ----------
+        data : Embeddings or Array
+            Input data to encode.
+
+        Returns
+        -------
+        NDArray[np.float32]
+            Encoded data as flattened 32-bit floating point array.
+        """
         array = (
             data.to_numpy().astype(np.float32)
             if isinstance(data, Embeddings)
@@ -107,6 +167,46 @@ class BaseDrift:
 
 
 class BaseDriftUnivariate(BaseDrift):
+    """
+    Base class for univariate drift detection algorithms.
+
+    Extends BaseDrift with feature-wise drift detection capabilities.
+    Applies statistical tests independently to each feature (pixel) and
+    uses multiple testing correction to control false discovery rates.
+
+    Parameters
+    ----------
+    data : Embeddings or Array
+        Reference dataset used as baseline for drift detection.
+    p_val : float, default 0.05
+        Significance threshold for drift detection, between 0 and 1.
+        Default 0.05 limits false drift alerts to 5% when no drift exists (Type I error rate).
+    update_strategy : UpdateStrategy or None, default None
+        Strategy for updating reference data when new data arrives.
+        When None, reference data remains fixed throughout detection.
+        Default None maintains stable baseline for consistent comparison.
+    correction : {"bonferroni", "fdr"}, default "bonferroni"
+        Multiple testing correction method for controlling false positives
+        across multiple features. "bonferroni" divides significance level
+        by number of features. "fdr" uses Benjamini-Hochberg procedure.
+        Default "bonferroni" provides conservative family-wise error control.
+    n_features : int or None, default None
+        Number of features to analyze. When None, automatically inferred
+        from the first sample's flattened shape. Default None enables
+        automatic feature detection for flexible input handling.
+
+    Attributes
+    ----------
+    p_val : float
+        Significance threshold for statistical tests.
+    update_strategy : UpdateStrategy or None
+        Reference data update strategy.
+    correction : {"bonferroni", "fdr"}
+        Multiple testing correction method.
+    n : int
+        Number of samples in the reference dataset.
+    """
+
     def __init__(
         self,
         data: Embeddings | Array,
@@ -121,16 +221,22 @@ class BaseDriftUnivariate(BaseDrift):
 
     @property
     def n_features(self) -> int:
-        """
-        Get the number of features in the reference data.
+        """Number of features in the reference data.
 
-        If the number of features is not provided during initialization, it will be inferred
-        from the reference data (``x_ref``).
+        Lazily computes the number of features from the first data sample
+        if not provided during initialization. Features correspond to the
+        flattened dimensionality of the input data (e.g., pixels for images).
 
         Returns
         -------
         int
-            Number of features in the reference data.
+            Number of features (flattened dimensions) in the reference data.
+            Always > 0 for valid datasets.
+
+        Notes
+        -----
+        For image data, this equals C x H x W.
+        Computed once and cached for efficiency.
         """
         # lazy process n_features as needed
         if self._n_features is None:
@@ -139,18 +245,27 @@ class BaseDriftUnivariate(BaseDrift):
         return self._n_features
 
     def score(self, data: Embeddings | Array) -> tuple[NDArray[np.float32], NDArray[np.float32]]:
-        """
-        Calculates p-values and test statistics per feature.
+        """Calculate feature-wise p-values and test statistics.
+
+        Applies the detector's statistical test independently to each feature,
+        comparing the distribution of each feature between reference and test data.
 
         Parameters
         ----------
         data : Embeddings or Array
-            Batch of instances to score.
+            Test dataset to compare against reference data.
 
         Returns
         -------
-        tuple[NDArray, NDArray]
-            Feature level p-values and test statistics
+        tuple[NDArray[np.float32], NDArray[np.float32]]
+            First array contains p-values for each feature (all between 0 and 1).
+            Second array contains test statistics for each feature (all >= 0).
+            Both arrays have shape (n_features,).
+
+        Notes
+        -----
+        Lower p-values indicate stronger evidence of drift for that feature.
+        Higher test statistics indicate greater distributional differences.
         """
         x_np = self._encode(data)
         p_val = np.zeros(self.n_features, dtype=np.float32)
@@ -164,22 +279,29 @@ class BaseDriftUnivariate(BaseDrift):
 
     def _apply_correction(self, p_vals: NDArray[np.float32]) -> tuple[bool, float]:
         """
-        Apply the specified correction method (Bonferroni or FDR) to the p-values.
+        Apply multiple testing correction to feature-wise p-values.
 
-        If the correction method is Bonferroni, the threshold for detecting :term:`drift<Drift>`
-        is divided by the number of features. For FDR, the correction is applied
-        using the Benjamini-Hochberg procedure.
+        Corrects for multiple comparisons across features to control
+        false positive rates. Bonferroni correction divides the significance
+        threshold by the number of features. FDR correction uses the
+        Benjamini-Hochberg procedure for less conservative control.
 
         Parameters
         ----------
-        p_vals : NDArray
-            Array of p-values from the univariate tests for each feature.
+        p_vals : NDArray[np.float32]
+            Array of p-values from univariate tests for each feature.
+            All values should be between 0 and 1.
 
         Returns
         -------
         tuple[bool, float]
-            A tuple containing a boolean indicating if drift was detected and the
-            threshold after correction.
+            Boolean indicating whether drift was detected after correction.
+            Float is the effective threshold used for detection.
+
+        Notes
+        -----
+        Bonferroni correction: threshold = p_val / n_features
+        FDR correction: Uses Benjamini-Hochberg step-up procedure
         """
         if self.correction == "bonferroni":
             threshold = self.p_val / self.n_features
@@ -201,21 +323,24 @@ class BaseDriftUnivariate(BaseDrift):
     @set_metadata
     @update_strategy
     def predict(self, data: Embeddings | Array) -> DriftOutput:
-        """
-        Predict whether a batch of data has drifted from the reference data and update
-        reference data using specified update strategy.
+        """Predict drift and update reference data using specified strategy.
+
+        Performs feature-wise drift detection, applies multiple testing
+        correction, and optionally updates the reference dataset based
+        on the configured update strategy.
 
         Parameters
         ----------
         data : Embeddings or Array
-            Batch of instances to predict drift on.
+            Test dataset to analyze for drift against reference data.
 
         Returns
         -------
         DriftOutput
-            Dictionary containing the :term:`drift<Drift>` prediction and optionally the feature level
-            p-values, threshold after multivariate correction if needed and test :term:`statistics<Statistics>`.
+            Complete drift detection results including overall :term:`drift<Drift>` prediction,
+            corrected thresholds, feature-level analysis, and summary :term:`statistics<Statistics>`.
         """
+
         # compute drift scores
         p_vals, dist = self.score(data)
 

dataeval/detectors/drift/_cvm.py

@@ -22,47 +22,66 @@ from dataeval.typing import Array
 
 
 class DriftCVM(BaseDriftUnivariate):
-    """
-    :term:`Drift` detector employing the :term:`Cramér-von Mises (CVM) Drift Detection` test.
+    """:term:`Drift` detector using the :term:`Cramér-von Mises (CVM) Test`.
+
+    Detects distributional changes in continuous data by comparing empirical
+    cumulative distribution functions between reference and test datasets.
+    For multivariate data, applies CVM test independently to each feature
+    and aggregates results using either the Bonferroni or
+    :term:`False Discovery Rate (FDR)` correction.
 
-    The CVM test detects changes in the distribution of continuous
-    univariate data. For multivariate data, a separate CVM test is applied to each
-    feature, and the obtained p-values are aggregated via the Bonferroni or
-    :term:`False Discovery Rate (FDR)` corrections.
+    The CVM test is particularly effective at detecting subtle
+    distributional shifts throughout the entire domain, providing higher
+    power than Kolmogorov-Smirnov for many types of drift.
 
     Parameters
     ----------
     data : Embeddings or Array
-        Data used as reference distribution.
-    p_val : float or None, default 0.05
-        :term:`p-value<P-Value>` used for significance of the statistical test for each feature.
-        If the FDR correction method is used, this corresponds to the acceptable
-        q-value.
+        Reference dataset used as baseline distribution for drift detection.
+        Should represent the expected data distribution.
+    p_val : float, default 0.05
+        Significance threshold for drift detection, between 0 and 1.
+        Default 0.05 limits false drift alerts to 5% when no drift exists (Type I error rate).
     update_strategy : UpdateStrategy or None, default None
-        Reference data can optionally be updated using an UpdateStrategy class. Update
-        using the last n instances seen by the detector with LastSeenUpdateStrategy
-        or via reservoir sampling with ReservoirSamplingUpdateStrategy.
+        Strategy for updating reference data when new data arrives.
+        When None, reference data remains fixed throughout detection.
     correction : "bonferroni" or "fdr", default "bonferroni"
-        Correction type for multivariate data. Either 'bonferroni' or 'fdr' (False
-        Discovery Rate).
+        Multiple testing correction method for multivariate drift detection.
+        "bonferroni" provides conservative family-wise error control by
+        dividing significance threshold by number of features.
+        "fdr" uses Benjamini-Hochberg procedure for less conservative control.
+        Default "bonferroni" minimizes false positive drift detections.
     n_features : int or None, default None
-        Number of features used in the univariate drift tests. If not provided, it will
-        be inferred from the data.
-
+        Number of features to analyze in univariate tests.
+        When None, automatically inferred from the flattened shape of first data sample.
 
     Example
     -------
+    Basic drift detection with image embeddings
+
     >>> from dataeval.data import Embeddings
+    >>> train_emb = Embeddings(train_images, model=encoder, batch_size=64)
+    >>> drift_detector = DriftCVM(train_emb)
 
-    Use Embeddings to encode images before testing for drift
+    Test incoming images for distributional drift
 
-    >>> train_emb = Embeddings(train_images, model=encoder, batch_size=64)
-    >>> drift = DriftCVM(train_emb)
+    >>> result = drift_detector.predict(test_images)
+    >>> print(f"Drift detected: {result.drifted}")
+    Drift detected: True
+
+    >>> print(f"Mean CVM statistic: {result.distance:.4f}")
+    Mean CVM statistic: 24.1325
+
+    Using different correction methods
+
+    >>> drift_fdr = DriftCVM(train_emb, correction="fdr", p_val=0.1)
+    >>> result = drift_fdr.predict(test_images)
 
-    Test incoming images for drift
+    Access feature level results
 
-    >>> drift.predict(test_images).drifted
-    True
+    >>> n_features = result.feature_drift
+    >>> print(f"Features showing drift: {n_features.sum()} / {len(n_features)}")
+    Features showing drift: 576 / 576
     """
 
     def __init__(

dataeval/detectors/drift/_ks.py

@@ -22,49 +22,77 @@ from dataeval.typing import Array
 
 
 class DriftKS(BaseDriftUnivariate):
-    """
-    :term:`Drift` detector employing the :term:`Kolmogorov-Smirnov (KS) \
+    """:term:`Drift` detector employing the :term:`Kolmogorov-Smirnov (KS) \
     distribution<Kolmogorov-Smirnov (K-S) test>` test.
 
-    The KS test detects changes in the maximum distance between two data
-    distributions with Bonferroni or :term:`False Discovery Rate (FDR)` correction
-    for multivariate data.
+    Detects distributional changes by measuring the maximum distance between
+    empirical cumulative distribution functions of reference and test datasets.
+    For multivariate data, applies KS test independently to each feature
+    and aggregates results using multiple testing correction.
+
+    The Kolmogorov-Smirnov test is particularly sensitive to differences in
+    the middle portions of distributions but has reduced power in the tails
+    where cumulative distribution functions are constrained near 0 and 1.
 
     Parameters
     ----------
     data : Embeddings or Array
-        Data used as reference distribution.
-    p_val : float or None, default 0.05
-        :term:`p-value<P-Value>` used for significance of the statistical test for each feature.
-        If the FDR correction method is used, this corresponds to the acceptable
-        q-value.
+        Reference dataset used as baseline distribution for drift detection.
+        Should represent the expected data distribution.
+    p_val : float, default 0.05
+        Significance threshold for drift detection, between 0 and 1. 
+        Default 0.05 limits false drift alerts to 5% when no drift exists (Type I error rate).
     update_strategy : UpdateStrategy or None, default None
-        Reference data can optionally be updated using an UpdateStrategy class. Update
-        using the last n instances seen by the detector with LastSeenUpdateStrategy
-        or via reservoir sampling with ReservoirSamplingUpdateStrategy.
+        Strategy for updating reference data when new data arrives.
+        When None, reference data remains fixed throughout detection.
     correction : "bonferroni" or "fdr", default "bonferroni"
-        Correction type for multivariate data. Either 'bonferroni' or 'fdr' (False
-        Discovery Rate).
+        Multiple testing correction method for multivariate drift detection.
+        "bonferroni" provides conservative family-wise error control by
+        dividing significance threshold by number of features.
+        "fdr" uses Benjamini-Hochberg procedure for less conservative control.
+        Default "bonferroni" minimizes false positive drift detections.
     alternative : "two-sided", "less" or "greater", default "two-sided"
-        Defines the alternative hypothesis. Options are 'two-sided', 'less' or
-        'greater'.
+        Alternative hypothesis for the statistical test. "two-sided" detects
+        any distributional difference. "less" tests if test distribution is
+        stochastically smaller. "greater" tests if test distribution is
+        stochastically larger. Default "two-sided" provides most general
+        drift detection without directional assumptions.
     n_features : int | None, default None
-        Number of features used in the univariate drift tests. If not provided, it will
-        be inferred from the data.
+        Number of features to analyze in univariate tests.
+        When None, automatically inferred from the flattened shape of first data sample.
 
     Example
     -------
-    >>> from dataeval.data import Embeddings
-
-    Use Embeddings to encode images before testing for drift
+    Basic drift detection with image embeddings:
 
+    >>> from dataeval.data import Embeddings
     >>> train_emb = Embeddings(train_images, model=encoder, batch_size=64)
-    >>> drift = DriftKS(train_emb)
-
-    Test incoming images for drift
-
-    >>> drift.predict(test_images).drifted
-    True
+    >>> drift_detector = DriftKS(train_emb)
+    
+    Test incoming images for distributional drift
+    
+    >>> result = drift_detector.predict(test_images)
+    >>> print(f"Drift detected: {result.drifted}")
+    Drift detected: True
+
+    >>> print(f"Mean KS statistic: {result.distance:.4f}")
+    Mean KS statistic: 0.8750
+    
+    Detect if test data has systematically higher values
+    
+    >>> drift_greater = DriftKS(train_emb, alternative="greater")
+    >>> result = drift_greater.predict(test_images)
+    
+    Using different correction methods
+
+    >>> drift_fdr = DriftKS(train_emb, correction="fdr", p_val=0.1)
+    >>> result = drift_fdr.predict(test_images)
+    
+    Access feature-level results
+    
+    >>> n_features = result.feature_drift
+    >>> print(f"Features showing drift: {n_features.sum()} / {len(n_features)}")
+    Features showing drift: 576 / 576
     """
 
     def __init__(

dataeval/detectors/drift/_mmd.py

@@ -24,31 +24,57 @@ from dataeval.typing import Array
 
 
 class DriftMMD(BaseDrift):
-    """
-    :term:`Maximum Mean Discrepancy (MMD) Drift Detection` algorithm \
-    using a permutation test.
+    """Drift detector using :term:`Maximum Mean Discrepancy (MMD) Drift Detection` with permutation test.
+
+    Detects distributional differences by comparing kernel embeddings of reference
+    and test datasets in a reproducing kernel Hilbert space (RKHS). Uses permutation
+    testing to assess statistical significance of the observed MMD^2 statistic.
+
+    MMD is particularly effective for high-dimensional data like images as it can
+    capture complex distributional differences that univariate tests might miss.
+    The kernel-based approach enables detection of both marginal and dependency
+    changes between features.
 
     Parameters
     ----------
     data : Embeddings or Array
-        Data used as reference distribution.
-    p_val : float or None, default 0.05
-        :term:`P-value` used for significance of the statistical test for each feature.
-        If the FDR correction method is used, this corresponds to the acceptable
-        q-value.
+        Reference dataset used as baseline distribution for drift detection.
+        Should represent the expected data distribution.
+    p_val : float, default 0.05
+        Significance threshold for statistical tests, between 0 and 1.
+        For FDR correction, this represents the acceptable false discovery rate.
+        Default 0.05 provides 95% confidence level for drift detection.
     update_strategy : UpdateStrategy or None, default None
-        Reference data can optionally be updated using an UpdateStrategy class. Update
-        using the last n instances seen by the detector with LastSeenUpdateStrategy
-        or via reservoir sampling with ReservoirSamplingUpdateStrategy.
+        Strategy for updating reference data when new data arrives.
+        When None, reference data remains fixed throughout detection.
     sigma : Array or None, default None
-        Optionally set the internal GaussianRBF kernel bandwidth. Can also pass multiple
-        bandwidth values as an array. The kernel evaluation is then averaged over
-        those bandwidths.
+        Bandwidth parameter(s) for the Gaussian RBF kernel. Controls the
+        kernel's sensitivity to distance between data points. When None,
+        automatically selects bandwidth using median heuristic. Can provide
+        multiple values as array to average over different scales.
     n_permutations : int, default 100
-        Number of permutations used in the permutation test.
+        Number of random permutations used in the permutation test to estimate
+        the null distribution of MMD² under no drift. Higher values provide
+        more accurate p-value estimates but increase computation time.
+        Default 100 balances statistical accuracy with computational efficiency.
     device : DeviceLike or None, default None
-        The hardware device to use if specified, otherwise uses the DataEval
-        default or torch default.
+        Hardware device for computation. When None, automatically selects
+        DataEval's configured device, falling back to PyTorch's default.
+
+    Attributes
+    ----------
+    p_val : float
+        Significance threshold for statistical tests.
+    update_strategy : UpdateStrategy or None
+        Reference data update strategy.
+    n : int
+        Number of samples in the reference dataset.
+    sigma : Array or None
+        Gaussian RBF kernel bandwidth parameter(s).
+    n_permutations : int
+        Number of permutations for statistical testing.
+    device : torch.device
+        Hardware device used for computations.
 
     Example
     -------
@@ -56,7 +82,7 @@ class DriftMMD(BaseDrift):
 
     Use Embeddings to encode images before testing for drift
 
-    >>> train_emb = Embeddings(train_images, model=encoder, batch_size=64)
+    >>> train_emb = Embeddings(train_images, model=encoder, batch_size=16)
     >>> drift = DriftMMD(train_emb)
 
     Test incoming images for drift

dataeval/detectors/drift/_uncertainty.py

@@ -31,24 +31,42 @@ def classifier_uncertainty(
     preds: Array,
     preds_type: Literal["probs", "logits"] = "probs",
 ) -> torch.Tensor:
-    """
-    Evaluate model_fn on x and transform predictions to prediction uncertainties.
+    """Convert model predictions to uncertainty scores using entropy.
+
+    Computes prediction uncertainty as the entropy of the predicted class
+    probability distribution. Higher entropy indicates greater model uncertainty,
+    with maximum uncertainty at uniform distributions and minimum at confident
+    single-class predictions.
 
     Parameters
     ----------
-    x : Array
-        Batch of instances.
-    model_fn : Callable
-        Function that evaluates a :term:`classification<Classification>` model on x in a single call (contains
-        batching logic if necessary).
-    preds_type : "probs" | "logits", default "probs"
-        Type of prediction output by the model. Options are 'probs' (in [0,1]) or
-        'logits' (in [-inf,inf]).
+    preds : Array
+        Model predictions for a batch of instances. For "probs" type, should
+        contain class probabilities that sum to 1 across the last dimension.
+        For "logits" type, contains raw model outputs before softmax.
+    preds_type : "probs" or "logits", default "probs"
+        Type of prediction values. "probs" expects probabilities in [0,1] that
+        sum to 1. "logits" expects raw outputs in [-inf,inf] and applies softmax.
+        Default "probs" assumes model outputs normalized probabilities.
 
     Returns
     -------
-    NDArray
-        A scalar indication of uncertainty of the model on each instance in x.
+    torch.Tensor
+        Uncertainty scores for each instance with shape (n_samples, 1).
+        Values are always >= 0, with higher values indicating greater uncertainty.
+
+    Raises
+    ------
+    ValueError
+        If preds_type is "probs" but probabilities don't sum to 1 within tolerance.
+    NotImplementedError
+        If preds_type is not "probs" or "logits".
+
+    Notes
+    -----
+    Uncertainty is computed as Shannon entropy: -sum(p * log(p)) where p are
+    the predicted class probabilities. This provides a principled measure of
+    model confidence that is widely used in uncertainty quantification.
     """
     preds_np = as_numpy(preds)
     if preds_type == "probs":
@@ -65,53 +83,98 @@ def classifier_uncertainty(
 
 
 class DriftUncertainty(BaseDrift):
-    """
-    Test for a change in the number of instances falling into regions on which \
-        the model is uncertain.
+    """Drift detector using model prediction uncertainty.
 
-    Performs a K-S test on prediction entropies.
+    Detects drift by monitoring changes in the distribution of model prediction
+    uncertainties (entropy) rather than input features directly. Uses
+    :term:`Kolmogorov-Smirnov (K-S) Test` to compare uncertainty distributions
+    between reference and test data.
+
+    This approach is particularly effective for detecting drift that affects model
+    confidence even when input features remain statistically similar, such as
+    out-of-domain samples or adversarial examples.
 
     Parameters
     ----------
-    data : Array
-        Data used as reference distribution.
-    model : Callable
-        :term:`Classification` model outputting class probabilities (or logits)
+    data : Embeddings or Array
+        Reference dataset used as baseline distribution for drift detection.
+        Should represent the expected "normal" data distribution.
     p_val : float, default 0.05
-        :term:`P-Value` used for the significance of the test.
+        Significance threshold for statistical tests, between 0 and 1.
+        For FDR correction, this represents the acceptable false discovery rate.
+        Default 0.05 provides 95% confidence level for drift detection.
     update_strategy : UpdateStrategy or None, default None
-        Reference data can optionally be updated using an UpdateStrategy class. Update
-        using the last n instances seen by the detector with LastSeenUpdateStrategy
-        or via reservoir sampling with ReservoirSamplingUpdateStrategy.
+        Strategy for updating reference data when new data arrives.
+        When None, reference data remains fixed throughout detection.
     correction : "bonferroni" or "fdr", default "bonferroni"
-        Correction type for multivariate data. Either 'bonferroni' or 'fdr' (False
-        Discovery Rate).
+        Multiple testing correction method for multivariate drift detection.
+        "bonferroni" provides conservative family-wise error control by
+        dividing significance threshold by number of features.
+        "fdr" uses Benjamini-Hochberg procedure for less conservative control.
+        Default "bonferroni" minimizes false positive drift detections.
     preds_type : "probs" or "logits", default "probs"
-        Type of prediction output by the model. Options are 'probs' (in [0,1]) or
-        'logits' (in [-inf,inf]).
+        Format of model prediction outputs. "probs" expects normalized
+        probabilities summing to 1. "logits" expects raw model outputs
+        and applies softmax normalization internally.
+        Default "probs" assumes standard classification model outputs.
     batch_size : int, default 32
-        Batch size used to evaluate model. Only relevant when backend has been
-        specified for batch prediction.
+        Batch size for model inference during uncertainty computation.
+        Larger batches improve GPU utilization but require more memory.
+        Default 32 balances efficiency and memory usage.
     transforms : Transform, Sequence[Transform] or None, default None
-        Transform(s) to apply to the data.
+        Data transformations applied before model inference. Should match
+        preprocessing used during model training for consistent predictions.
+        When None, uses raw input data without preprocessing.
     device : DeviceLike or None, default None
-        Device type used. The default None tries to use the GPU and falls back on
-        CPU if needed. Can be specified by passing either 'cuda' or 'cpu'.
+        Hardware device for computation. When None, automatically selects
+        DataEval's configured device, falling back to PyTorch's default.
+
+    Attributes
+    ----------
+    model : torch.nn.Module
+        Classification model used for uncertainty computation.
+    device : torch.device
+        Hardware device used for model inference.
+    batch_size : int
+        Batch size for model predictions.
+    preds_type : {"probs", "logits"}
+        Format of model prediction outputs.
 
     Example
     -------
     >>> model = ClassificationModel()
-    >>> drift = DriftUncertainty(x_ref, model=model, batch_size=20)
+    >>> drift_detector = DriftUncertainty(x_ref, model=model, batch_size=16)
 
     Verify reference images have not drifted
 
-    >>> drift.predict(x_ref.copy()).drifted
-    False
+    >>> result = drift_detector.predict(x_test)
+    >>> print(f"Drift detected: {result.drifted}")
+    Drift detected: True
 
-    Test incoming images for drift
+    >>> print(f"Mean uncertainty change: {result.distance:.4f}")
+    Mean uncertainty change: 0.8160
 
-    >>> drift.predict(x_test).drifted
-    True
+    With data preprocessing
+
+    >>> import torchvision.transforms.v2 as T
+    >>> transforms = T.Compose([T.ToDtype(torch.float32)])
+    >>> drift_detector = DriftUncertainty(x_ref, model=model, batch_size=16, transforms=transforms)
+
+    Notes
+    -----
+    Uncertainty-based drift detection is complementary to feature-based methods.
+    It can detect semantic drift (changes in data meaning) that may not be
+    apparent in raw feature statistics, making it valuable for monitoring
+    model performance in production environments.
+
+    The method assumes that model uncertainty is a reliable indicator of
+    data quality. This works best with well-calibrated models trained on
+    representative data. Poorly calibrated models may produce misleading
+    uncertainty estimates.
+
+    For optimal performance, ensure the model and transforms match those used
+    during training, and that the reference data represents the expected
+    operational distribution where the model performs reliably.
     """
 
     def __init__(
@@ -142,27 +205,38 @@ class DriftUncertainty(BaseDrift):
         )
 
     def _transform(self, x: torch.Tensor) -> torch.Tensor:
+        """Apply preprocessing transforms to input data."""
         for transform in self._transforms:
             x = transform(x)
         return x
 
     def _preprocess(self, x: Array) -> torch.Tensor:
+        """Convert input data to uncertainty scores via model predictions."""
         preds = predict_batch(x, self.model, self.device, self.batch_size, self._transform)
         return classifier_uncertainty(preds, self.preds_type)
 
     def predict(self, x: Array) -> DriftOutput:
-        """
-        Predict whether a batch of data has drifted from the reference data.
+        """Predict whether model uncertainty distribution has drifted.
+
+        Computes prediction uncertainties for the input data and tests
+        whether their distribution significantly differs from the reference
+        uncertainty distribution using Kolmogorov-Smirnov test.
 
         Parameters
         ----------
         x : Array
-            Batch of instances.
+            Batch of instances to test for uncertainty drift.
 
         Returns
         -------
-        DriftUnvariateOutput
-            Dictionary containing the drift prediction, :term:`p-value<P-Value>`, and threshold
-            statistics.
+        DriftOutput
+            Drift detection results including overall prediction, p-values,
+            test statistics, and feature-level analysis of uncertainty values.
+
+        Notes
+        -----
+        The returned DriftOutput treats uncertainty values as "features" for
+        consistency with the underlying KS test implementation, even though
+        uncertainty-based drift typically involves univariate analysis.
         """
         return self._detector.predict(self._preprocess(x).cpu().numpy())

dataeval/outputs/_drift.py

@@ -18,8 +18,28 @@ from dataeval.outputs._base import Output
 
 @dataclass(frozen=True)
 class DriftBaseOutput(Output):
-    """
-    Base output class for Drift Detector classes
+    """Base output class for drift detector classes.
+
+    Provides common fields returned by all drift detection methods, containing
+    instance-level drift predictions and summary statistics. Subclasses extend
+    this with detector-specific additional fields.
+
+    Attributes
+    ----------
+    drifted : bool
+        Whether drift was detected in the analyzed data. True indicates
+        significant drift from reference distribution.
+    threshold : float
+        Significance threshold used for drift detection, typically between 0 and 1.
+        For multivariate methods, this is the corrected threshold after
+        Bonferroni or FDR correction.
+    p_val : float
+        Instance-level p-value from statistical test, between 0 and 1.
+        For univariate methods, this is the mean p-value across all features.
+    distance : float
+        Instance-level test statistic or distance metric, always >= 0.
+        For univariate methods, this is the mean distance across all features.
+        Higher values indicate greater deviation from reference distribution.
     """
 
     drifted: bool
@@ -31,58 +51,76 @@ class DriftBaseOutput(Output):
 @dataclass(frozen=True)
 class DriftMMDOutput(DriftBaseOutput):
     """
-    Output class for :class:`.DriftMMD` :term:`drift<Drift>` detector.
+    Output class for :class:`.DriftMMD` (Maximum Mean Discrepancy) drift detector.
+
+    Extends :class:`.DriftBaseOutput` with MMD-specific distance threshold information.
+    Used by MMD-based drift detectors that compare kernel embeddings between
+    reference and test distributions.
 
     Attributes
     ----------
     drifted : bool
-        Drift prediction for the images
+        Whether drift was detected based on MMD permutation test.
     threshold : float
-        :term:`P-Value` used for significance of the permutation test
+        P-value threshold used for significance of the permutation test.
     p_val : float
-        P-value obtained from the permutation test
+        P-value obtained from the MMD permutation test, between 0 and 1.
     distance : float
-        MMD^2 between the reference and test set
+        Squared Maximum Mean Discrepancy between reference and test set.
+        Always >= 0, with higher values indicating greater distributional difference.
     distance_threshold : float
-        MMD^2 threshold above which drift is flagged
+        Squared Maximum Mean Discrepancy threshold above which drift is flagged, always >= 0.
+        Determined from permutation test at specified significance level.
+
+    Notes
+    -----
+    MMD uses kernel methods to compare distributions in reproducing kernel
+    Hilbert spaces, making it effective for high-dimensional data like images.
     """
 
-    # drifted: bool
-    # threshold: float
-    # p_val: float
-    # distance: float
     distance_threshold: float
 
 
 @dataclass(frozen=True)
 class DriftOutput(DriftBaseOutput):
-    """
-    Output class for :class:`.DriftCVM`, :class:`.DriftKS`, and :class:`.DriftUncertainty` drift detectors.
+    """Output class for univariate drift detectors.
+
+    Extends :class:`.DriftBaseOutput` with feature-level (per-pixel) drift information.
+    Used by Kolmogorov-Smirnov, Cramér-von Mises, and uncertainty-based
+    drift detectors that analyze each feature independently.
 
     Attributes
     ----------
     drifted : bool
-        :term:`Drift` prediction for the images
+        Overall drift prediction after multivariate correction.
     threshold : float
-        Threshold after multivariate correction if needed
+        Corrected threshold after Bonferroni or FDR correction for multiple testing.
     p_val : float
-        Instance-level p-value
+        Mean p-value across all features, between 0 and 1.
+        For descriptive purposes only; individual feature p-values are used
+        for drift detection decisions. Can appear high even when drifted=True
+        if only a subset of features show drift.
     distance : float
-        Instance-level distance
-    feature_drift : NDArray
-        Feature-level array of images detected to have drifted
+        Mean test statistic across all features, always >= 0.
+    feature_drift : NDArray[bool]
+        Boolean array indicating which features (pixels) show drift.
+        Shape matches the number of features in the input data.
     feature_threshold : float
-        Feature-level threshold to determine drift
-    p_vals : NDArray
-        Feature-level p-values
-    distances : NDArray
-        Feature-level distances
+        Uncorrected p-value threshold used for individual feature testing.
+        Typically the original p_val before multivariate correction.
+    p_vals : NDArray[np.float32]
+        P-values for each feature, all values between 0 and 1.
+        Shape matches the number of features in the input data.
+    distances : NDArray[np.float32]
+        Test statistics for each feature, all values >= 0.
+        Shape matches the number of features in the input data.
+
+    Notes
+    -----
+    Feature-level analysis enables identification of specific pixels or regions
+    that contribute most to detected drift, useful for interpretability.
     """
 
-    # drifted: bool
-    # threshold: float
-    # p_val: float
-    # distance: float
     feature_drift: NDArray[np.bool_]
     feature_threshold: float
     p_vals: NDArray[np.float32]

dataeval/outputs/_workflows.py

@@ -108,7 +108,13 @@ def plot_measure(
                 zorder=3,
             )
     else:
-        ax.scatter(steps, averaged_measure, label=f"Model Results ({name})", zorder=3, c="black")
+        ax.scatter(
+            steps,
+            averaged_measure,
+            label=f"Model Results ({name})",
+            zorder=3,
+            c="black",
+        )
     # Plot extrapolation
     ax.plot(
         projection,
@@ -149,7 +155,9 @@ def f_inv_out(y_i: NDArray[Any], x: NDArray[Any]) -> NDArray[np.int64]:
                 "Number of samples could not be determined for target(s): "
                 f"""{
                     np.array2string(
-                        1 - y_i[unachievable_targets], separator=", ", formatter={"float": lambda x: f"{x}"}
+                        1 - y_i[unachievable_targets],
+                        separator=", ",
+                        formatter={"float": lambda x: f"{x}"},
                     )
                 }""",
                 UserWarning,
@@ -223,7 +231,9 @@ def calc_params(p_i: NDArray[Any], n_i: NDArray[Any], niter: int) -> NDArray[np.
 
 
 def get_curve_params(
-    averaged_measures: MutableMapping[str, NDArray[Any]], ranges: NDArray[Any], niter: int
+    averaged_measures: MutableMapping[str, NDArray[Any]],
+    ranges: NDArray[Any],
+    niter: int,
 ) -> Mapping[str, NDArray[np.float64]]:
     """Calculates and aggregates parameters for both single and multi-class metrics"""
     output = {}
@@ -324,7 +334,10 @@ class SufficiencyOutput(Output):
         return proj
 
     def plot(
-        self, class_names: Sequence[str] | None = None, error_bars: bool = False, asymptote: bool = False
+        self,
+        class_names: Sequence[str] | None = None,
+        error_bars: bool = False,
+        asymptote: bool = False,
     ) -> Sequence[Figure]:
         """
         Plotting function for data :term:`sufficience<Sufficiency>` tasks.
@@ -426,7 +439,8 @@ class SufficiencyOutput(Output):
                 projection[name] = np.zeros((len(measure), len(tarray)))
                 for i in range(len(measure)):
                     projection[name][i] = inv_project_steps(
-                        self.params[name][i], tarray[i] if tarray.ndim == measure.ndim else tarray
+                        self.params[name][i],
+                        tarray[i] if tarray.ndim == measure.ndim else tarray,
                     )
             else:
                 projection[name] = inv_project_steps(self.params[name], tarray)

dataeval/typing.py

@@ -21,7 +21,7 @@ __all__ = [
 ]
 
 
-from collections.abc import Iterator, Mapping
+from collections.abc import Iterator
 from typing import (
     Any,
     Generic,
@@ -94,6 +94,7 @@ class Array(Protocol):
 
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
+_T_cn = TypeVar("_T_cn", contravariant=True)
 
 
 class DatasetMetadata(TypedDict, total=False):
@@ -128,6 +129,19 @@ class ModelMetadata(TypedDict, total=False):
     index2label: NotRequired[ReadOnly[dict[int, str]]]
 
 
+class DatumMetadata(TypedDict, total=False):
+    """
+    Datum level metadata required for all `AnnotatedDataset` classes.
+
+    Attributes
+    ----------
+    id : Required[str]
+        A unique identifier for the datum
+    """
+
+    id: Required[ReadOnly[str]]
+
+
 @runtime_checkable
 class Dataset(Generic[_T_co], Protocol):
     """
@@ -173,7 +187,7 @@ class AnnotatedDataset(Dataset[_T_co], Generic[_T_co], Protocol):
 # ========== IMAGE CLASSIFICATION DATASETS ==========
 
 
-ImageClassificationDatum: TypeAlias = tuple[ArrayLike, ArrayLike, Mapping[str, Any]]
+ImageClassificationDatum: TypeAlias = tuple[ArrayLike, ArrayLike, DatumMetadata]
 """
 Type alias for an image classification datum tuple.
 
@@ -213,7 +227,7 @@ class ObjectDetectionTarget(Protocol):
     def scores(self) -> ArrayLike: ...
 
 
-ObjectDetectionDatum: TypeAlias = tuple[ArrayLike, ObjectDetectionTarget, Mapping[str, Any]]
+ObjectDetectionDatum: TypeAlias = tuple[ArrayLike, ObjectDetectionTarget, DatumMetadata]
 """
 Type alias for an object detection datum tuple.
 
@@ -254,7 +268,7 @@ class SegmentationTarget(Protocol):
     def scores(self) -> ArrayLike: ...
 
 
-SegmentationDatum: TypeAlias = tuple[ArrayLike, SegmentationTarget, Mapping[str, Any]]
+SegmentationDatum: TypeAlias = tuple[ArrayLike, SegmentationTarget, DatumMetadata]
 """
 Type alias for an image classification datum tuple.
 
@@ -311,3 +325,8 @@ class Transform(Generic[_T], Protocol):
     """
 
     def __call__(self, data: _T, /) -> _T: ...
+
+
+@runtime_checkable
+class Action(Generic[_T_cn, _T_co], Protocol):
+    def __call__(self, evaluator: _T_cn) -> _T_co: ...

{dataeval-0.88.1.dist-info → dataeval-0.89.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataeval
-Version: 0.88.1
+Version: 0.89.0
 Summary: DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks
 Project-URL: Homepage, https://dataeval.ai/
 Project-URL: Repository, https://github.com/aria-ml/dataeval/

{dataeval-0.88.1.dist-info → dataeval-0.89.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 dataeval/__init__.py,sha256=aFzX3SLx8wgc763RY772P41ZLqeHcUHRKW9XAN0KfHQ,1793
 dataeval/_log.py,sha256=Q2d6oqYKXyn1wkgMdNX9iswod4Jq0jPADShrCFVgJI0,374
-dataeval/_version.py,sha256=CKtd7X5fA88g3vtlmrUWb2oMZ7hUnqfrivEo9r-T_BU,513
+dataeval/_version.py,sha256=WrO2EvGpE352dBNSCRePHfYFYuFHG0OvoJpgjI_9VSQ,513
 dataeval/config.py,sha256=lL73s_xa9pBxHHCnBKi59D_tl4vS7ig1rfWbIYkM_ac,3839
 dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/typing.py,sha256=cKpK8rY7iVf-KL9kuye6qi_6LS6hKbMxHpurdWlYY44,7445
+dataeval/typing.py,sha256=pInHYviGxKbX4WQKVdB3CVtd5PRrTj6aH1SMONMDs3M,7854
 dataeval/data/__init__.py,sha256=wzQ6uUFLNB3VJR0a2QnRBYwEmwXT93q0WpHu7FmFW1E,486
-dataeval/data/_embeddings.py,sha256=BHoiSdt46TblVSglg9Cyrm8iAJJq1Z2jR4wesL0WOf4,14731
+dataeval/data/_embeddings.py,sha256=Bnl7KLw7waMJNxwpS_-W5dJl0uu4tjBLUsbIXICyyjI,14741
 dataeval/data/_images.py,sha256=9q0O5Zurf-5727rMC7DB_i3TtXcL67D9a5GGx5qlov8,3875
-dataeval/data/_metadata.py,sha256=-dhmyX6vvv97S9YHr6roNcbzXequkxMw48PwNDdzZ9I,24163
+dataeval/data/_metadata.py,sha256=M5OobFuhxyksjWwvyV-1PnWjFUYHcNfjejgxa203d8s,24178
 dataeval/data/_selection.py,sha256=4qI-GwSdEGiRCyr3kqxr6uOiyRRKsPBRzYHmpgdWLY0,5301
 dataeval/data/_split.py,sha256=aCkXFvkCw8VkWICdCmY9tHiEvkQI5j9jUa7QLjm-gZE,16759
 dataeval/data/selections/__init__.py,sha256=2m8ZB53wXzqLcqmc6p5atO6graB6ZyiRSNJFxf11X_g,613
@@ -20,12 +20,12 @@ dataeval/data/selections/_reverse.py,sha256=FqYlpPg-0Vz75kbEhGFrJlzIGELSmDZxPlBM
 dataeval/data/selections/_shuffle.py,sha256=uW_Zss773ob2swqwTdL6G-CzMElCq8TO2TScvABQR1U,1268
 dataeval/detectors/__init__.py,sha256=3Sg-XWlwr75zEEH3hZKA4nWMtGvaRlnfzTWvZG_Ak6U,189
 dataeval/detectors/drift/__init__.py,sha256=Jqv98oOVeC2tvHlNGxQ8RJ6De2q4SyS5lTpaYlb4ocM,756
-dataeval/detectors/drift/_base.py,sha256=__mlqkiPW0GcVSVE4u9t6M2mp3rAU5leSk_XPQn_Mp8,7619
-dataeval/detectors/drift/_cvm.py,sha256=cS33zWJmFY1fft1XcANcP2jSD5ou7TxvIU2AldhTynM,3004
-dataeval/detectors/drift/_ks.py,sha256=uMc5-NA-lSV1IODrY8uJe87ll3uRJT_oXLJFXy95M1w,3186
-dataeval/detectors/drift/_mmd.py,sha256=EkfbeK5L6xGGQrcA1v_0YlpIOingF73jn2H6s3tRKbo,11550
+dataeval/detectors/drift/_base.py,sha256=w1sUQlfFy6Wi5xIXStpnBm7L_Cxmtprm7LoPQbcVMME,13037
+dataeval/detectors/drift/_cvm.py,sha256=6E0-XIgVl40ivqBLqalMGTpG6sIGpC4AKOcLMoEpGE8,3990
+dataeval/detectors/drift/_ks.py,sha256=65I4gNjpkxXHMukEMU26ctF-4uLvIzPq3TNMsp0_yFs,4736
+dataeval/detectors/drift/_mmd.py,sha256=3oDFUUW6aVqs-T_Oxx-2iBa24H2hSN215lTEh8v-N7k,12943
 dataeval/detectors/drift/_mvdc.py,sha256=WMN6aDOWCh1q1MtdRXFIZlFcfnVi4XgBHsS0A6L5UuY,2942
-dataeval/detectors/drift/_uncertainty.py,sha256=-4aiwNosJ1_4kY-d2n4YbZV_jvnf5xdTMDELXSoW6OM,5874
+dataeval/detectors/drift/_uncertainty.py,sha256=yAaoEnH231DnWCHyODsr2UCtOf8Shs6zSbvu0efkv2g,9950
 dataeval/detectors/drift/updates.py,sha256=L1PnrPlIE1x6ujCc5mCwjcAZwadVTn-Zjb6MnTDvzJQ,2251
 dataeval/detectors/drift/_nml/__init__.py,sha256=MNyKyZlfTjr5uQql2uBBfRkUdsuduie_WJdn09GYmqg,137
 dataeval/detectors/drift/_nml/_base.py,sha256=wMqegfa92Tldqix1RL6dLMdiKgX0GqHmTiFxO38ja_c,2672
@@ -69,14 +69,14 @@ dataeval/metrics/stats/_visualstats.py,sha256=SbXvNWxfKrw-2wCu5FXMsnpsMUVaQzdJkj
 dataeval/outputs/__init__.py,sha256=geHB5M3QOiFFaQGV4ZwDTTKpqZPvPePbqG7lzaPhaXQ,1741
 dataeval/outputs/_base.py,sha256=lVC7xmBgv3JYY2wVLaGBMPlkRE_KV9UloaeQn0nQydA,5875
 dataeval/outputs/_bias.py,sha256=gj2AgSKOdq6bj59RMiHpha4Skld6ZMB8cW5KesOZ6T4,10483
-dataeval/outputs/_drift.py,sha256=hXILED_soY8ppIQZgftQvmumtwDrTnABbYl-flIGEU4,4588
+dataeval/outputs/_drift.py,sha256=_c41lUtEIg_NveYL9fxnYJA-nFqu09414Qb6XYYYFkU,7119
 dataeval/outputs/_estimators.py,sha256=SUjur5jI6OU9C7GpsAuA_qqO1PRnS-8eZN-otsaV5q0,3120
 dataeval/outputs/_linters.py,sha256=N4nP5HMoeN2zLndWzhoIT5QB1Ujxbs8Gx5pWPKhl3yc,6683
 dataeval/outputs/_metadata.py,sha256=ffZgpX8KWURPHXpOWjbvJ2KRqWQkS2nWuIjKUzoHhMI,1710
 dataeval/outputs/_ood.py,sha256=suLKVXULGtXH0rq9eXHI1d3d2jhGmItJtz4QiQd47A4,1718
 dataeval/outputs/_stats.py,sha256=PsDV0uw41aTy-X9tjz-PqOj78TTnH4JQVpOrU3OThAE,17423
 dataeval/outputs/_utils.py,sha256=KJ1P8tcMFIkGi2A6VfqbZwLcT1cD0c2YssTbWbHALjE,938
-dataeval/outputs/_workflows.py,sha256=Q6lvEjrqdazs0WZTp5hP9wLsrR7-Cofmb3b12OYZZUA,13771
+dataeval/outputs/_workflows.py,sha256=IdMjeyGKegJkChJWdyx8CiFneSaLx37voHR-X7O6qPk,13950
 dataeval/utils/__init__.py,sha256=sjelzMPaTImF6isiRcp8UGDE3tppEpWS5GoR8WKPZ1k,242
 dataeval/utils/_array.py,sha256=P4_gyH3kkksUJm9Vqx-oPtLWxFmqMacUJzhj0vmrUd8,6361
 dataeval/utils/_bin.py,sha256=QjlRCB5mOauETdxSbvRxRG17riO6gScsMd_lNnnvqxs,7391
@@ -99,7 +99,7 @@ dataeval/utils/torch/models.py,sha256=1idpXyjrYcCBSsbxxRUOto8xr4MJNjDEqQHiIXVU5Z
 dataeval/utils/torch/trainer.py,sha256=kBdgxd9TL1Pvz-dyZbS__POAKeFrDiQ4vKFh8ltJApc,5543
 dataeval/workflows/__init__.py,sha256=ou8y0KO-d6W5lgmcyLjKlf-J_ckP3vilW7wHkgiDlZ4,255
 dataeval/workflows/sufficiency.py,sha256=m3Z8VquGxefai6nOqoMveYA1XAA_mUf_IL21W-enyxQ,10274
-dataeval-0.88.1.dist-info/METADATA,sha256=9YDLUVCwj9Owh25uBSvsNkudiCot1jYH_4nTQCSkAEM,5601
-dataeval-0.88.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dataeval-0.88.1.dist-info/licenses/LICENSE,sha256=uAooygKWvX6NbU9Ran9oG2msttoG8aeTeHSTe5JeCnY,1061
-dataeval-0.88.1.dist-info/RECORD,,
+dataeval-0.89.0.dist-info/METADATA,sha256=X0YdtdEe7XBWqlUlEESHjD3gibKvyij-8tstduSwiLc,5601
+dataeval-0.89.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dataeval-0.89.0.dist-info/licenses/LICENSE,sha256=uAooygKWvX6NbU9Ran9oG2msttoG8aeTeHSTe5JeCnY,1061
+dataeval-0.89.0.dist-info/RECORD,,