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

dataeval/_internal/workflows/sufficiency.py

@@ -1,4 +1,5 @@
 import warnings
+from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional, Sequence, Union, cast
 
 import matplotlib.pyplot as plt
@@ -6,57 +7,80 @@ import numpy as np
 import torch
 import torch.nn as nn
 from matplotlib.figure import Figure
+from numpy.typing import NDArray
 from scipy.optimize import basinhopping
 from torch.utils.data import Dataset
 
-from dataeval._internal.metrics.base import EvaluateMixin
+from dataeval._internal.output import OutputMetadata, set_metadata
 
-STEPS_KEY = "_STEPS_"
-PARAMS_KEY = "_CURVE_PARAMS_"
 
-SufficiencyOutput = Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]
+@dataclass(frozen=True)
+class SufficiencyOutput(OutputMetadata):
+    """
+    Attributes
+    ----------
+    steps : NDArray[np.uint32]
+        Array of sample sizes
+    params : Dict[str, NDArray[np.float64]]
+        Inverse power curve coefficients for the line of best fit for each measure
+    measures : Dict[str, NDArray[np.float64]]
+        Average of values observed for each sample size step for each measure
+    """
+
+    steps: NDArray[np.uint32]
+    params: Dict[str, NDArray[np.float64]]
+    measures: Dict[str, NDArray[np.float64]]
 
+    def __post_init__(self):
+        c = len(self.steps)
+        if set(self.params) != set(self.measures):
+            raise ValueError("params and measures have a key mismatch")
+        for m, v in self.measures.items():
+            c_v = v.shape[1] if v.ndim > 1 else len(v)
+            if c != c_v:
+                raise ValueError(f"{m} does not contain the expected number ({c}) of data points.")
 
-def f_out(n_i: np.ndarray, x: np.ndarray) -> np.ndarray:
+
+def f_out(n_i: NDArray, x: NDArray) -> NDArray:
     """
     Calculates the line of best fit based on its free parameters
 
     Parameters
     ----------
-    n_i : np.ndarray
+    n_i : NDArray
         Array of sample sizes
-    x : np.ndarray
+    x : NDArray
         Array of inverse power curve coefficients
 
     Returns
     -------
-    np.ndarray
+    NDArray
         Data points for the line of best fit
     """
     return x[0] * n_i ** (-x[1]) + x[2]
 
 
-def f_inv_out(y_i: np.ndarray, x: np.ndarray) -> np.ndarray:
+def f_inv_out(y_i: NDArray, x: NDArray) -> NDArray[np.uint64]:
     """
     Inverse function for f_out()
 
     Parameters
     ----------
-    y_i : np.ndarray
+    y_i : NDArray
         Data points for the line of best fit
-    x : np.ndarray
+    x : NDArray
         Array of inverse power curve coefficients
 
     Returns
     -------
-    np.ndarray
+    NDArray[np.uint64]
         Array of sample sizes
     """
     n_i = ((y_i - x[2]) / x[0]) ** (-1 / x[1])
-    return n_i
+    return np.asarray(n_i, dtype=np.uint64)
 
 
-def calc_params(p_i: np.ndarray, n_i: np.ndarray, niter: int) -> np.ndarray:
+def calc_params(p_i: NDArray, n_i: NDArray, niter: int) -> NDArray:
     """
     Retrieves the inverse power curve coefficients for the line of best fit.
     Global minimization is done via basin hopping. More info on this algorithm
@@ -64,9 +88,9 @@ def calc_params(p_i: np.ndarray, n_i: np.ndarray, niter: int) -> np.ndarray:
 
     Parameters
     ----------
-    p_i : np.ndarray
+    p_i : NDArray
         Array of corresponding losses
-    n_i : np.ndarray
+    n_i : NDArray
         Array of sample sizes
     niter : int
         Number of iterations to perform in the basin-hopping
@@ -74,7 +98,7 @@ def calc_params(p_i: np.ndarray, n_i: np.ndarray, niter: int) -> np.ndarray:
 
     Returns
     -------
-    np.ndarray
+    NDArray
         Array of parameters to recreate line of best fit
     """
 
@@ -128,60 +152,46 @@ def validate_dataset_len(dataset: Dataset) -> int:
     return length
 
 
-def validate_output(data: SufficiencyOutput):
-    """Ensure the sufficiency data used is not malformed"""
-    if not all(key in data for key in [STEPS_KEY, PARAMS_KEY]):
-        raise KeyError(f"{STEPS_KEY} and {PARAMS_KEY} are required keys for Sufficiency output.")
-    c = len(data[STEPS_KEY])
-    for m, v in data.items():
-        if m in [STEPS_KEY, PARAMS_KEY]:
-            continue
-        v = cast(np.ndarray, v)
-        c_v = v.shape[1] if v.ndim > 1 else len(v)
-        if c != c_v:
-            raise ValueError("f{m} does not contain the expected number ({c}) of data points.")
-
-
-def project_steps(params: np.ndarray, projection: np.ndarray) -> np.ndarray:
+def project_steps(params: NDArray, projection: NDArray) -> NDArray:
     """Projects the measures for each value of X
 
     Parameters
     ----------
-    params : np.ndarray
+    params : NDArray
         Inverse power curve coefficients used to calculate projection
-    projection : np.ndarray
+    projection : NDArray
         Steps to extrapolate
 
     Returns
     -------
-    np.ndarray
+    NDArray
         Extrapolated measure values at each projection step
 
     """
     return 1 - f_out(projection, params)
 
 
-def inv_project_steps(params: np.ndarray, targets: np.ndarray) -> np.ndarray:
+def inv_project_steps(params: NDArray, targets: NDArray) -> NDArray[np.uint64]:
     """Inverse function for project_steps()
 
     Parameters
     ----------
-    params : np.ndarray
+    params : NDArray
         Inverse power curve coefficients used to calculate projection
-    targets : np.ndarray
+    targets : NDArray
         Desired measure values
 
     Returns
     -------
-    np.ndarray
+    NDArray[np.uint64]
         Array of sample sizes, or 0 if overflow
     """
     steps = f_inv_out(1 - np.array(targets), params)
     steps[np.isnan(steps)] = 0
-    return np.ceil(steps).astype(np.int64)
+    return np.ceil(steps)
 
 
-def get_curve_params(measures: Dict[str, np.ndarray], ranges: np.ndarray, niter: int) -> Dict[str, np.ndarray]:
+def get_curve_params(measures: Dict[str, NDArray], ranges: NDArray, niter: int) -> Dict[str, NDArray]:
     """Calculates and aggregates parameters for both single and multi-class metrics"""
     output = {}
     for name, measure in measures.items():
@@ -198,10 +208,10 @@ def get_curve_params(measures: Dict[str, np.ndarray], ranges: np.ndarray, niter:
 
 def plot_measure(
     name: str,
-    steps: np.ndarray,
-    measure: np.ndarray,
-    params: np.ndarray,
-    projection: np.ndarray,
+    steps: NDArray,
+    measure: NDArray,
+    params: NDArray,
+    projection: NDArray,
 ) -> Figure:
     fig = plt.figure()
     fig = cast(Figure, fig)
@@ -228,7 +238,7 @@ def plot_measure(
     return fig
 
 
-class Sufficiency(EvaluateMixin):
+class Sufficiency:
     """
     Project dataset sufficiency using given a model and evaluation criteria
 
@@ -265,7 +275,7 @@ class Sufficiency(EvaluateMixin):
         train_ds: Dataset,
         test_ds: Dataset,
         train_fn: Callable[[nn.Module, Dataset, Sequence[int]], None],
-        eval_fn: Callable[[nn.Module, Dataset], Union[Dict[str, float], Dict[str, np.ndarray]]],
+        eval_fn: Callable[[nn.Module, Dataset], Union[Dict[str, float], Dict[str, NDArray]]],
         runs: int = 1,
         substeps: int = 5,
         train_kwargs: Optional[Dict[str, Any]] = None,
@@ -312,13 +322,13 @@ class Sufficiency(EvaluateMixin):
     @property
     def eval_fn(
         self,
-    ) -> Callable[[nn.Module, Dataset], Union[Dict[str, float], Dict[str, np.ndarray]]]:
+    ) -> Callable[[nn.Module, Dataset], Union[Dict[str, float], Dict[str, NDArray]]]:
         return self._eval_fn
 
     @eval_fn.setter
     def eval_fn(
         self,
-        value: Callable[[nn.Module, Dataset], Union[Dict[str, float], Dict[str, np.ndarray]]],
+        value: Callable[[nn.Module, Dataset], Union[Dict[str, float], Dict[str, NDArray]]],
     ):
         if not callable(value):
             raise TypeError("Must provide a callable for eval_fn.")
@@ -340,13 +350,14 @@ class Sufficiency(EvaluateMixin):
     def eval_kwargs(self, value: Optional[Dict[str, Any]]):
         self._eval_kwargs = {} if value is None else value
 
-    def evaluate(self, eval_at: Optional[np.ndarray] = None, niter: int = 1000) -> SufficiencyOutput:
+    @set_metadata("dataeval.workflows", ["runs", "substeps"])
+    def evaluate(self, eval_at: Optional[NDArray] = None, niter: int = 1000) -> SufficiencyOutput:
         """
         Creates data indices, trains models, and returns plotting data
 
         Parameters
         ----------
-        eval_at : Optional[np.ndarray]
+        eval_at : Optional[NDArray]
             Specify this to collect accuracies over a specific set of dataset lengths, rather
             than letting Sufficiency internally create the lengths to evaluate at.
         niter : int, default 1000
@@ -354,8 +365,8 @@ class Sufficiency(EvaluateMixin):
 
         Returns
         -------
-        Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]
-            Dictionary containing the average of each measure per substep
+        SufficiencyOutput
+            Dataclass containing the average of each measure per substep
         """
         if eval_at is not None:
             ranges = eval_at
@@ -365,7 +376,7 @@ class Sufficiency(EvaluateMixin):
                 self._length,
                 self.substeps,
             )  # Start, Stop, Num steps
-            ranges = np.geomspace(*geomshape).astype(np.int64)
+            ranges = np.geomspace(*geomshape, dtype=np.uint32)
         substeps = len(ranges)
         measures = {}
 
@@ -381,7 +392,7 @@ class Sufficiency(EvaluateMixin):
                 self.train_fn(
                     model,
                     self.train_ds,
-                    indices[:substep].tolist(),
+                    indices[: int(substep)].tolist(),
                     **self.train_kwargs,
                 )
 
@@ -390,9 +401,6 @@ class Sufficiency(EvaluateMixin):
 
                 # Keep track of each measures values
                 for name, value in measure.items():
-                    if name in [STEPS_KEY, PARAMS_KEY]:
-                        raise KeyError(f"Cannot use reserved name '{name}' as a metric name.")
-
                     # Sum result into current substep iteration to be averaged later
                     value = np.array(value).ravel()
                     if name not in measures:
@@ -402,57 +410,50 @@ class Sufficiency(EvaluateMixin):
         # The mean for each measure must be calculated before being returned
         measures = {k: (v / self.runs).T for k, v in measures.items()}
         params_output = get_curve_params(measures, ranges, niter)
-        output = {STEPS_KEY: ranges, PARAMS_KEY: params_output}
-        output.update(measures)
-        return output
+        return SufficiencyOutput(ranges, params_output, measures)
 
     @classmethod
     def project(
         cls,
         data: SufficiencyOutput,
-        projection: Union[int, Sequence[int], np.ndarray],
-    ) -> Dict[str, np.ndarray]:
+        projection: Union[int, Sequence[int], NDArray[np.uint]],
+    ) -> SufficiencyOutput:
         """Projects the measures for each value of X
 
         Parameters
         ----------
-        data : Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]
+        data : SufficiencyOutput
             Dataclass containing the average of each measure per substep
-        steps : Union[int, np.ndarray]
+        projection : Union[int, Sequence[int], NDArray[np.uint]]
             Step or steps to project
-        niter : int, default 200
-            Number of iterations to perform in the basin-hopping
-            numerical process to curve-fit data
+
+        Returns
+        -------
+        SufficiencyOutput
+            Dataclass containing the projected measures per projection
 
         Raises
         ------
-        KeyError
-            If STEPS_KEY or measure is not a valid key
         ValueError
             If the length of data points in the measures do not match
             If the steps are not int, Sequence[int] or an ndarray
         """
-        validate_output(data)
         projection = [projection] if isinstance(projection, int) else projection
         projection = np.array(projection) if isinstance(projection, Sequence) else projection
         if not isinstance(projection, np.ndarray):
             raise ValueError("'steps' must be an int, Sequence[int] or ndarray")
 
         output = {}
-        output[STEPS_KEY] = projection
-        for name, measures in data.items():
-            if name in [STEPS_KEY, PARAMS_KEY]:
-                continue
-            measures = cast(np.ndarray, measures)
+        for name, measures in data.measures.items():
             if measures.ndim > 1:
                 result = []
                 for i in range(len(measures)):
-                    projected = project_steps(data[PARAMS_KEY][name][i], projection)
+                    projected = project_steps(data.params[name][i], projection)
                     result.append(projected)
-                output[name] = np.array(result).T
+                output[name] = np.array(result)
             else:
-                output[name] = project_steps(data[PARAMS_KEY][name], projection)
-        return output
+                output[name] = project_steps(data.params[name], projection)
+        return SufficiencyOutput(projection, data.params, output)
 
     @classmethod
     def plot(cls, data: SufficiencyOutput, class_names: Optional[Sequence[str]] = None) -> List[Figure]:
@@ -460,7 +461,7 @@ class Sufficiency(EvaluateMixin):
 
         Parameters
         ----------
-        data : Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]
+        data : SufficiencyOutput
             Dataclass containing the average of each measure per substep
 
         Returns
@@ -470,29 +471,19 @@ class Sufficiency(EvaluateMixin):
 
         Raises
         ------
-        KeyError
-            If STEPS_KEY or measure is not a valid key
         ValueError
             If the length of data points in the measures do not match
         """
-        validate_output(data)
-
-        # X, y data
-        steps = cast(np.ndarray, data[STEPS_KEY])
-
         # Extrapolation parameters
-        last_X = steps[-1]
-        geomshape = (0.01 * last_X, last_X * 4, len(steps))
+        last_X = data.steps[-1]
+        geomshape = (0.01 * last_X, last_X * 4, len(data.steps))
         extrapolated = np.geomspace(*geomshape).astype(np.int64)
 
         # Stores all plots
         plots = []
 
         # Create a plot for each measure on one figure
-        for name, measures in data.items():
-            if name in [STEPS_KEY, PARAMS_KEY]:
-                continue
-            measures = cast(np.ndarray, measures)
+        for name, measures in data.measures.items():
             if measures.ndim > 1:
                 if class_names is not None and len(measures) != len(class_names):
                     raise IndexError("Class name count does not align with measures")
@@ -500,56 +491,54 @@ class Sufficiency(EvaluateMixin):
                     class_name = str(i) if class_names is None else class_names[i]
                     fig = plot_measure(
                         f"{name}_{class_name}",
-                        steps,
+                        data.steps,
                         measure,
-                        data[PARAMS_KEY][name][i],
+                        data.params[name][i],
                         extrapolated,
                     )
                     plots.append(fig)
 
             else:
-                fig = plot_measure(name, steps, measures, data[PARAMS_KEY][name], extrapolated)
+                fig = plot_measure(name, data.steps, measures, data.params[name], extrapolated)
                 plots.append(fig)
 
         return plots
 
     @classmethod
-    def inv_project(cls, targets: Dict[str, np.ndarray], data: SufficiencyOutput) -> Dict[str, np.ndarray]:
+    def inv_project(cls, targets: Dict[str, NDArray], data: SufficiencyOutput) -> Dict[str, NDArray]:
         """
         Calculate training samples needed to achieve target model metric values.
 
         Parameters
         ----------
-        targets : Dict[str, np.ndarray]
+        targets : Dict[str, NDArray]
             Dictionary of target metric scores (from 0.0 to 1.0) that we want
             to achieve, where the key is the name of the metric.
 
-        data : Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]
+        data : SufficiencyOutput
             Dataclass containing the average of each measure per substep
 
         Returns
         -------
-        Dict[str, np.ndarray]
+        Dict[str, NDArray]
             List of the number of training samples needed to achieve each
             corresponding entry in targets
         """
 
-        validate_output(data)
-
         projection = {}
 
         for name, target in targets.items():
-            if name not in data:
+            if name not in data.measures:
                 continue
 
-            measure = cast(np.ndarray, data[name])
+            measure = data.measures[name]
             if measure.ndim > 1:
                 projection[name] = np.zeros((len(measure), len(target)))
                 for i in range(len(measure)):
                     projection[name][i] = inv_project_steps(
-                        data[PARAMS_KEY][name][i], target[i] if target.ndim == measure.ndim else target
+                        data.params[name][i], target[i] if target.ndim == measure.ndim else target
                     )
             else:
-                projection[name] = inv_project_steps(data[PARAMS_KEY][name], target)
+                projection[name] = inv_project_steps(data.params[name], target)
 
         return projection

dataeval/flags/__init__.py

@@ -1,3 +1,3 @@
-from dataeval._internal.flags import ImageHash, ImageProperty, ImageStatistics, ImageVisuals
+from dataeval._internal.flags import ImageStat
 
-__all__ = ["ImageHash", "ImageProperty", "ImageStatistics", "ImageVisuals"]
+__all__ = ["ImageStat"]

dataeval/metrics/__init__.py

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

dataeval/utils/__init__.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.63.0
+Version: 0.65.0
 Summary: DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks
 Home-page: https://dataeval.ai/
 License: MIT

dataeval-0.65.0.dist-info/RECORD

@@ -0,0 +1,60 @@
+dataeval/__init__.py,sha256=Uok47bAn3XhZppFB7u2BAVel5MDFpXC-1fEFlrWBIi8,424
+dataeval/_internal/detectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/clusterer.py,sha256=QHME6JQBqQe0xgEDuOGav6EDZFFq1hNiVde-DfUdNKU,20697
+dataeval/_internal/detectors/drift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/drift/base.py,sha256=0Vs69uctnC17pLhJ53rhDsQ8DLlZAj06LDCVGJhsMYo,9298
+dataeval/_internal/detectors/drift/cvm.py,sha256=5tmD6uBumJgBS3u6e46Az13ytWSIScAAImvPHNk4PDA,4052
+dataeval/_internal/detectors/drift/ks.py,sha256=FKHbJ4GR3kkADjPkf2CrjumIILEvuVUynjrOAFsK5no,4046
+dataeval/_internal/detectors/drift/mmd.py,sha256=n5Z2tvpX41J5UPEE1JsJVBnVhGwZp3ADmLXEqFyXiek,7653
+dataeval/_internal/detectors/drift/torch.py,sha256=zd2PcvSQ7j0rLwq8CvGpF9o8v5cVYZJFGv4jetU2PDo,10890
+dataeval/_internal/detectors/drift/uncertainty.py,sha256=TZ1JIoZ9HRnrHupfPHvGT1P0gR-hYdH9bsigzJr_QcE,5311
+dataeval/_internal/detectors/duplicates.py,sha256=VjunPZ9ffhVNFda9OIvnfE7QCvdA7OOfQMWEzDn2mdU,2973
+dataeval/_internal/detectors/linter.py,sha256=gC-KDajxyNyBtCphtC2NULjeXmFx-d15GKF9I-MNOdI,5866
+dataeval/_internal/detectors/ood/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/detectors/ood/ae.py,sha256=FjqMucicFsDIKJMAOjWpKBohrPM4F1ubFLJk91GVqio,2681
+dataeval/_internal/detectors/ood/aegmm.py,sha256=Kf9R5q-hoRg6RUHlJG-2oo52ZKeQmJQbxG0kFtHh6zA,2416
+dataeval/_internal/detectors/ood/base.py,sha256=ybY4DJeQrzY62tEFnaFnAUL0ILkulOes63aA09jKynw,7633
+dataeval/_internal/detectors/ood/llr.py,sha256=Amj3MFmoE0wi60qsHF7qMGRzO3ZeUW4ywUcLppx1ZQw,10160
+dataeval/_internal/detectors/ood/vae.py,sha256=ntabTTTmPhJ18giZ7A64mxpJvTH9pIHmHPGGnu-gA8g,2987
+dataeval/_internal/detectors/ood/vaegmm.py,sha256=opBfFLuXEAIMa8E6scwf-GWbZbuXnsqXlXTbLN4MoYg,2861
+dataeval/_internal/flags.py,sha256=BKRYNvANpleVb1DGWqZASl_CB-BOa4UnamFY2So53Cc,2152
+dataeval/_internal/interop.py,sha256=kX6lsEb7xoMD3iRG8GUp4uLbCCoC4Rb33PS6CHUl7BU,1036
+dataeval/_internal/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/metrics/balance.py,sha256=gD0Vm6Y55v6byfCJQi1c6cj9YzsDfCsHsEmFu8OrR1E,6758
+dataeval/_internal/metrics/ber.py,sha256=bz7l3RqM54mYUwA8pqk9gq5GMFeRCNMD-65Prm9BV3w,4628
+dataeval/_internal/metrics/coverage.py,sha256=9ZvcNjItE9rEyA2UHPE1K9zpTbbib4xqk8WpPpDN8ok,4037
+dataeval/_internal/metrics/divergence.py,sha256=nmMUfr9FGnH798eb6xzEiMj4C42rQVthh5HeexiY6EE,4119
+dataeval/_internal/metrics/diversity.py,sha256=dAgKaqY1J5cHy0JPUIN3kuW6NyS3wUb76w0EDipQaE4,7148
+dataeval/_internal/metrics/parity.py,sha256=kOKw-B0RuralYxfBx5FiwyRn9kzR0uM9n8dpA7yebBI,11463
+dataeval/_internal/metrics/stats.py,sha256=Fg1HZIQ1PWX4kgakN5wOOS627_vKt40nzvlzdjh7Q-E,8752
+dataeval/_internal/metrics/uap.py,sha256=jv0ATJ5t5tEnKfcbuqB7KanO1n9dsqDsn42riJpG0M4,1307
+dataeval/_internal/metrics/utils.py,sha256=izd1jimtLP0L__OERITqs0ppvYLL0PTlAC3kDfh3GOE,13037
+dataeval/_internal/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/models/pytorch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/models/pytorch/autoencoder.py,sha256=iK3Z9claesU_pJkRaiFJIZ9zKZg-Qj8ugzVYTTokDbE,6123
+dataeval/_internal/models/pytorch/blocks.py,sha256=pm2xwsDZjZJYXrhhiz8husvh2vHmrkFMSYEn-EDUD5Q,1354
+dataeval/_internal/models/pytorch/utils.py,sha256=Qgwym1PxGuwxbXCKUT-8r6Iyrxqm7x94oj45Vf5_CjE,1675
+dataeval/_internal/models/tensorflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/models/tensorflow/autoencoder.py,sha256=rErnOfDFTd7e4brSGQ2Lr1x1kNjSEHdbOREOtUfIhIM,9975
+dataeval/_internal/models/tensorflow/gmm.py,sha256=wnqQKm3fURuvBROUd2fitCqzKViDo-g0-Djr3TBHZ3U,3640
+dataeval/_internal/models/tensorflow/losses.py,sha256=24gDqrA-EBg9J9tkLuXYZzbkwUjjAX8c1RAtN0o72xA,3774
+dataeval/_internal/models/tensorflow/pixelcnn.py,sha256=B5cwB2IGPw-7b8klt82j_60g_IvqSiDELxvbiBYJtAo,48068
+dataeval/_internal/models/tensorflow/trainer.py,sha256=rHWRHrX5hMj2iNZD9HqzfhPvqLwR2g-Aw-68Vq2_U94,4117
+dataeval/_internal/models/tensorflow/utils.py,sha256=G7JpmjmWlJtqqHdxnbiBRVQjAXYFTqShii5Yz_Ici9U,8603
+dataeval/_internal/output.py,sha256=L-EbpcdyZR2-NvsEKJkVpHXcyr3chdydbGNqoeXl-lI,2975
+dataeval/_internal/utils.py,sha256=umvc_vN5c5IR0lz2F1U2YjA3VZloKTAEp9BQx8rSk6g,1561
+dataeval/_internal/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/_internal/workflows/sufficiency.py,sha256=BNl11OOrAjpyAIXeVhbGbJJ_tQDwZjXRW6dnlb6LYPM,17781
+dataeval/detectors/__init__.py,sha256=I2e7YWb55RRlKQll85Z6KdN5wdBa53smn-_fcZIsCwA,1507
+dataeval/flags/__init__.py,sha256=qo06_Tk0ul4lOhKSEs0HE2G6WBFvMwNJq77vRX1ynww,72
+dataeval/metrics/__init__.py,sha256=eGL4LMxM1pTWwsT8HI-aIA7pZ2EPGFVIa86rG2LlVXs,787
+dataeval/models/__init__.py,sha256=onevPb5wznCggowBnVT0OUa8uBJXZCbrkFuek1UFvOs,293
+dataeval/models/tensorflow/__init__.py,sha256=A1XRxVGHefuvh_WpaKE1x95pRD1FecuFp66iuNPA_5U,424
+dataeval/models/torch/__init__.py,sha256=su7P9DF9LChlVCNHWG6d7s_yeIfWQbhCYWIkzJe0Qig,190
+dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/utils/__init__.py,sha256=bgUXeumTEspt2Q76YyEliGrnS-_incswY-pDexPdSCc,229
+dataeval/workflows/__init__.py,sha256=ObgS1cVYFRzFZWbNzGs2OcU02IVkJkAMHNnlnSNTMCE,208
+dataeval-0.65.0.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.65.0.dist-info/METADATA,sha256=-bjqI2XgbnRnGoHU3qf0NLfdHYY4bW5cm5tx__ux8zU,4217
+dataeval-0.65.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+dataeval-0.65.0.dist-info/RECORD,,

dataeval/_internal/functional/ber.py

@@ -1,63 +0,0 @@
-from typing import Tuple
-
-import numpy as np
-from scipy.sparse import coo_matrix
-from scipy.stats import mode
-
-from dataeval._internal.functional.utils import compute_neighbors, get_classes_counts, minimum_spanning_tree
-
-
-def ber_mst(X: np.ndarray, y: np.ndarray, _: int) -> Tuple[float, float]:
-    """Calculates the Bayes Error Rate using a minimum spanning tree
-
-    Parameters
-    ----------
-    X : np.ndarray (N, :)
-        Data points with arbitrary dimensionality
-    y : np.ndarray (N, 1)
-        Labels for each data point
-    """
-
-    M, N = get_classes_counts(y)
-
-    tree = coo_matrix(minimum_spanning_tree(X))
-    matches = np.sum([y[tree.row[i]] != y[tree.col[i]] for i in range(N - 1)])
-    deltas = matches / (2 * N)
-    upper = 2 * deltas
-    lower = ((M - 1) / (M)) * (1 - max(1 - 2 * ((M) / (M - 1)) * deltas, 0) ** 0.5)
-    return upper, lower
-
-
-def ber_knn(X: np.ndarray, y: np.ndarray, k: int) -> Tuple[float, float]:
-    """Calculates the Bayes Error Rate using K-nearest neighbors"""
-
-    M, N = get_classes_counts(y)
-
-    # All features belong on second dimension
-    X = X.reshape((X.shape[0], -1))
-    nn_indices = compute_neighbors(X, X, k=k)
-    nn_indices = np.expand_dims(nn_indices, axis=1) if nn_indices.ndim == 1 else nn_indices
-    modal_class = mode(y[nn_indices], axis=1, keepdims=True).mode.squeeze()
-    upper = float(np.count_nonzero(modal_class - y) / N)
-    lower = _knn_lowerbound(upper, M, k)
-    return upper, lower
-
-
-def _knn_lowerbound(value: float, classes: int, k: int) -> float:
-    """Several cases for computing the BER lower bound"""
-    if value <= 1e-10:
-        return 0.0
-
-    if classes == 2 and k != 1:
-        if k > 5:
-            # Property 2 (Devroye, 1981) cited in Snoopy paper, not in snoopy repo
-            alpha = 0.3399
-            beta = 0.9749
-            a_k = alpha * np.sqrt(k) / (k - 3.25) * (1 + beta / (np.sqrt(k - 3)))
-            return value / (1 + a_k)
-        if k > 2:
-            return value / (1 + (1 / np.sqrt(k)))
-        # k == 2:
-        return value / 2
-
-    return ((classes - 1) / classes) * (1 - np.sqrt(max(0, 1 - ((classes / (classes - 1)) * value))))