dataeval 0.81.0__py3-none-any.whl → 0.82.1__py3-none-any.whl

dataeval/metrics/bias/_diversity.py

@@ -2,116 +2,18 @@ from __future__ import annotations
 
 __all__ = []
 
-import contextlib
-from dataclasses import dataclass
-from typing import Any, Literal
+from typing import Literal
 
 import numpy as np
 import scipy as sp
 from numpy.typing import NDArray
 
-from dataeval._output import Output, set_metadata
-from dataeval.typing import ArrayLike
+from dataeval.outputs import DiversityOutput
+from dataeval.outputs._base import set_metadata
 from dataeval.utils._bin import get_counts
 from dataeval.utils._method import get_method
-from dataeval.utils._plot import heatmap
 from dataeval.utils.data import Metadata
 
-with contextlib.suppress(ImportError):
-    from matplotlib.figure import Figure
-
-
-def _plot(labels: NDArray[Any], bar_heights: NDArray[Any]) -> Figure:
-    """
-    Plots a formatted bar plot
-
-    Parameters
-    ----------
-    labels : NDArray
-        Array containing the labels for each bar
-    bar_heights : NDArray
-        Array containing the values for each bar
-
-    Returns
-    -------
-    matplotlib.figure.Figure
-        Bar plot figure
-    """
-    import matplotlib.pyplot as plt
-
-    fig, ax = plt.subplots(figsize=(8, 8))
-
-    ax.bar(labels, bar_heights)
-    ax.set_xlabel("Factors")
-
-    plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")
-
-    fig.tight_layout()
-    return fig
-
-
-@dataclass(frozen=True)
-class DiversityOutput(Output):
-    """
-    Output class for :func:`.diversity` :term:`bias<Bias>` metric.
-
-    Attributes
-    ----------
-    diversity_index : NDArray[np.double]
-        :term:`Diversity` index for classes and factors
-    classwise : NDArray[np.double]
-        Classwise diversity index [n_class x n_factor]
-    factor_names : list[str]
-        Names of each metadata factor
-    class_names : list[str]
-        Class labels for each value in the dataset
-    """
-
-    diversity_index: NDArray[np.double]
-    classwise: NDArray[np.double]
-    factor_names: list[str]
-    class_names: list[str]
-
-    def plot(
-        self,
-        row_labels: ArrayLike | None = None,
-        col_labels: ArrayLike | None = None,
-        plot_classwise: bool = False,
-    ) -> Figure:
-        """
-        Plot a heatmap of diversity information
-
-        Parameters
-        ----------
-        row_labels : ArrayLike or None, default None
-            List/Array containing the labels for rows in the histogram
-        col_labels : ArrayLike or None, default None
-            List/Array containing the labels for columns in the histogram
-        plot_classwise : bool, default False
-            Whether to plot per-class balance instead of global balance
-        """
-        if plot_classwise:
-            if row_labels is None:
-                row_labels = self.class_names
-            if col_labels is None:
-                col_labels = self.factor_names
-
-            fig = heatmap(
-                self.classwise,
-                row_labels,
-                col_labels,
-                xlabel="Factors",
-                ylabel="Class",
-                cbarlabel=f"Normalized {self.meta()['arguments']['method'].title()} Index",
-            )
-
-        else:
-            # Creating label array for heat map axes
-            heat_labels = np.concatenate((["class"], self.factor_names))
-            fig = _plot(heat_labels, self.diversity_index)
-
-        return fig
-
 
 def diversity_shannon(
     counts: NDArray[np.int_],
@@ -236,26 +138,29 @@ def diversity(
 
     >>> div_simp = diversity(metadata, method="simpson")
     >>> div_simp.diversity_index
-    array([0.6       , 0.80882353, 1.        , 0.8       ])
+    array([0.6  , 0.809, 1.   , 0.8  ])
 
     >>> div_simp.classwise
-    array([[0.5       , 0.8       , 0.8       ],
-           [0.63043478, 0.97560976, 0.52830189]])
+    array([[0.5  , 0.8  , 0.8  ],
+           [0.63 , 0.976, 0.528]])
 
     Compute Shannon diversity index of metadata and class labels
 
     >>> div_shan = diversity(metadata, method="shannon")
     >>> div_shan.diversity_index
-    array([0.81127812, 0.9426312 , 1.        , 0.91829583])
+    array([0.811, 0.943, 1.   , 0.918])
 
     >>> div_shan.classwise
-    array([[0.68260619, 0.91829583, 0.91829583],
-           [0.81443569, 0.99107606, 0.76420451]])
+    array([[0.683, 0.918, 0.918],
+           [0.814, 0.991, 0.764]])
 
     See Also
     --------
     scipy.stats.entropy
     """
+    if not metadata.discrete_factor_names and not metadata.continuous_factor_names:
+        raise ValueError("No factors found in provided metadata.")
+
     diversity_fn = get_method(_DIVERSITY_FN_MAP, method)
     discretized_data = np.hstack((metadata.class_labels[:, np.newaxis], metadata.discrete_data))
     cnts = get_counts(discretized_data)

dataeval/metrics/bias/_parity.py

@@ -2,87 +2,20 @@ from __future__ import annotations
 
 __all__ = []
 
-import contextlib
 import warnings
-from dataclasses import dataclass
-from typing import Any, Generic, TypeVar
+from typing import Any
 
 import numpy as np
 from numpy.typing import NDArray
 from scipy.stats import chisquare
 from scipy.stats.contingency import chi2_contingency, crosstab
 
-from dataeval._output import Output, set_metadata
+from dataeval.outputs import LabelParityOutput, ParityOutput
+from dataeval.outputs._base import set_metadata
 from dataeval.typing import ArrayLike
 from dataeval.utils._array import as_numpy
 from dataeval.utils.data import Metadata
 
-with contextlib.suppress(ImportError):
-    import pandas as pd
-
-TData = TypeVar("TData", np.float64, NDArray[np.float64])
-
-
-@dataclass(frozen=True)
-class BaseParityOutput(Generic[TData], Output):
-    score: TData
-    p_value: TData
-
-    def to_dataframe(self) -> pd.DataFrame:
-        """
-        Exports the parity output results to a pandas DataFrame.
-
-        Returns
-        -------
-        pd.DataFrame
-        """
-        import pandas as pd
-
-        return pd.DataFrame(
-            index=self.factor_names,  # type: ignore - list[str] is documented as acceptable index type
-            data={
-                "score": self.score.round(2),
-                "p-value": self.p_value.round(2),
-            },
-        )
-
-
-@dataclass(frozen=True)
-class LabelParityOutput(BaseParityOutput[np.float64]):
-    """
-    Output class for :func:`.label_parity` :term:`bias<Bias>` metrics.
-
-    Attributes
-    ----------
-    score : np.float64
-        chi-squared score(s) of the test
-    p_value : np.float64
-        p-value(s) of the test
-    """
-
-
-@dataclass(frozen=True)
-class ParityOutput(BaseParityOutput[NDArray[np.float64]]):
-    """
-    Output class for :func:`.parity` :term:`bias<Bias>` metrics.
-
-    Attributes
-    ----------
-    score : NDArray[np.float64]
-        chi-squared score(s) of the test
-    p_value : NDArray[np.float64]
-        p-value(s) of the test
-    factor_names : list[str]
-        Names of each metadata factor
-    insufficient_data: dict
-        Dictionary of metadata factors with less than 5 class occurrences per value
-    """
-
-    # score: NDArray[np.float64]
-    # p_value: NDArray[np.float64]
-    factor_names: list[str]
-    insufficient_data: dict[str, dict[int, dict[str, int]]]
-
 
 def normalize_expected_dist(expected_dist: NDArray[Any], observed_dist: NDArray[Any]) -> NDArray[Any]:
     """
@@ -306,8 +239,11 @@ def parity(metadata: Metadata) -> ParityOutput:
     ...     random_seed=175)
     >>> metadata.continuous_factor_bins = {"age": 4, "income": 3}
     >>> parity(metadata)
-    ParityOutput(score=array([7.35731943, 5.46711299, 0.51506212]), p_value=array([0.28906231, 0.24263543, 0.77295762]), factor_names=['age', 'income', 'gender'], insufficient_data={'age': {3: {'artist': 4}, 4: {'artist': 4, 'teacher': 3}}, 'income': {1: {'artist': 3}}})
+    ParityOutput(score=array([7.357, 5.467, 0.515]), p_value=array([0.289, 0.243, 0.773]), factor_names=['age', 'income', 'gender'], insufficient_data={'age': {3: {'artist': 4}, 4: {'artist': 4, 'teacher': 3}}, 'income': {1: {'artist': 3}}})
     """  # noqa: E501
+    if not metadata.discrete_factor_names and not metadata.continuous_factor_names:
+        raise ValueError("No factors found in provided metadata.")
+
     chi_scores = np.zeros(metadata.discrete_data.shape[1])
     p_values = np.zeros_like(chi_scores)
     insufficient_data = {}

dataeval/metrics/estimators/__init__.py

@@ -13,7 +13,8 @@ __all__ = [
     "UAPOutput",
 ]
 
-from dataeval.metrics.estimators._ber import BEROutput, ber
-from dataeval.metrics.estimators._clusterer import ClustererOutput, clusterer
-from dataeval.metrics.estimators._divergence import DivergenceOutput, divergence
-from dataeval.metrics.estimators._uap import UAPOutput, uap
+from dataeval.metrics.estimators._ber import ber
+from dataeval.metrics.estimators._clusterer import clusterer
+from dataeval.metrics.estimators._divergence import divergence
+from dataeval.metrics.estimators._uap import uap
+from dataeval.outputs._estimators import BEROutput, ClustererOutput, DivergenceOutput, UAPOutput

dataeval/metrics/estimators/_ber.py

@@ -12,7 +12,6 @@ from __future__ import annotations
 
 __all__ = []
 
-from dataclasses import dataclass
 from typing import Literal
 
 import numpy as np
@@ -20,31 +19,14 @@ from numpy.typing import NDArray
 from scipy.sparse import coo_matrix
 from scipy.stats import mode
 
-from dataeval._output import Output, set_metadata
+from dataeval.outputs import BEROutput
+from dataeval.outputs._base import set_metadata
 from dataeval.typing import ArrayLike
 from dataeval.utils._array import as_numpy, ensure_embeddings
 from dataeval.utils._method import get_method
 from dataeval.utils._mst import compute_neighbors, minimum_spanning_tree
 
 
-@dataclass(frozen=True)
-class BEROutput(Output):
-    """
-    Output class for :func:`.ber` estimator metric.
-
-    Attributes
-    ----------
-    ber : float
-        The upper bounds of the :term:`Bayes error rate<Bayes Error Rate (BER)>`
-    ber_lower : float
-        The lower bounds of the Bayes Error Rate
-    """
-
-    ber: float
-
-    ber_lower: float
-
-
 def ber_mst(images: NDArray[np.float64], labels: NDArray[np.int_], k: int = 1) -> tuple[float, float]:
     """Calculates the :term:`Bayes error rate<Bayes Error Rate (BER)>` using a minimum spanning tree.
 

dataeval/metrics/estimators/_clusterer.py

@@ -2,72 +2,12 @@ from __future__ import annotations
 
 __all__ = []
 
-from dataclasses import dataclass
 
-import numpy as np
-from numpy.typing import NDArray
-
-from dataeval._output import Output
+from dataeval.outputs import ClustererOutput
 from dataeval.typing import ArrayLike
 from dataeval.utils._array import as_numpy
 
 
-@dataclass(frozen=True)
-class ClustererOutput(Output):
-    """
-    Output class for :func:`.clusterer`.
-
-    Attributes
-    ----------
-    clusters : NDArray[int]
-        Assigned clusters
-    mst : NDArray[int]
-        The minimum spanning tree of the data
-    linkage_tree : NDArray[float]
-        The linkage array of the data
-    condensed_tree : NDArray[float]
-        The condensed tree of the data
-    membership_strengths : NDArray[float]
-        The strength of the data point belonging to the assigned cluster
-    """
-
-    clusters: NDArray[np.int_]
-    mst: NDArray[np.double]
-    linkage_tree: NDArray[np.double]
-    condensed_tree: NDArray[np.double]
-    membership_strengths: NDArray[np.double]
-
-    def find_outliers(self) -> NDArray[np.int_]:
-        """
-        Retrieves Outliers based on when the sample was added to the cluster
-        and how far it was from the cluster when it was added
-
-        Returns
-        -------
-        NDArray[int]
-            A numpy array of the outlier indices
-        """
-        return np.nonzero(self.clusters == -1)[0]
-
-    def find_duplicates(self) -> tuple[list[list[int]], list[list[int]]]:
-        """
-        Finds duplicate and near duplicate data based on cluster average distance
-
-        Returns
-        -------
-        Tuple[List[List[int]], List[List[int]]]
-            The exact :term:`duplicates<Duplicates>` and near duplicates as lists of related indices
-        """
-        # Delay load numba compiled functions
-        from dataeval.utils._clusterer import compare_links_to_cluster_std, sorted_union_find
-
-        exact_indices, near_indices = compare_links_to_cluster_std(self.mst, self.clusters)
-        exact_dupes = sorted_union_find(exact_indices)
-        near_dupes = sorted_union_find(near_indices)
-
-        return [[int(ii) for ii in il] for il in exact_dupes], [[int(ii) for ii in il] for il in near_dupes]
-
-
 def clusterer(data: ArrayLike) -> ClustererOutput:
     """
     Uses hierarchical clustering on the flattened data and returns clustering

dataeval/metrics/estimators/_divergence.py

@@ -7,36 +7,19 @@ from __future__ import annotations
 
 __all__ = []
 
-from dataclasses import dataclass
 from typing import Literal
 
 import numpy as np
 from numpy.typing import NDArray
 
-from dataeval._output import Output, set_metadata
+from dataeval.outputs import DivergenceOutput
+from dataeval.outputs._base import set_metadata
 from dataeval.typing import ArrayLike
 from dataeval.utils._array import ensure_embeddings
 from dataeval.utils._method import get_method
 from dataeval.utils._mst import compute_neighbors, minimum_spanning_tree
 
 
-@dataclass(frozen=True)
-class DivergenceOutput(Output):
-    """
-    Output class for :func:`.divergence` estimator metric.
-
-    Attributes
-    ----------
-    divergence : float
-        :term:`Divergence` value calculated between 2 datasets ranging between 0.0 and 1.0
-    errors : int
-        The number of differing edges between the datasets
-    """
-
-    divergence: float
-    errors: int
-
-
 def divergence_mst(data: NDArray[np.float64], labels: NDArray[np.int_]) -> int:
     """
     Calculates the estimated label errors based on the minimum spanning tree

dataeval/metrics/estimators/_uap.py

@@ -8,29 +8,15 @@ from __future__ import annotations
 
 __all__ = []
 
-from dataclasses import dataclass
 
 from sklearn.metrics import average_precision_score
 
-from dataeval._output import Output, set_metadata
+from dataeval.outputs import UAPOutput
+from dataeval.outputs._base import set_metadata
 from dataeval.typing import ArrayLike
 from dataeval.utils._array import as_numpy
 
 
-@dataclass(frozen=True)
-class UAPOutput(Output):
-    """
-    Output class for :func:`.uap` estimator metric.
-
-    Attributes
-    ----------
-    uap : float
-        The empirical mean precision estimate
-    """
-
-    uap: float
-
-
 @set_metadata
 def uap(labels: ArrayLike, scores: ArrayLike) -> UAPOutput:
     """

dataeval/metrics/stats/__init__.py

@@ -5,15 +5,14 @@ and label statistics against the images and labels of a dataset.
 
 __all__ = [
     "ChannelStatsOutput",
-    "DatasetStatsOutput",
+    "ImageStatsOutput",
     "DimensionStatsOutput",
     "HashStatsOutput",
     "LabelStatsOutput",
     "PixelStatsOutput",
     "VisualStatsOutput",
     "boxratiostats",
-    "channelstats",
-    "datasetstats",
+    "imagestats",
     "dimensionstats",
     "hashstats",
     "labelstats",
@@ -22,14 +21,18 @@ __all__ = [
 ]
 
 from dataeval.metrics.stats._boxratiostats import boxratiostats
-from dataeval.metrics.stats._datasetstats import (
+from dataeval.metrics.stats._dimensionstats import dimensionstats
+from dataeval.metrics.stats._hashstats import hashstats
+from dataeval.metrics.stats._imagestats import imagestats
+from dataeval.metrics.stats._labelstats import labelstats
+from dataeval.metrics.stats._pixelstats import pixelstats
+from dataeval.metrics.stats._visualstats import visualstats
+from dataeval.outputs._stats import (
     ChannelStatsOutput,
-    DatasetStatsOutput,
-    channelstats,
-    datasetstats,
+    DimensionStatsOutput,
+    HashStatsOutput,
+    ImageStatsOutput,
+    LabelStatsOutput,
+    PixelStatsOutput,
+    VisualStatsOutput,
 )
-from dataeval.metrics.stats._dimensionstats import DimensionStatsOutput, dimensionstats
-from dataeval.metrics.stats._hashstats import HashStatsOutput, hashstats
-from dataeval.metrics.stats._labelstats import LabelStatsOutput, labelstats
-from dataeval.metrics.stats._pixelstats import PixelStatsOutput, pixelstats
-from dataeval.metrics.stats._visualstats import VisualStatsOutput, visualstats