dataeval 0.86.4__py3-none-any.whl → 0.86.6__py3-none-any.whl

dataeval/__init__.py

@@ -8,7 +8,7 @@ shifts that impact performance of deployed models.
 from __future__ import annotations
 
 __all__ = ["config", "detectors", "log", "metrics", "typing", "utils", "workflows"]
-__version__ = "0.86.4"
+__version__ = "0.86.6"
 
 import logging
 

dataeval/config.py

@@ -25,7 +25,7 @@ _seed: int | None = None
 
 ### CONSTS ###
 
-EPSILON = 1e-10
+EPSILON = 1e-12
 
 ### TYPES ###
 

dataeval/data/_metadata.py

@@ -4,7 +4,7 @@ __all__ = []
 
 import warnings
 from dataclasses import dataclass
-from typing import Any, Iterable, Literal, Mapping, Sequence
+from typing import Any, Iterable, Literal, Mapping, Sequence, Sized
 
 import numpy as np
 import polars as pl
@@ -69,6 +69,7 @@ class Metadata:
         self._is_binned = False
 
         self._dataset = dataset
+        self._count = len(dataset) if isinstance(dataset, Sized) else 0
         self._continuous_factor_bins = dict(continuous_factor_bins) if continuous_factor_bins else {}
         self._auto_bin_method: Literal["uniform_width", "uniform_count", "clusters"] = auto_bin_method
 
@@ -198,8 +199,9 @@ class Metadata:
 
     @property
     def image_count(self) -> int:
-        self._bin()
-        return 0 if self._image_indices.size == 0 else int(self._image_indices.max() + 1)
+        if self._count == 0:
+            self._structure()
+        return self._count
 
     def _filter(self, factor: str | tuple[str, Any]) -> bool:
         factor = factor[0] if isinstance(factor, tuple) else factor

dataeval/detectors/drift/_nml/_result.py

@@ -29,7 +29,7 @@ class AbstractResult(GenericOutput[pd.DataFrame]):
         self._data = results_data.copy(deep=True)
 
     def data(self) -> pd.DataFrame:
-        return self.to_df()
+        return self.to_dataframe()
 
     @property
     def empty(self) -> bool:
@@ -38,7 +38,7 @@ class AbstractResult(GenericOutput[pd.DataFrame]):
     def __len__(self) -> int:
         return 0 if self.empty else len(self._data)
 
-    def to_df(self, multilevel: bool = True) -> pd.DataFrame:
+    def to_dataframe(self, multilevel: bool = True) -> pd.DataFrame:
         """Export results to pandas dataframe."""
         if multilevel:
             return self._data

dataeval/detectors/linters/outliers.py

@@ -7,6 +7,7 @@ from typing import Any, Literal, Sequence, overload
 import numpy as np
 from numpy.typing import NDArray
 
+from dataeval.config import EPSILON
 from dataeval.data._images import Images
 from dataeval.metrics.stats._base import combine_stats, get_dataset_step_from_idx
 from dataeval.metrics.stats._imagestats import imagestats
@@ -17,27 +18,59 @@ from dataeval.outputs._stats import BASE_ATTRS
 from dataeval.typing import ArrayLike, Dataset
 
 
-def _get_outlier_mask(
-    values: NDArray, method: Literal["zscore", "modzscore", "iqr"], threshold: float | None
-) -> NDArray:
-    values = values.astype(np.float64)
-    if method == "zscore":
-        threshold = threshold if threshold else 3.0
-        std = np.std(values)
-        abs_diff = np.abs(values - np.mean(values))
-        return std != 0 and (abs_diff / std) > threshold
-    if method == "modzscore":
-        threshold = threshold if threshold else 3.5
-        abs_diff = np.abs(values - np.median(values))
-        med_abs_diff = np.median(abs_diff) if np.median(abs_diff) != 0 else np.mean(abs_diff)
-        mod_z_score = 0.6745 * abs_diff / med_abs_diff
+def _get_zscore_mask(values: NDArray[np.float64], threshold: float | None) -> NDArray[np.bool_] | None:
+    threshold = threshold if threshold is not None else 3.0
+    std_val = np.nanstd(values)
+    if std_val > EPSILON:
+        mean_val = np.nanmean(values)
+        abs_diff = np.abs(values - mean_val)
+        return (abs_diff / std_val) > threshold
+    return None
+
+
+def _get_modzscore_mask(values: NDArray[np.float64], threshold: float | None) -> NDArray[np.bool_] | None:
+    threshold = threshold if threshold is not None else 3.5
+    median_val = np.nanmedian(values)
+    abs_diff = np.abs(values - median_val)
+    m_abs_diff = np.nanmedian(abs_diff)
+    m_abs_diff = np.nanmean(abs_diff) if m_abs_diff <= EPSILON else m_abs_diff
+    if m_abs_diff > EPSILON:
+        mod_z_score = 0.6745 * abs_diff / m_abs_diff
         return mod_z_score > threshold
-    if method == "iqr":
-        threshold = threshold if threshold else 1.5
-        qrt = np.percentile(values, q=(25, 75), method="midpoint")
-        iqr = (qrt[1] - qrt[0]) * threshold
-        return (values < (qrt[0] - iqr)) | (values > (qrt[1] + iqr))
-    raise ValueError("Outlier method must be 'zscore' 'modzscore' or 'iqr'.")
+    return None
+
+
+def _get_iqr_mask(values: NDArray[np.float64], threshold: float | None) -> NDArray[np.bool_] | None:
+    threshold = threshold if threshold is not None else 1.5
+    qrt = np.nanpercentile(values, q=(25, 75), method="midpoint")
+    iqr_val = qrt[1] - qrt[0]
+    if iqr_val > EPSILON:
+        iqr_threshold = iqr_val * threshold
+        return (values < (qrt[0] - iqr_threshold)) | (values > (qrt[1] + iqr_threshold))
+    return None
+
+
+def _get_outlier_mask(
+    values: NDArray[Any], method: Literal["zscore", "modzscore", "iqr"], threshold: float | None
+) -> NDArray[np.bool_]:
+    if len(values) == 0:
+        return np.array([], dtype=bool)
+
+    nan_mask = np.isnan(values)
+
+    if np.all(nan_mask):
+        outliers = None
+    elif method == "zscore":
+        outliers = _get_zscore_mask(values.astype(np.float64), threshold)
+    elif method == "modzscore":
+        outliers = _get_modzscore_mask(values.astype(np.float64), threshold)
+    elif method == "iqr":
+        outliers = _get_iqr_mask(values.astype(np.float64), threshold)
+    else:
+        raise ValueError("Outlier method must be 'zscore' 'modzscore' or 'iqr'.")
+
+    # If outliers were found, return the mask with NaN values set to False, otherwise return all False
+    return outliers & ~nan_mask if outliers is not None else np.full(values.shape, False, dtype=bool)
 
 
 class Outliers:
@@ -164,10 +197,10 @@ class Outliers:
         >>> len(results)
         2
         >>> results.issues[0]
-        {10: {'skew': -3.906, 'kurtosis': 13.266, 'entropy': 0.2128}, 12: {'std': 0.00536, 'var': 2.87e-05, 'skew': -3.906, 'kurtosis': 13.266, 'entropy': 0.2128}}
+        {10: {'entropy': 0.2128}, 12: {'std': 0.00536, 'var': 2.87e-05, 'entropy': 0.2128}}
         >>> results.issues[1]
         {}
-        """  # noqa: E501
+        """
         if isinstance(stats, (ImageStatsOutput, DimensionStatsOutput, PixelStatsOutput, VisualStatsOutput)):
             return OutliersOutput(self._get_outliers(stats.data()))
 
@@ -221,7 +254,7 @@ class Outliers:
         >>> list(results.issues)
         [10, 12]
         >>> results.issues[10]
-        {'contrast': 1.25, 'zeros': 0.05493, 'skew': -3.906, 'kurtosis': 13.266, 'entropy': 0.2128}
+        {'contrast': 1.25, 'zeros': 0.05493, 'entropy': 0.2128}
         """
         images = Images(data) if isinstance(data, Dataset) else data
         self.stats = imagestats(images)

dataeval/metrics/stats/_base.py

@@ -13,8 +13,8 @@ from multiprocessing import Pool
 from typing import Any, Callable, Generic, Iterable, Iterator, Sequence, TypeVar
 
 import numpy as np
-import tqdm
 from numpy.typing import NDArray
+from tqdm.auto import tqdm
 
 from dataeval.config import get_max_processes
 from dataeval.outputs._stats import BASE_ATTRS, BaseStatsOutput, SourceIndex
@@ -77,7 +77,7 @@ class PoolWrapper:
     """
 
     def __init__(self, processes: int | None) -> None:
-        self.pool = Pool(processes) if processes is not None and processes > 1 else None
+        self.pool = Pool(processes) if processes is None or processes > 1 else None
 
     def imap(self, func: Callable[[_S], _T], iterable: Iterable[_S]) -> Iterator[_T]:
         return map(func, iterable) if self.pool is None else self.pool.imap(func, iterable)
@@ -93,7 +93,7 @@ class PoolWrapper:
 
 class StatsProcessor(Generic[TStatsOutput]):
     output_class: type[TStatsOutput]
-    cache_keys: list[str] = []
+    cache_keys: set[str] = set()
     image_function_map: dict[str, Callable[[StatsProcessor[TStatsOutput]], Any]] = {}
     channel_function_map: dict[str, Callable[[StatsProcessor[TStatsOutput]], Any]] = {}
 
@@ -267,7 +267,7 @@ def run_stats(
     stats_processor_cls = stats_processor_cls if isinstance(stats_processor_cls, Iterable) else [stats_processor_cls]
 
     with PoolWrapper(processes=get_max_processes()) as p:
-        for r in tqdm.tqdm(
+        for r in tqdm(
             p.imap(
                 partial(
                     process_stats_unpack,

dataeval/metrics/stats/_labelstats.py

@@ -68,7 +68,11 @@ def labelstats(dataset: Metadata | AnnotatedDataset[Any]) -> LabelStatsOutput:
 
     # Count labels per image
     label_per_image_df = metadata_df.group_by("image_index").agg(pl.len().alias("label_count"))
-    label_per_image = label_per_image_df.sort("image_index")["label_count"].to_list()
+
+    # Join with all indices to include missing ones with 0 count
+    all_indices = pl.DataFrame({"image_index": range(metadata.image_count)})
+    complete_label_df = all_indices.join(label_per_image_df, on="image_index", how="left").fill_null(0)
+    label_per_image = complete_label_df.sort("image_index")["label_count"].to_list()
 
     return LabelStatsOutput(
         label_counts_per_class=label_counts,

dataeval/metrics/stats/_pixelstats.py

@@ -15,12 +15,13 @@ from dataeval.typing import ArrayLike, Dataset
 
 class PixelStatsProcessor(StatsProcessor[PixelStatsOutput]):
     output_class: type = PixelStatsOutput
+    cache_keys = {"histogram"}
     image_function_map: dict[str, Callable[[StatsProcessor[PixelStatsOutput]], Any]] = {
         "mean": lambda x: np.nanmean(x.scaled),
         "std": lambda x: np.nanstd(x.scaled),
         "var": lambda x: np.nanvar(x.scaled),
-        "skew": lambda x: np.nan_to_num(skew(x.scaled.ravel())),
-        "kurtosis": lambda x: np.nan_to_num(kurtosis(x.scaled.ravel())),
+        "skew": lambda x: skew(x.scaled.ravel(), nan_policy="omit"),
+        "kurtosis": lambda x: kurtosis(x.scaled.ravel(), nan_policy="omit"),
         "histogram": lambda x: np.histogram(x.scaled, 256, (0, 1))[0],
         "entropy": lambda x: entropy(x.get("histogram")),
     }
@@ -28,8 +29,8 @@ class PixelStatsProcessor(StatsProcessor[PixelStatsOutput]):
         "mean": lambda x: np.nanmean(x.scaled, axis=1),
         "std": lambda x: np.nanstd(x.scaled, axis=1),
         "var": lambda x: np.nanvar(x.scaled, axis=1),
-        "skew": lambda x: np.nan_to_num(skew(x.scaled, axis=1)),
-        "kurtosis": lambda x: np.nan_to_num(kurtosis(x.scaled, axis=1)),
+        "skew": lambda x: skew(x.scaled, axis=1, nan_policy="omit"),
+        "kurtosis": lambda x: kurtosis(x.scaled, axis=1, nan_policy="omit"),
         "histogram": lambda x: np.apply_along_axis(lambda y: np.histogram(y, 256, (0, 1))[0], 1, x.scaled),
         "entropy": lambda x: entropy(x.get("histogram"), axis=1),
     }

dataeval/metrics/stats/_visualstats.py

@@ -6,6 +6,7 @@ from typing import Any, Callable
 
 import numpy as np
 
+from dataeval.config import EPSILON
 from dataeval.metrics.stats._base import StatsProcessor, run_stats
 from dataeval.outputs import VisualStatsOutput
 from dataeval.outputs._base import set_metadata
@@ -17,23 +18,21 @@ QUARTILES = (0, 25, 50, 75, 100)
 
 class VisualStatsProcessor(StatsProcessor[VisualStatsOutput]):
     output_class: type = VisualStatsOutput
+    cache_keys: set[str] = {"percentiles"}
     image_function_map: dict[str, Callable[[StatsProcessor[VisualStatsOutput]], Any]] = {
         "brightness": lambda x: x.get("percentiles")[1],
-        "contrast": lambda x: 0
-        if np.mean(x.get("percentiles")) == 0
-        else (np.max(x.get("percentiles")) - np.min(x.get("percentiles"))) / np.mean(x.get("percentiles")),
+        "contrast": lambda x: (np.max(x.get("percentiles")) - np.min(x.get("percentiles")))
+        / (np.mean(x.get("percentiles")) + EPSILON),
         "darkness": lambda x: x.get("percentiles")[-2],
         "missing": lambda x: np.count_nonzero(np.isnan(np.sum(x.image, axis=0))) / np.prod(x.shape[-2:]),
         "sharpness": lambda x: np.nanstd(edge_filter(np.mean(x.image, axis=0))),
-        "zeros": lambda x: np.count_nonzero(np.nansum(x.image, axis=0) == 0) / np.prod(x.shape[-2:]),
+        "zeros": lambda x: np.count_nonzero(np.sum(x.image, axis=0) == 0) / np.prod(x.shape[-2:]),
         "percentiles": lambda x: np.nanpercentile(x.scaled, q=QUARTILES),
     }
     channel_function_map: dict[str, Callable[[StatsProcessor[VisualStatsOutput]], Any]] = {
         "brightness": lambda x: x.get("percentiles")[:, 1],
-        "contrast": lambda x: np.nan_to_num(
-            (np.max(x.get("percentiles"), axis=1) - np.min(x.get("percentiles"), axis=1))
-            / np.mean(x.get("percentiles"), axis=1)
-        ),
+        "contrast": lambda x: (np.max(x.get("percentiles"), axis=1) - np.min(x.get("percentiles"), axis=1))
+        / (np.mean(x.get("percentiles"), axis=1) + EPSILON),
         "darkness": lambda x: x.get("percentiles")[:, -2],
         "missing": lambda x: np.count_nonzero(np.isnan(x.image), axis=(1, 2)) / np.prod(x.shape[-2:]),
         "sharpness": lambda x: np.nanstd(np.vectorize(edge_filter, signature="(m,n)->(m,n)")(x.image), axis=(1, 2)),

dataeval/outputs/_drift.py

@@ -114,7 +114,7 @@ class DriftMVDCOutput(PerMetricResult):
         import matplotlib.pyplot as plt
 
         fig, ax = plt.subplots(dpi=300)
-        resdf = self.to_df()
+        resdf = self.to_dataframe()
         xticks = np.arange(resdf.shape[0])
         trndf = resdf[resdf["chunk"]["period"] == "reference"]
         tstdf = resdf[resdf["chunk"]["period"] == "analysis"]

dataeval/outputs/_stats.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Iterable, Mapping, NamedTuple, Optional, Sequence, Union
 
 import numpy as np
-import pandas as pd
+import polars as pl
 from numpy.typing import NDArray
 from typing_extensions import TypeAlias
 
@@ -22,7 +22,7 @@ SOURCE_INDEX = "source_index"
 OBJECT_COUNT = "object_count"
 IMAGE_COUNT = "image_count"
 
-BASE_ATTRS = (SOURCE_INDEX, OBJECT_COUNT, IMAGE_COUNT)
+BASE_ATTRS = [SOURCE_INDEX, OBJECT_COUNT, IMAGE_COUNT]
 
 
 class SourceIndex(NamedTuple):
@@ -156,14 +156,21 @@ class BaseStatsOutput(Output):
         Mapping[str, NDArray[Any]]
         """
         filter_ = [filter] if isinstance(filter, str) else filter
+
+        """
+        Performs validation checks to ensure selected keys and constant or 1-D values
+        Each set of checks returns True if a valid value.
+        Only one set of final checks needs to be True to allow the value through
+        """
         return {
             k: v
             for k, v in self.data().items()
-            if k not in BASE_ATTRS
-            and (filter_ is None or k in filter_)
-            and isinstance(v, np.ndarray)
-            and v.ndim == 1
-            and (not exclude_constant or len(np.unique(v)) > 1)
+            if (
+                k not in BASE_ATTRS  # Ignore BaseStatsOutput attributes
+                and (filter_ is None or k in filter_)  # Key is selected
+                and (isinstance(v, np.ndarray) and v.ndim == 1)  # Check valid array
+                and (not exclude_constant or len(np.unique(v)) > 1)  # Check valid numpy "constant"
+            )
         }
 
     def plot(
@@ -195,6 +202,11 @@ class BaseStatsOutput(Output):
             return histogram_plot(factors, log)
         return channel_histogram_plot(factors, log, max_channels, ch_mask)
 
+    def to_dataframe(self) -> pl.DataFrame:
+        """Returns the processed factors a polars dataframe of shape (factors, samples)"""
+
+        return pl.DataFrame(self.factors())
+
 
 @dataclass(frozen=True)
 class DimensionStatsOutput(BaseStatsOutput):
@@ -256,6 +268,43 @@ class HashStatsOutput(BaseStatsOutput):
     xxhash: Sequence[str]
     pchash: Sequence[str]
 
+    def to_dataframe(self) -> pl.DataFrame:
+        """
+        Returns a polars dataframe for the xxhash and pchash attributes of each sample
+
+        Note
+        ----
+        xxhash and pchash do not follow the normal definition of factors but are
+        helpful attributes of the data
+
+        Examples
+        --------
+        Display the hashes of a dataset of images, whose shape is (C, H, W),
+        as a polars DataFrame
+
+        >>> from dataeval.metrics.stats import hashstats
+        >>> results = hashstats(dataset)
+        >>> print(results.to_dataframe())
+        shape: (8, 2)
+        ┌──────────────────┬──────────────────┐
+        │ xxhash           ┆ pchash           │
+        │ ---              ┆ ---              │
+        │ str              ┆ str              │
+        ╞══════════════════╪══════════════════╡
+        │ 69b50a5f06af238c ┆ e666999999266666 │
+        │ 5a861d7a23d1afe7 ┆ e666999999266666 │
+        │ 7ffdb4990ad44ac6 ┆ e666999966666299 │
+        │ 4f0c366a3298ceac ┆ e666999999266666 │
+        │ c5519e36ac1f8839 ┆ 96e91656e91616e9 │
+        │ e7e92346159a4567 ┆ e666999999266666 │
+        │ 9a538f797a5ba8ee ┆ e666999999266666 │
+        │ 1a658bd2a1baee25 ┆ e666999999266666 │
+        └──────────────────┴──────────────────┘
+        """
+        data = {"xxhash": self.xxhash, "pchash": self.pchash}
+        schema = {"xxhash": str, "pchash": str}
+        return pl.DataFrame(data=data, schema=schema)
+
 
 @dataclass(frozen=True)
 class LabelStatsOutput(Output):
@@ -325,17 +374,13 @@ class LabelStatsOutput(Output):
 
         return "\n".join(table_str)
 
-    def to_dataframe(self) -> pd.DataFrame:
+    def to_dataframe(self) -> pl.DataFrame:
         """
-        Exports the label statistics output results to a pandas DataFrame.
-
-        Notes
-        -----
-        This method requires `pandas <https://pandas.pydata.org/>`_ to be installed.
+        Exports the label statistics output results to a polars DataFrame.
 
         Returns
         -------
-        pd.DataFrame
+        pl.DataFrame
         """
         total_count = []
         image_count = []
@@ -343,7 +388,7 @@ class LabelStatsOutput(Output):
             total_count.append(self.label_counts_per_class[cls])
             image_count.append(self.image_counts_per_class[cls])
 
-        return pd.DataFrame(
+        return pl.DataFrame(
             {
                 "Label": self.class_names,
                 "Total Count": total_count,

dataeval/utils/data/_dataset.py

@@ -72,9 +72,8 @@ def _listify_metadata(
 
 def _find_max(arr: ArrayLike) -> Any:
     if not isinstance(arr, (bytes, str)) and isinstance(arr, (Iterable, Sequence, Array)):
-        if isinstance(arr[0], (Iterable, Sequence, Array)):
-            return max([_find_max(x) for x in arr])  # type: ignore
-        return max(arr)
+        nested = [x for x in [_find_max(x) for x in arr] if x is not None]
+        return max(nested) if len(nested) > 0 else None
     return arr
 
 

dataeval/utils/datasets/_fileio.py

@@ -8,7 +8,7 @@ import zipfile
 from pathlib import Path
 
 import requests
-from tqdm import tqdm
+from tqdm.auto import tqdm
 
 ARCHIVE_ENDINGS = [".zip", ".tar", ".tgz"]
 COMPRESS_ENDINGS = [".gz", ".bz2"]

dataeval/utils/torch/_internal.py

@@ -8,7 +8,7 @@ import numpy as np
 import torch
 from numpy.typing import NDArray
 from torch.utils.data import DataLoader, TensorDataset
-from tqdm import tqdm
+from tqdm.auto import tqdm
 
 from dataeval.config import DeviceLike, get_device
 from dataeval.typing import Array

{dataeval-0.86.4.dist-info → dataeval-0.86.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.86.4
+Version: 0.86.6
 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.86.4.dist-info → dataeval-0.86.6.dist-info}/RECORD

@@ -1,10 +1,10 @@
-dataeval/__init__.py,sha256=6gfYCGo82QKKO58jQSma27Mr-R316vmCDbTjXRh5B7o,1636
+dataeval/__init__.py,sha256=9M6Th_pJ371mFO5oLUC0UZJmDclHa8SbNJse71-T84I,1636
 dataeval/_log.py,sha256=C7AGkIRzymvYJ0LQXtnShiy3i5Xrp8T58JzIHHguk_Q,365
-dataeval/config.py,sha256=hjad0TK1UmaKQlUuxqxt64_OAUqZkHjicBf06cvTyrQ,4082
+dataeval/config.py,sha256=bHa8np4FCtLLv8_xlfdDC4lb1InJ_kT0vXDO5P42rvk,4082
 dataeval/data/__init__.py,sha256=wzQ6uUFLNB3VJR0a2QnRBYwEmwXT93q0WpHu7FmFW1E,486
 dataeval/data/_embeddings.py,sha256=PFjpdV9bfusCB4taTIYSzx1hP8nJb_KCkZTN8kMw-Hs,12885
 dataeval/data/_images.py,sha256=Rc_59CuU4zfN7Xm7an1XUx8ZghQg6a56VJWMZD9edRw,2654
-dataeval/data/_metadata.py,sha256=5pND6IZ5KeEGrhCDiBVxhU_BXWU0okBxt8oNkZ9a2_M,14309
+dataeval/data/_metadata.py,sha256=OTda9V7DA5Ejxip_NR16LCK2C8HMtpjWHHiFoW3LrLY,14364
 dataeval/data/_selection.py,sha256=r06xeiyK8nTWPLyItkoPQRWZI1i6LATSue_cuEbCdc4,4463
 dataeval/data/_split.py,sha256=nQABR05vxil2Qx7-uX4Fm0_DWpibskBGDJOYj_b1u3I,16737
 dataeval/data/selections/__init__.py,sha256=2m8ZB53wXzqLcqmc6p5atO6graB6ZyiRSNJFxf11X_g,613
@@ -26,13 +26,13 @@ dataeval/detectors/drift/_nml/__init__.py,sha256=MNyKyZlfTjr5uQql2uBBfRkUdsuduie
 dataeval/detectors/drift/_nml/_base.py,sha256=o34LcCsD9p1A6u8UdQn-dxIVwC2CMr6uCpC0vq16JX0,2663
 dataeval/detectors/drift/_nml/_chunk.py,sha256=t12eouanRNiu5DJXOaYDZXUvFMqfcp1BETLOufdV79M,13567
 dataeval/detectors/drift/_nml/_domainclassifier.py,sha256=n7Ttq5Ej7sAY9Jn2iagaGj4IIWiG8gmA3wwFizlBqes,7292
-dataeval/detectors/drift/_nml/_result.py,sha256=Nz_qTRu_EcJ1OcywSTVXFm9fx3UyuX66ZWACrffG5dI,3255
+dataeval/detectors/drift/_nml/_result.py,sha256=TMK17bnlgSdL0MCRHtQZJO8YoWWe4C2kh_akESrlP1g,3269
 dataeval/detectors/drift/_nml/_thresholds.py,sha256=WGdkLei9w_EvvsRHQzWdDyFVoZHIwM78k_aB3eoh31Q,12060
 dataeval/detectors/drift/_uncertainty.py,sha256=BHlykJ-r7TGLJxdPfoazXnoAJ1qVDzbk5HjAMdsnHz8,5847
 dataeval/detectors/drift/updates.py,sha256=L1PnrPlIE1x6ujCc5mCwjcAZwadVTn-Zjb6MnTDvzJQ,2251
 dataeval/detectors/linters/__init__.py,sha256=xn2zPwUcmsuf-Jd9uw6AVI11C9z1b1Y9fYtuFnXenZ0,404
 dataeval/detectors/linters/duplicates.py,sha256=X5WSEvI_BHkLoXjkaHK6wTnSkx4IjpO_exMRjSlhc70,4963
-dataeval/detectors/linters/outliers.py,sha256=R3-p8kzia77Q3k2grXeRXnRiv7nMhosoPY1sDLQVKrs,9049
+dataeval/detectors/linters/outliers.py,sha256=GaM9n8yPgBPzVOL_bxJCj0eCwobEEP4JHKHD9liRdlw,10130
 dataeval/detectors/ood/__init__.py,sha256=juCYBDs7CQEAtMhnEpPqF6uTrOIH9kTBSuQ_GRw6a8o,283
 dataeval/detectors/ood/ae.py,sha256=fTrUfFxv6xUqzKpwMC8rW3JrizA16M_bgzqLuBKMrS0,2944
 dataeval/detectors/ood/base.py,sha256=9b-Ljznf0lB1SXF4F_Aj3eJ4Y3ijGEDPMjucUsWOGJM,3051
@@ -54,23 +54,23 @@ dataeval/metrics/estimators/_clusterer.py,sha256=1HrpihGTJ63IkNSOy4Ibw633Gllkm1R
 dataeval/metrics/estimators/_divergence.py,sha256=-np4nWNtRrHnvo4xdWuTzkyJJmobyjDnVDBOMjtBS1Y,4003
 dataeval/metrics/estimators/_uap.py,sha256=BULEBbJ9BQ1IcTeZf0x7iI60QHAWCccBOM97FIu9VXA,1928
 dataeval/metrics/stats/__init__.py,sha256=6tA_9nbbM5ObJ6cds8Y1VBtTQiTOxrpGQSFLu_lWGGA,1098
-dataeval/metrics/stats/_base.py,sha256=-TIDSHT-zwNXqWMTM6Nu3BQ11cWP4TFYFaUF40vIChs,12534
+dataeval/metrics/stats/_base.py,sha256=R-hxoEPLreZcxYxBfyjbKfdoGMMTPiqJ5g2zSO-1UYM,12541
 dataeval/metrics/stats/_boxratiostats.py,sha256=ROZrlqgbowkGfCR5PJ5TL7Og40iMOdUqJnsCtaz_Xek,6450
 dataeval/metrics/stats/_dimensionstats.py,sha256=EVO-BlxrZl8qrP09lwPbyWdrG1ZeDtgj4LiswDwEZ1I,2896
 dataeval/metrics/stats/_hashstats.py,sha256=qa1CYRgOebkxqkALfffaPM-kJ074ZbyfpWbfOfuObSs,4758
 dataeval/metrics/stats/_imagestats.py,sha256=gUPNgN5Zwzdr7WnSwbve1NXNsyxd5dy3cSnlR_7guCg,3007
-dataeval/metrics/stats/_labelstats.py,sha256=UG7aKpFctLJvca3rC9sPT_25sCes77KpgZguJYMXfU0,2949
-dataeval/metrics/stats/_pixelstats.py,sha256=5RCQh0OQkHiCkn3DgCPVxKoFfifX_FOtwsnotADSZ0I,3265
-dataeval/metrics/stats/_visualstats.py,sha256=0k6bvAL_d66nQMfG7bydCOFJb7B0dhgG7fqCjVTp1sg,3707
+dataeval/metrics/stats/_labelstats.py,sha256=_dXt3p8_-SHEtHvJWbL0rnQvO2g30zxX42mG2LGJepU,3195
+dataeval/metrics/stats/_pixelstats.py,sha256=N9e7RXuzSHtlJtWU7l5IcTTIXe2kOmWiuj6lnJpZWq0,3312
+dataeval/metrics/stats/_visualstats.py,sha256=b6jMq36_UlKduMrkwfq2i0fXNalDEcMdqPgoynXl5hI,3713
 dataeval/outputs/__init__.py,sha256=geHB5M3QOiFFaQGV4ZwDTTKpqZPvPePbqG7lzaPhaXQ,1741
 dataeval/outputs/_base.py,sha256=-Wa0gFcBVLbfWPMZyCql7x4vGsnkLP4pecsQIeUZ2_Y,5904
 dataeval/outputs/_bias.py,sha256=1OZpKncYTryjPLRHb4d6NlhE27uPT57gCob_5jtjKDI,10456
-dataeval/outputs/_drift.py,sha256=rKn5vqMR6XNujgSqfHsH76oFkoGsUusquZL2Qy4Ae6Y,4581
+dataeval/outputs/_drift.py,sha256=hXILED_soY8ppIQZgftQvmumtwDrTnABbYl-flIGEU4,4588
 dataeval/outputs/_estimators.py,sha256=mh-R08CgYtmq9ffANDMYR-V4vrZnSjOjEyOMiMDZ2Ic,3091
 dataeval/outputs/_linters.py,sha256=k8lkd8EZ23q0m-HOD-FgqMcLQFy1UH7vws2ucLPyn08,6697
 dataeval/outputs/_metadata.py,sha256=ffZgpX8KWURPHXpOWjbvJ2KRqWQkS2nWuIjKUzoHhMI,1710
 dataeval/outputs/_ood.py,sha256=suLKVXULGtXH0rq9eXHI1d3d2jhGmItJtz4QiQd47A4,1718
-dataeval/outputs/_stats.py,sha256=F-515PGBNB69DXM-YaCkGHAyaXkCD-yYvKfj4-q7R4w,15247
+dataeval/outputs/_stats.py,sha256=_ItGjs9YaMHqjivkR1YBcSErD5ICfa_-iV9nq0l8bTM,17451
 dataeval/outputs/_utils.py,sha256=NfhYaGT2PZlhIs8ICKUsPWHZXjhWYDkEJqBDdqMeaOM,929
 dataeval/outputs/_workflows.py,sha256=K786mOgegxVi81diUA-qpbwGEkwa8YA7Fk4ttgjJeaY,10831
 dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -85,14 +85,14 @@ dataeval/utils/_method.py,sha256=9B9JQbgqWJBRhQJb7glajUtWaQzUTIUuvrZ9_bisxsM,394
 dataeval/utils/_mst.py,sha256=bLmJmu_1Dtj3hC5gQp3oAiJ_7TKtEjahTqusVRRU4eI,2168
 dataeval/utils/_plot.py,sha256=1rnMkBRvTFLoTAHqXwF7c7GJ5_5iqlgarZKAzmYciLk,7225
 dataeval/utils/data/__init__.py,sha256=xGzrjrOxOP2DP1tU84AWMKPnSxFvSjM81CTlDg4rNM8,331
-dataeval/utils/data/_dataset.py,sha256=CFK9h-XPN7J-iF2nXol6keMDbGm6VIweFAMAjXRUlhg,9527
+dataeval/utils/data/_dataset.py,sha256=tC_vqgWnmojAoAANo5BUVfEUYXl7GzOBSeYjR9olbDk,9506
 dataeval/utils/data/collate.py,sha256=5egEEKhNNCGeNLChO1p6dZ4Wg6x51VEaMNHz7hEZUxI,3936
 dataeval/utils/data/metadata.py,sha256=L1c2bCiMj0aR0QCoKkjwBujIftJDEMgW_3ZbgeS8WHo,14703
 dataeval/utils/datasets/__init__.py,sha256=pAXqHX76yAoBI8XB3m6zGuW-u3s3PCoIXG5GDzxH7Zs,572
 dataeval/utils/datasets/_antiuav.py,sha256=kA_ia1fYNcJiz9SpCvh-Z8iSc7iJrdogjBI3soyaa7A,8304
 dataeval/utils/datasets/_base.py,sha256=pyfpJda3ku469M3TFRsJn9S2oAiQODOGTlLcdcoEW9U,9031
 dataeval/utils/datasets/_cifar10.py,sha256=hZc_A30yKYBbv2kvVdEkZ9egyEe6XBUnmksoIAoJ-5Y,8265
-dataeval/utils/datasets/_fileio.py,sha256=OASFA9uX3KgfyPb5vza12BlZyAi9Y8Al9lUR_IYPcsM,5449
+dataeval/utils/datasets/_fileio.py,sha256=LEoFVNdryRdi7mKpWw-9D8lA6XMa-Jaszd85bv93POo,5454
 dataeval/utils/datasets/_milco.py,sha256=iXf4C1I3Eg_3gHKUe4XPi21yFMBO51zxTIqAkGf9bYg,7869
 dataeval/utils/datasets/_mixin.py,sha256=S8iii-SoYUsFFYNXjw2thlZkpBvRLnZ4XI8wTqOKXgU,1729
 dataeval/utils/datasets/_mnist.py,sha256=uz46sE1Go3TgGjG6x2cXckSVQ0mSg2mhgk8BUvLWjb0,8149
@@ -102,12 +102,12 @@ dataeval/utils/datasets/_voc.py,sha256=pafY112O80isYkrdy7Quie9SBm_TmYhREuyl8Sxts
 dataeval/utils/torch/__init__.py,sha256=dn5mjCrFp0b1aL_UEURhONU0Ag0cmXoTOBSGagpkTiA,325
 dataeval/utils/torch/_blocks.py,sha256=HVhBTMMD5NA4qheMUgyol1KWiKZDIuc8k5j4RcMKmhk,1466
 dataeval/utils/torch/_gmm.py,sha256=XM68GNEP97EjaB1U49-ZXRb81d0CEFnPS910alrcB3g,3740
-dataeval/utils/torch/_internal.py,sha256=vHy-DzPhmvE8h3wmWc3aciBJ8nDGzQ1z1jTZgGjmDyM,4154
+dataeval/utils/torch/_internal.py,sha256=HuyBB7NWFI9sUrRbOCZFxOfZjRGPdqr5iF7_DT2S0wo,4159
 dataeval/utils/torch/models.py,sha256=1idpXyjrYcCBSsbxxRUOto8xr4MJNjDEqQHiIXVU5Zc,9700
 dataeval/utils/torch/trainer.py,sha256=Oc2lK13uPGhmLYbmAqlPWyKxgG4YJFlnSXCqFHUZbdA,5528
 dataeval/workflows/__init__.py,sha256=ou8y0KO-d6W5lgmcyLjKlf-J_ckP3vilW7wHkgiDlZ4,255
 dataeval/workflows/sufficiency.py,sha256=j-R8dg4XE6a66p_oTXG2GNzgg3vGk85CTblxhFXaxog,8513
-dataeval-0.86.4.dist-info/LICENSE.txt,sha256=uAooygKWvX6NbU9Ran9oG2msttoG8aeTeHSTe5JeCnY,1061
-dataeval-0.86.4.dist-info/METADATA,sha256=qdxTuVh3WxpHvsdRZhAvQIYxiATJLDixoF97xMFYrXM,5353
-dataeval-0.86.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-dataeval-0.86.4.dist-info/RECORD,,
+dataeval-0.86.6.dist-info/LICENSE.txt,sha256=uAooygKWvX6NbU9Ran9oG2msttoG8aeTeHSTe5JeCnY,1061
+dataeval-0.86.6.dist-info/METADATA,sha256=pHhjYhbE3BlgvxtINd333FwljVfELIKQnplaAwLNZVg,5353
+dataeval-0.86.6.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dataeval-0.86.6.dist-info/RECORD,,