dataeval 0.72.0__py3-none-any.whl → 0.72.2__py3-none-any.whl

dataeval/{_internal/workflows → workflows}/sufficiency.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+__all__ = ["SufficiencyOutput", "Sufficiency"]
+
 import warnings
 from dataclasses import dataclass
-from typing import Any, Callable, Iterable, Mapping, Sequence, cast
+from typing import Any, Callable, Generic, Iterable, Mapping, Sequence, TypeVar, cast
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -13,8 +15,8 @@ from numpy.typing import ArrayLike, NDArray
 from scipy.optimize import basinhopping
 from torch.utils.data import Dataset
 
-from dataeval._internal.interop import as_numpy
-from dataeval._internal.output import OutputMetadata, set_metadata
+from dataeval.interop import as_numpy
+from dataeval.output import OutputMetadata, set_metadata
 
 
 @dataclass(frozen=True)
@@ -36,7 +38,7 @@ class SufficiencyOutput(OutputMetadata):
     params: dict[str, NDArray[np.float64]]
     measures: dict[str, NDArray[np.float64]]
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         c = len(self.steps)
         if set(self.params) != set(self.measures):
             raise ValueError("params and measures have a key mismatch")
@@ -45,7 +47,7 @@ class SufficiencyOutput(OutputMetadata):
             if c != c_v:
                 raise ValueError(f"{m} does not contain the expected number ({c}) of data points.")
 
-    @set_metadata("dataeval.workflows.SufficiencyOutput")
+    @set_metadata()
     def project(
         self,
         projection: int | Iterable[int],
@@ -86,7 +88,7 @@ class SufficiencyOutput(OutputMetadata):
         return SufficiencyOutput(projection, self.params, output)
 
     def plot(self, class_names: Sequence[str] | None = None) -> list[Figure]:
-        """Plotting function for data sufficiency tasks
+        """Plotting function for data :term:`sufficience<Sufficiency>` tasks
 
         Parameters
         ----------
@@ -170,7 +172,7 @@ class SufficiencyOutput(OutputMetadata):
         return projection
 
 
-def f_out(n_i: NDArray, x: NDArray) -> NDArray:
+def f_out(n_i: NDArray[Any], x: NDArray[Any]) -> NDArray[Any]:
     """
     Calculates the line of best fit based on its free parameters
 
@@ -189,7 +191,7 @@ def f_out(n_i: NDArray, x: NDArray) -> NDArray:
     return x[0] * n_i ** (-x[1]) + x[2]
 
 
-def f_inv_out(y_i: NDArray, x: NDArray) -> NDArray[np.uint64]:
+def f_inv_out(y_i: NDArray[Any], x: NDArray[Any]) -> NDArray[np.uint64]:
     """
     Inverse function for f_out()
 
@@ -209,7 +211,7 @@ def f_inv_out(y_i: NDArray, x: NDArray) -> NDArray[np.uint64]:
     return np.asarray(n_i, dtype=np.uint64)
 
 
-def calc_params(p_i: NDArray, n_i: NDArray, niter: int) -> NDArray:
+def calc_params(p_i: NDArray[Any], n_i: NDArray[Any], niter: int) -> NDArray[Any]:
     """
     Retrieves the inverse power curve coefficients for the line of best fit.
     Global minimization is done via basin hopping. More info on this algorithm
@@ -254,7 +256,7 @@ def calc_params(p_i: NDArray, n_i: NDArray, niter: int) -> NDArray:
     return res.x
 
 
-def reset_parameters(model: nn.Module):
+def reset_parameters(model: nn.Module) -> nn.Module:
     """
     Re-initializes each layer in the model using
     the layer's defined weight_init function
@@ -272,7 +274,7 @@ def reset_parameters(model: nn.Module):
     return model.apply(fn=weight_reset)
 
 
-def validate_dataset_len(dataset: Dataset) -> int:
+def validate_dataset_len(dataset: Dataset[Any]) -> int:
     if not hasattr(dataset, "__len__"):
         raise TypeError("Must provide a dataset with a length attribute")
     length: int = dataset.__len__()  # type: ignore
@@ -281,7 +283,7 @@ def validate_dataset_len(dataset: Dataset) -> int:
     return length
 
 
-def project_steps(params: NDArray, projection: NDArray) -> NDArray:
+def project_steps(params: NDArray[Any], projection: NDArray[Any]) -> NDArray[Any]:
     """Projects the measures for each value of X
 
     Parameters
@@ -300,7 +302,7 @@ def project_steps(params: NDArray, projection: NDArray) -> NDArray:
     return 1 - f_out(projection, params)
 
 
-def inv_project_steps(params: NDArray, targets: NDArray) -> NDArray[np.uint64]:
+def inv_project_steps(params: NDArray[Any], targets: NDArray[Any]) -> NDArray[np.uint64]:
     """Inverse function for project_steps()
 
     Parameters
@@ -320,7 +322,7 @@ def inv_project_steps(params: NDArray, targets: NDArray) -> NDArray[np.uint64]:
     return np.ceil(steps)
 
 
-def get_curve_params(measures: dict[str, NDArray], ranges: NDArray, niter: int) -> dict[str, NDArray]:
+def get_curve_params(measures: dict[str, NDArray[Any]], ranges: NDArray[Any], niter: int) -> dict[str, NDArray[Any]]:
     """Calculates and aggregates parameters for both single and multi-class metrics"""
     output = {}
     for name, measure in measures.items():
@@ -337,10 +339,10 @@ def get_curve_params(measures: dict[str, NDArray], ranges: NDArray, niter: int)
 
 def plot_measure(
     name: str,
-    steps: NDArray,
-    measure: NDArray,
-    params: NDArray,
-    projection: NDArray,
+    steps: NDArray[Any],
+    measure: NDArray[Any],
+    params: NDArray[Any],
+    projection: NDArray[Any],
 ) -> Figure:
     fig = plt.figure()
     fig = cast(Figure, fig)
@@ -367,9 +369,12 @@ def plot_measure(
     return fig
 
 
-class Sufficiency:
+T = TypeVar("T")
+
+
+class Sufficiency(Generic[T]):
     """
-    Project dataset sufficiency using given a model and evaluation criteria
+    Project dataset :term:`sufficiency<Sufficiency>` using given a model and evaluation criteria
 
     Parameters
     ----------
@@ -401,10 +406,10 @@ class Sufficiency:
     def __init__(
         self,
         model: nn.Module,
-        train_ds: Dataset,
-        test_ds: Dataset,
-        train_fn: Callable[[nn.Module, Dataset, Sequence[int]], None],
-        eval_fn: Callable[[nn.Module, Dataset], Mapping[str, float] | Mapping[str, ArrayLike]],
+        train_ds: Dataset[T],
+        test_ds: Dataset[T],
+        train_fn: Callable[[nn.Module, Dataset[T], Sequence[int]], None],
+        eval_fn: Callable[[nn.Module, Dataset[T]], Mapping[str, float] | Mapping[str, ArrayLike]],
         runs: int = 1,
         substeps: int = 5,
         train_kwargs: Mapping[str, Any] | None = None,
@@ -421,29 +426,29 @@ class Sufficiency:
         self.eval_kwargs = eval_kwargs
 
     @property
-    def train_ds(self):
+    def train_ds(self) -> Dataset[T]:
         return self._train_ds
 
     @train_ds.setter
-    def train_ds(self, value: Dataset):
+    def train_ds(self, value: Dataset[T]) -> None:
         self._train_ds = value
         self._length = validate_dataset_len(value)
 
     @property
-    def test_ds(self):
+    def test_ds(self) -> Dataset[T]:
         return self._test_ds
 
     @test_ds.setter
-    def test_ds(self, value: Dataset):
+    def test_ds(self, value: Dataset[T]) -> None:
         validate_dataset_len(value)
         self._test_ds = value
 
     @property
-    def train_fn(self) -> Callable[[nn.Module, Dataset, Sequence[int]], None]:
+    def train_fn(self) -> Callable[[nn.Module, Dataset[T], Sequence[int]], None]:
         return self._train_fn
 
     @train_fn.setter
-    def train_fn(self, value: Callable[[nn.Module, Dataset, Sequence[int]], None]):
+    def train_fn(self, value: Callable[[nn.Module, Dataset[T], Sequence[int]], None]) -> None:
         if not callable(value):
             raise TypeError("Must provide a callable for train_fn.")
         self._train_fn = value
@@ -451,14 +456,14 @@ class Sufficiency:
     @property
     def eval_fn(
         self,
-    ) -> Callable[[nn.Module, Dataset], dict[str, float] | Mapping[str, ArrayLike]]:
+    ) -> Callable[[nn.Module, Dataset[T]], dict[str, float] | Mapping[str, ArrayLike]]:
         return self._eval_fn
 
     @eval_fn.setter
     def eval_fn(
         self,
-        value: Callable[[nn.Module, Dataset], dict[str, float] | Mapping[str, ArrayLike]],
-    ):
+        value: Callable[[nn.Module, Dataset[T]], dict[str, float] | Mapping[str, ArrayLike]],
+    ) -> None:
         if not callable(value):
             raise TypeError("Must provide a callable for eval_fn.")
         self._eval_fn = value
@@ -468,7 +473,7 @@ class Sufficiency:
         return self._train_kwargs
 
     @train_kwargs.setter
-    def train_kwargs(self, value: Mapping[str, Any] | None):
+    def train_kwargs(self, value: Mapping[str, Any] | None) -> None:
         self._train_kwargs = {} if value is None else value
 
     @property
@@ -476,10 +481,10 @@ class Sufficiency:
         return self._eval_kwargs
 
     @eval_kwargs.setter
-    def eval_kwargs(self, value: Mapping[str, Any] | None):
+    def eval_kwargs(self, value: Mapping[str, Any] | None) -> None:
         self._eval_kwargs = {} if value is None else value
 
-    @set_metadata("dataeval.workflows", ["runs", "substeps"])
+    @set_metadata(["runs", "substeps"])
     def evaluate(self, eval_at: int | Iterable[int] | None = None, niter: int = 1000) -> SufficiencyOutput:
         """
         Creates data indices, trains models, and returns plotting data
@@ -488,7 +493,7 @@ class Sufficiency:
         ----------
         eval_at : int | Iterable[int] | None, default None
             Specify this to collect accuracies over a specific set of dataset lengths, rather
-            than letting Sufficiency internally create the lengths to evaluate at.
+            than letting :term:`sufficiency<Sufficiency>` internally create the lengths to evaluate at.
         niter : int, default 1000
             Iterations to perform when using the basin-hopping method to curve-fit measure(s).
 

{dataeval-0.72.0.dist-info → dataeval-0.72.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.72.0
+Version: 0.72.2
 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
@@ -8,7 +8,7 @@ Author: Andrew Weng
 Author-email: andrew.weng@ariacoustics.com
 Maintainer: ARiA
 Maintainer-email: dataeval@ariacoustics.com
-Requires-Python: >=3.9,<3.12
+Requires-Python: >=3.9,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
@@ -17,24 +17,26 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering
 Provides-Extra: all
 Provides-Extra: tensorflow
 Provides-Extra: torch
 Requires-Dist: hdbscan (>=0.8.36)
+Requires-Dist: markupsafe (<3.0.2) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: matplotlib ; extra == "torch" or extra == "all"
 Requires-Dist: numpy (>1.24.3)
-Requires-Dist: nvidia-cudnn-cu11 (>=8.6.0.163) ; extra == "tensorflow" or extra == "torch" or extra == "all"
 Requires-Dist: pillow (>=10.3.0)
 Requires-Dist: scikit-learn (>=1.5.0)
 Requires-Dist: scipy (>=1.10)
-Requires-Dist: tensorflow (>=2.16) ; extra == "tensorflow" or extra == "all"
+Requires-Dist: tensorflow (>=2.16,<2.18) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: tensorflow_probability (>=0.24) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: tf-keras (>=2.16) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: torch (>=2.2.0) ; extra == "torch" or extra == "all"
 Requires-Dist: torchvision (>=0.17.0) ; extra == "torch" or extra == "all"
 Requires-Dist: tqdm
+Requires-Dist: typing-extensions (>=4.12) ; python_version >= "3.9" and python_version < "3.10"
 Requires-Dist: xxhash (>=3.3)
 Project-URL: Documentation, https://dataeval.readthedocs.io/
 Project-URL: Repository, https://github.com/aria-ml/dataeval/
@@ -44,7 +46,7 @@ Description-Content-Type: text/markdown
 
 ## About DataEval
 
-DataEval focuses on characterizing image data and its impact on model performance across classification and object-detection tasks.
+DataEval focuses on characterizing image data and its impact on model performance across Classification and object-detection tasks.
 
 <!-- start about -->
 

dataeval-0.72.2.dist-info/RECORD

@@ -0,0 +1,72 @@
+dataeval/__init__.py,sha256=UYhkwned7TR5hiU_c8I_qUaKogO1EODTBgT-9_t0ofI,641
+dataeval/detectors/__init__.py,sha256=xdp8LYOFjV5tVbAwu0Y03KU9EajHkSFy_M3raqbxpDc,383
+dataeval/detectors/drift/__init__.py,sha256=MRPWFOaoVoqAHW36nA5F3wk7QXJU4oecND2RbtgG9oY,757
+dataeval/detectors/drift/base.py,sha256=0S-0MFpIFaJ4_8IGreFKSmyna2L50FBn7DVaoNWmw8E,14509
+dataeval/detectors/drift/cvm.py,sha256=kc59w2_wtxFGNnLcaJRvX5v_38gPXiebSGNiFVdunEQ,4142
+dataeval/detectors/drift/ks.py,sha256=gcpe1WIQeNeZdLYkdMZCFLXUp1bHMQUxwJE6-RLVOXs,4229
+dataeval/detectors/drift/mmd.py,sha256=TqGOnUNYKwpS0GQPV3dSl-_qRa0g2flmoQ-dxzW_JfY,7586
+dataeval/detectors/drift/torch.py,sha256=D46J72OPW8-PpP3w9ODMBfcDSdailIgVjgHVFpbYfws,11649
+dataeval/detectors/drift/uncertainty.py,sha256=Xz2yzJjtJfw1vLag234jwRvaa_HK36nMajGx8bQaNRs,5322
+dataeval/detectors/drift/updates.py,sha256=UJ0z5hlunRi7twnkLABfdJG3tT2EqX4y9IGx8_USYvo,1780
+dataeval/detectors/linters/__init__.py,sha256=BvpaB1RUpkEhhXk3Mqi5NYoOcJKZRFSBOJCmQOIfYRU,483
+dataeval/detectors/linters/clusterer.py,sha256=OtBE5rglAGdTTQRmKUHP6J-uWmnh2E3lZxeqJCnc87U,21014
+dataeval/detectors/linters/duplicates.py,sha256=tOD43rJkvheIA3mznbUqHhft2yD3xRZQdCt61daIca4,5665
+dataeval/detectors/linters/merged_stats.py,sha256=X-bDTwjyR8RuVmzxLaHZmQ5nI3oOWvsqVlitdSncapk,1355
+dataeval/detectors/linters/outliers.py,sha256=BUVvtbKHo04KnRmrgb84MBr0l1gtcY3-xNCHjetFrEQ,10117
+dataeval/detectors/ood/__init__.py,sha256=FVyVuaxVKAOgSTaaBf-j2OXXDarSBFcJ7CTlMV6w88s,661
+dataeval/detectors/ood/ae.py,sha256=cdwrgCpQkueK_HQoQbeXw7s0oTE-6FKVtXe9vETDe5M,2117
+dataeval/detectors/ood/aegmm.py,sha256=jK5aN1UjwwZaSLB3BpzH25eLp5wBqzlgylsfphaoZaE,1814
+dataeval/detectors/ood/base.py,sha256=S9jl4xH2zB_-ixalysQJZEvRCGOqMQSruacvfd4Dnfc,8687
+dataeval/detectors/ood/llr.py,sha256=HUNsro-cV7RR5Mht6pJ4NWCRR7aWeVdjwkBNurs5LbM,10378
+dataeval/detectors/ood/metadata_ks_compare.py,sha256=jH7uDwyyBIIcTrRhQEdnLAdrwf7LfNczKBw0CpJyF5c,4282
+dataeval/detectors/ood/metadata_least_likely.py,sha256=nxMCXUOjOfWHDTGT2SLE7OYBCydRq8zHLd8t17k7hMM,5193
+dataeval/detectors/ood/metadata_ood_mi.py,sha256=KLay2BmgHrStBV92VpIs_B1yEfQKllsMTgzOQEng01I,4065
+dataeval/detectors/ood/vae.py,sha256=O1jpGkpavtJAqn4WrmocPRMtkX4iSdkpiCDUPBF1Ano,2925
+dataeval/detectors/ood/vaegmm.py,sha256=37epPiQKeicy6SZD0D7O7hCFQSajZ-8wvga1pmJiq2s,2183
+dataeval/interop.py,sha256=CFtGyVTwTqkJFkNfhHYhnBRVwxKIQ9f-9Zuuz_uQDqo,1589
+dataeval/metrics/__init__.py,sha256=fPBNLd-T6mCErZBBJrxWmXIL0jCk7fNUYIcNEBkMa80,238
+dataeval/metrics/bias/__init__.py,sha256=puf645-hAO5hFHNHlZ239TPopqWIoN-uLGXFB8-hA_o,599
+dataeval/metrics/bias/balance.py,sha256=pgxaIqFvRcygYlAUbM_BKrbi45WU7fRV08HBrI7Z5q4,8569
+dataeval/metrics/bias/coverage.py,sha256=Ku9l-qvc6YrRiQ0PRzkpfjInyOhkAKKSO_bf_LnOwNg,3623
+dataeval/metrics/bias/diversity.py,sha256=-cmh-vyAUrn4rbn6-ZXvLuaO43Ncj28GKyeTmhWRzfE,8973
+dataeval/metrics/bias/metadata.py,sha256=nUZRwhcKaJM0GVwXn5k11Fa1s56_OtOBF7tmXjMDpsM,8919
+dataeval/metrics/bias/parity.py,sha256=uJ3p8m6id5mZpDNnS1NmxCThb5V6v75lJv_0TGAhCRA,16668
+dataeval/metrics/estimators/__init__.py,sha256=O6ocxJq8XDkfJWwXeJnnnzbOyRnFPKF4kTIVTTZYOA8,380
+dataeval/metrics/estimators/ber.py,sha256=SVT-BIC_GLs0l2l2NhWu4OpRbgn96w-OwTSoPHTnQbE,5037
+dataeval/metrics/estimators/divergence.py,sha256=pImaa216-YYTgGWDCSTcpJrC-dfl7150yVrPfW_TyGc,4293
+dataeval/metrics/estimators/uap.py,sha256=Tz1VZOyUa68HlTh94Rl-wnXCWdTAVjTQc3LtSPEWVu4,2175
+dataeval/metrics/stats/__init__.py,sha256=igLRaAt1nX6yRwC4xI0zNPBADi3u7EsSxWP3OZ8AqcU,1086
+dataeval/metrics/stats/base.py,sha256=9M5g2FAWvd50HT-T2h-MCmYLpvk--em_yWro1qWGHFs,12177
+dataeval/metrics/stats/boxratiostats.py,sha256=iNr-FdppiJ7XAeeLY-o7gL_PSxvT8j86iwRijKca2Eg,6465
+dataeval/metrics/stats/datasetstats.py,sha256=LAMFCIS9v0RjLrdKUFuo8nY-3HLVvRlqQIXGMKtsHEw,6255
+dataeval/metrics/stats/dimensionstats.py,sha256=xdTp2AbGH3xefUUsB4sDjgSKiojJ73DCHyuCOPKsErc,4056
+dataeval/metrics/stats/hashstats.py,sha256=X6aSouaMhDcGZMLuCTje3G4QOr2i-Td6H3SyBFDF6mA,4960
+dataeval/metrics/stats/labelstats.py,sha256=BKwSmyxCr2wYq8IMraCUS-b5wqacfT_BukJUYNfqeCo,4114
+dataeval/metrics/stats/pixelstats.py,sha256=x90O10IqVjEORtYwueFLvJnVYTxhPBOOx5HMweBQnJY,4578
+dataeval/metrics/stats/visualstats.py,sha256=y0xIvst7epcajk8vz2jngiAiz0T7DZC-M97Rs1-vV9I,4950
+dataeval/output.py,sha256=jWXXNxFNBEaY1rN7Z-6LZl6bQT-I7z_wqr91Rhrdt_0,3061
+dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/utils/__init__.py,sha256=zTgPsmloPy0qZMzb4xipNNdIWpaHtseGph68pIAD-hQ,684
+dataeval/utils/image.py,sha256=KgC_1nW__nGN5q6bVZNvG4U_qIBdjcPATz9qe8f2XuA,1928
+dataeval/utils/shared.py,sha256=BvEeYPMNQTmx4LSaImGeC0VkvcbEY3Byqtxa-jQ3xgc,3623
+dataeval/utils/split_dataset.py,sha256=IopyxwC3FaZwgVriW4OXze-mDMpOlvRr83OADA5Jydk,19454
+dataeval/utils/tensorflow/__init__.py,sha256=l4OjIA75JJXeNWDCkST1xtDMVYsw97lZ-9JXFBlyuYg,539
+dataeval/utils/tensorflow/_internal/autoencoder.py,sha256=-pm4VqMEjHcrgre-K8uhMvaEVHyeqZsZbejrnlM6OtY,10430
+dataeval/utils/tensorflow/_internal/gmm.py,sha256=QoEgbeax1GETqRmUF7A2ih9uFOZfFAjGzgH2ljExlAc,3669
+dataeval/utils/tensorflow/_internal/loss.py,sha256=IXW_kxovLaTLd6UkMOIQLPEAGrOMILHDKagvRYgj-DE,4065
+dataeval/utils/tensorflow/_internal/pixelcnn.py,sha256=Aa7koa7YxqhHmFequpsfMw2-61KO03evWWcvvFTuaco,48518
+dataeval/utils/tensorflow/_internal/trainer.py,sha256=ld7pisl4ZXjEA6nxBStRNDEuNJme0IPo08oWqal6bYc,4167
+dataeval/utils/tensorflow/_internal/utils.py,sha256=k1mjy44oE63SIkckvU8BTlqtWsCnGynJF4eYyw1pebQ,8799
+dataeval/utils/tensorflow/loss/__init__.py,sha256=Q-66vt91Oe1ByYfo28tW32zXDq2MqQ2gngWgmIVmof8,227
+dataeval/utils/torch/__init__.py,sha256=lpkqfgyARUxgrV94cZESQv8PIP2p-UnwItZ_wIr0XzQ,675
+dataeval/utils/torch/blocks.py,sha256=HVhBTMMD5NA4qheMUgyol1KWiKZDIuc8k5j4RcMKmhk,1466
+dataeval/utils/torch/datasets.py,sha256=9YV9-Uhq6NCMuu1hPhMnQXjmeI-Ld8ve1z_haxre88o,15023
+dataeval/utils/torch/models.py,sha256=0BsXmLK8W1OZ8nnEGb1f9LzIeCgtevQC37dvKS1v1vA,3236
+dataeval/utils/torch/trainer.py,sha256=EraOKiXxiMNiycStZNMR5yRz3ehgp87d9ewR9a9dV4w,5559
+dataeval/utils/torch/utils.py,sha256=FI4LJ6DvXFQJVff8fxSCP7LRkp8H9BIUgYX0kk7_Cuo,1537
+dataeval/workflows/__init__.py,sha256=x2JnOoKmLUCZOsB6RNPqMdVvxEb6Hpda5GPJnD_k0v0,310
+dataeval/workflows/sufficiency.py,sha256=1jSYhH9i4oesmJYs5PZvWS1LGXf8ekOgNhpFtMPLPXk,18552
+dataeval-0.72.2.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.72.2.dist-info/METADATA,sha256=ddOmTZA6nX7VceQhOmyQ-cQ1aBv2VU9Za32vnmjP-VE,4702
+dataeval-0.72.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dataeval-0.72.2.dist-info/RECORD,,

dataeval/_internal/metrics/stats/hashstats.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Iterable
-
-from numpy.typing import ArrayLike
-
-from dataeval._internal.metrics.stats.base import BaseStatsOutput, StatsProcessor, run_stats
-from dataeval._internal.metrics.utils import pchash, xxhash
-from dataeval._internal.output import set_metadata
-
-
-@dataclass(frozen=True)
-class HashStatsOutput(BaseStatsOutput):
-    """
-    Output class for :func:`hashstats` stats metric
-
-    Attributes
-    ----------
-    xxhash : List[str]
-        xxHash hash of the images as a hex string
-    pchash : List[str]
-        Perception hash of the images as a hex string
-    """
-
-    xxhash: list[str]
-    pchash: list[str]
-
-
-class HashStatsProcessor(StatsProcessor[HashStatsOutput]):
-    output_class = HashStatsOutput
-    image_function_map = {
-        "xxhash": lambda x: xxhash(x.image),
-        "pchash": lambda x: pchash(x.image),
-    }
-
-
-@set_metadata("dataeval.metrics")
-def hashstats(
-    images: Iterable[ArrayLike],
-    bboxes: Iterable[ArrayLike] | None = None,
-) -> HashStatsOutput:
-    """
-    Calculates hashes for each image
-
-    This function computes hashes from the images including exact hashes and perception-based
-    hashes. These hash values can be used to determine if images are exact or near matches.
-
-    Parameters
-    ----------
-    images : ArrayLike
-        Images to hashing
-    bboxes : Iterable[ArrayLike] or None
-        Bounding boxes in `xyxy` format for each image
-
-    Returns
-    -------
-    HashStatsOutput
-        A dictionary-like object containing the computed hashes for each image.
-
-    See Also
-    --------
-    Duplicates
-
-    Examples
-    --------
-    Calculating the statistics on the images, whose shape is (C, H, W)
-
-    >>> results = hashstats(images)
-    >>> print(results.xxhash)
-    ['a72434443d6e7336', 'efc12c2f14581d79', '4a1e03483a27d674', '3a3ecedbcf814226']
-    >>> print(results.pchash)
-    ['8f25506af46a7c6a', '8000808000008080', '8e71f18e0ef18e0e', 'a956d6a956d6a928']
-    """
-    return run_stats(images, bboxes, False, [HashStatsProcessor])[0]