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

dataeval/_internal/functional/metadata.py

@@ -0,0 +1,136 @@
+from typing import Dict, List
+
+import numpy as np
+from scipy.stats import entropy
+
+
+def _get_counts(
+    data: np.ndarray, names: list[str], is_categorical: List, subset_mask: np.ndarray = np.empty(shape=0)
+) -> tuple[Dict, Dict]:
+    """
+    Initialize dictionary of histogram counts --- treat categorical values
+    as histogram bins.
+
+    Parameters
+    ----------
+    subset_mask: Optional[np.ndarray[bool]]
+        Boolean mask of samples to bin (e.g. when computing per class).  True -> include in histogram counts
+
+    Returns
+    -------
+    counts: Dict
+        histogram counts per metadata factor in `factors`.  Each
+        factor will have a different number of bins.  Counts get reused
+        across metrics, so hist_counts are cached but only if computed
+        globally, i.e. without masked samples.
+    """
+
+    hist_counts, hist_bins = {}, {}
+    # np.where needed to satisfy linter
+    mask = np.where(subset_mask if len(subset_mask) > 0 else np.ones(data.shape[0], dtype=bool))
+
+    for cdx, fn in enumerate(names):
+        # linter doesn't like double indexing
+        col_data = data[mask, cdx].squeeze()
+        if is_categorical[cdx]:
+            # if discrete, use unique values as bins
+            bins, cnts = np.unique(col_data, return_counts=True)
+        else:
+            bins = hist_bins.get(fn, "auto")
+            cnts, bins = np.histogram(col_data, bins=bins, density=True)
+
+        hist_counts[fn] = cnts
+        hist_bins[fn] = bins
+
+    return hist_counts, hist_bins
+
+
+def _entropy(
+    data: np.ndarray,
+    names: list,
+    is_categorical: List,
+    normalized: bool = False,
+    subset_mask: np.ndarray = np.empty(shape=0),
+) -> np.ndarray:
+    """
+    Meant for use with Bias metrics, Balance, Diversity, ClasswiseBalance,
+    and Classwise Diversity.
+
+    Compute entropy for discrete/categorical variables and, through standard
+    histogram binning, for continuous variables.
+
+
+    Parameters
+    ----------
+    normalized: bool
+        Flag that determines whether or not to normalize entropy by log(num_bins)
+    subset_mask: Optional[np.ndarray[bool]]
+        Boolean mask of samples to bin (e.g. when computing per class).  True -> include in histogram counts
+
+
+    Notes
+    -----
+    For continuous variables, histogram bins are chosen automatically.  See
+    numpy.histogram for details.
+
+    Returns
+    -------
+    ent: np.ndarray[float]
+        Entropy estimate per column of X
+
+    See Also
+    --------
+    numpy.histogram
+    scipy.stats.entropy
+    """
+
+    num_factors = len(names)
+    hist_counts, _ = _get_counts(data, names, is_categorical, subset_mask=subset_mask)
+
+    ev_index = np.empty(num_factors)
+    for col, cnts in enumerate(hist_counts.values()):
+        # entropy in nats, normalizes counts
+        ev_index[col] = entropy(cnts)
+        if normalized:
+            if len(cnts) == 1:
+                # log(0)
+                ev_index[col] = 0
+            else:
+                ev_index[col] /= np.log(len(cnts))
+    return ev_index
+
+
+def _get_num_bins(
+    data: np.ndarray, names: list, is_categorical: List, subset_mask: np.ndarray = np.empty(shape=0)
+) -> np.ndarray:
+    """
+    Number of bins or unique values for each metadata factor, used to
+    normalize entropy/diversity.
+
+    Parameters
+    ----------
+    subset_mask: Optional[np.ndarray[bool]]
+        Boolean mask of samples to bin (e.g. when computing per class).  True -> include in histogram counts
+    """
+    # likely cached
+    hist_counts, _ = _get_counts(data, names, is_categorical, subset_mask)
+    num_bins = np.empty(len(hist_counts))
+    for idx, cnts in enumerate(hist_counts.values()):
+        num_bins[idx] = len(cnts)
+
+    return num_bins
+
+
+def _infer_categorical(X: np.ndarray, threshold: float = 0.5) -> np.ndarray:
+    """
+    Compute fraction of feature values that are unique --- intended to be used
+    for inferring whether variables are categorical.
+    """
+    if X.ndim == 1:
+        X = np.expand_dims(X, axis=1)
+    num_samples = X.shape[0]
+    pct_unique = np.empty(X.shape[1])
+    for col in range(X.shape[1]):  # type: ignore
+        uvals = np.unique(X[:, col], axis=0)
+        pct_unique[col] = len(uvals) / num_samples
+    return pct_unique < threshold

dataeval/_internal/functional/metadataparity.py

@@ -0,0 +1,190 @@
+import warnings
+from typing import Dict, Tuple
+
+import numpy as np
+import scipy
+
+
+def validate_dict(d: Dict) -> None:
+    """
+    Verify that dict-of-arrays (proxy for dataframe) contains arrays of equal
+    length.  Future iterations could include type checking, conversion from
+    string to numeric types, etc.
+
+    Parameters
+    ----------
+    d: Dict
+        dictionary of {variable_name: values}
+    """
+    # assert that length of all arrays are equal -- could expand to other properties
+    lengths = []
+    for arr in d.values():
+        lengths.append(arr.shape)
+
+    if lengths[1:] != lengths[:-1]:
+        raise ValueError("The lengths of each entry in the dictionary are not equal." f" Found lengths {lengths}")
+
+
+def digitize_factor_bins(continuous_values: np.ndarray, bins: int, factor_name: str):
+    """
+    Digitizes a list of values into a given number of bins.
+
+    Parameters
+    ----------
+    continuous_values: np.ndarray
+        The values to be digitized.
+    bins: int
+        The number of bins for the discrete values that continuous_values will be digitized into.
+    factor_name: str
+        The name of the factor to be digitized.
+
+    Returns
+    -------
+    np.ndarray
+        The digitized values
+
+    """
+    if not np.all([np.issubdtype(type(n), np.number) for n in continuous_values]):
+        raise TypeError(
+            f"Encountered a non-numeric value for factor {factor_name}, but the factor"
+            " was specified to be continuous. Ensure all occurrences of this factor are numeric types,"
+            f" or do not specify {factor_name} as a continuous factor."
+        )
+
+    _, bin_edges = np.histogram(continuous_values, bins=bins)
+    bin_edges[-1] = np.inf
+    bin_edges[0] = -np.inf
+    return np.digitize(continuous_values, bin_edges)
+
+
+def format_discretize_factors(
+    data_factors: dict[str, np.ndarray], continuous_factor_names: np.ndarray, continuous_factor_bincounts: np.ndarray
+) -> Tuple[dict, np.ndarray]:
+    """
+    Sets up the internal list of metadata factors.
+
+    Parameters
+    ----------
+    data_factors: Dict[str, np.ndarray]
+        The dataset factors, which are per-image attributes including class label and metadata.
+        Each key of dataset_factors is a factor, whose value is the per-image factor values.
+    continuous_factor_names : np.ndarray
+        The factors in data_factors that have continuous values.
+        All factors are treated as having discrete values unless they
+        are specified in this array. Each element of this array must occur as a key in data_factors.
+    continuous_factor_bincounts : np.ndarray
+        Array of the bin counts to discretize values into for each factor in continuous_factor_names.
+
+    Returns
+    -------
+    Dict[str, np.ndarray]
+        Intrinsic per-image metadata information with the formatting that input data_factors uses.
+        Each key is a metadata factor, whose value is the discrete per-image factor values.
+    np.ndarray
+        Per-image labels, whose ith element is the label for the ith element of the dataset.
+    """
+
+    if len(continuous_factor_bincounts) != len(continuous_factor_names):
+        raise ValueError(
+            f"continuous_factor_bincounts has length {len(continuous_factor_bincounts)}, "
+            f"but continuous_factor_names has length {len(continuous_factor_names)}. "
+            "Each element of continuous_factor_names must have a corresponding element "
+            "in continuous_factor_bincounts. Alternatively, leave continuous_factor_bincounts empty "
+            "to use a default digitization of 10 bins."
+        )
+
+    # TODO: add unit test for this
+    for key in continuous_factor_names:
+        if key not in data_factors:
+            raise KeyError(
+                f"The continuous factor name {key} "
+                f"does not exist in data_factors. Delete {key} from "
+                f"continuous_factor_names or add an entry with key {key} to "
+                "data_factors."
+            )
+
+    metadata_factors = {}
+
+    # make sure each factor has the same number of entries
+    validate_dict(data_factors)
+
+    labels = data_factors["class"]
+
+    # Each continuous factor is discretized into some number of bins.
+    # This matches the number of bins for a factor with the factor
+    num_bins = dict(zip(continuous_factor_names, continuous_factor_bincounts))
+
+    metadata_factors = {
+        name: val if name not in continuous_factor_names else digitize_factor_bins(val, num_bins[name], name)
+        for name, val in data_factors.items()
+        if name != "class"
+    }
+
+    return metadata_factors, labels
+
+
+def compute_parity(factors: dict[str, np.ndarray], labels: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Evaluates the statistical independence of metadata factors from class labels.
+    This performs a chi-square test, which provides a score and a p-value for
+    statistical independence between each pair of a metadata factor and a class label.
+    A high score with a low p-value suggests that a metadata factor is strongly
+    correlated with a class label.
+
+    Parameters
+    ----------
+    factors: Dict[str, np.ndarray]
+        Intrinsic per-image metadata information.
+        factors['key'][i] is the value of the metadata factor 'key' at the ith element of the dataset.
+    labels: np.ndarray
+        Dataset labels.
+        Labels[i] is the label for the ith element of the dataset.
+
+    Returns
+    -------
+    np.ndarray
+        Array of length (num_factors) whose (i)th element corresponds to
+        the chi-square score for the relationship between factor i
+        and the class labels in the dataset.
+    np.ndarray
+        Array of length (num_factors) whose (i)th element corresponds to
+        the p-value value for the chi-square test for the relationship between
+        factor i and the class labels in the dataset.
+    """
+
+    chi_scores = np.zeros(len(factors))
+    p_values = np.zeros(len(factors))
+    n_cls = len(np.unique(labels))
+    for i, (current_factor_name, factor_values) in enumerate(factors.items()):
+        unique_factor_values = np.unique(factor_values)
+        contingency_matrix = np.zeros((len(unique_factor_values), n_cls))
+        # Builds a contingency matrix where entry at index (r,c) represents
+        # the frequency of current_factor_name achieving value unique_factor_values[r]
+        # at a data point with class c.
+
+        # TODO: Vectorize this nested for loop
+        for fi, factor_value in enumerate(unique_factor_values):
+            for label in range(n_cls):
+                with_both = np.bitwise_and((labels == label), factor_values == factor_value)
+                contingency_matrix[fi, label] = np.sum(with_both)
+                if 0 < contingency_matrix[fi, label] < 5:
+                    warnings.warn(
+                        f"Factor {current_factor_name} value {factor_value} co-occurs "
+                        f"only {contingency_matrix[fi, label]} times with label {label}. "
+                        "This can cause inaccurate chi_square calculation. Recommend"
+                        "ensuring each label occurs either 0 times or at least 5 times. "
+                        "Alternatively, digitize any continuous-valued factors "
+                        "into fewer bins."
+                    )
+
+        # This deletes rows containing only zeros,
+        # because scipy.stats.chi2_contingency fails when there are rows containing only zeros.
+        rowsums = np.sum(contingency_matrix, axis=1)
+        rowmask = np.where(rowsums)
+        contingency_matrix = contingency_matrix[rowmask]
+
+        chi2, p, _, _ = scipy.stats.chi2_contingency(contingency_matrix)
+
+        chi_scores[i] = chi2
+        p_values[i] = p
+    return chi_scores, p_values

dataeval/_internal/functional/uap.py

@@ -0,0 +1,6 @@
+import numpy as np
+from sklearn.metrics import average_precision_score
+
+
+def uap(labels: np.ndarray, scores: np.ndarray):
+    return float(average_precision_score(labels, scores, average="weighted"))

dataeval/_internal/interop.py

@@ -0,0 +1,52 @@
+from importlib import import_module
+from typing import Any, Iterable, Optional, runtime_checkable
+
+import numpy as np
+
+module_cache = {}
+
+
+def try_import(module_name):
+    if module_name in module_cache:
+        return module_cache[module_name]
+
+    try:
+        module = import_module(module_name)
+    except ImportError:  # pragma: no cover - covered by test_mindeps.py
+        module = None
+
+    module_cache[module_name] = module
+    return module
+
+
+try:
+    from maite.protocols import ArrayLike  # type: ignore
+except ImportError:  # pragma: no cover - covered by test_mindeps.py
+    from typing import Protocol
+
+    @runtime_checkable
+    class ArrayLike(Protocol):
+        def __array__(self) -> Any: ...
+
+
+def to_numpy(array: Optional[ArrayLike]) -> np.ndarray:
+    if array is None:
+        return np.ndarray([])
+
+    if isinstance(array, np.ndarray):
+        return array
+
+    tf = try_import("tensorflow")
+    if tf and tf.is_tensor(array):
+        return array.numpy()  # type: ignore
+
+    torch = try_import("torch")
+    if torch and isinstance(array, torch.Tensor):
+        return array.detach().cpu().numpy()  # type: ignore
+
+    return np.asarray(array)
+
+
+def to_numpy_iter(iterable: Iterable[ArrayLike]):
+    for array in iterable:
+        yield to_numpy(array)

dataeval/_internal/maite/utils.py

@@ -0,0 +1,30 @@
+from typing import Tuple
+
+import numpy as np
+import torch
+
+import maite.protocols.image_classification as ic
+from maite.protocols import ArrayLike
+
+
+def arraylike_to_numpy(xp: ArrayLike) -> np.ndarray:
+    """Converts ArrayLike objects to numpy"""
+
+    # Must ensure Tensors are not on GPU
+    return xp.detach().cpu().numpy() if isinstance(xp, torch.Tensor) else np.asarray(xp)
+
+
+# TODO: Overload with od.Dataset
+# TODO: Check if batching aggregation is faster (e.g. DataLoader)
+# TODO: Add verbosity flags (tqdm?)
+def extract_to_numpy(dataset: ic.Dataset) -> Tuple[np.ndarray, np.ndarray]:
+    """Iterate over dataset and separate images from labels"""
+    images = []
+    labels = []
+
+    # (image, label, metadata)
+    for image, label, _ in dataset:
+        images.append(image)
+        labels.append(label)
+
+    return np.asarray(images), np.asarray(labels)

dataeval/_internal/metrics/base.py

@@ -8,7 +8,7 @@ TCallable = TypeVar("TCallable", bound=Callable)
 
 class MetricMixin(ABC, Generic[TOutput]):
     @abstractmethod
-    def update(self, preds, targets): ...
+    def update(self, *args, **kwargs): ...
 
     @abstractmethod
     def compute(self) -> TOutput: ...
@@ -19,7 +19,7 @@ class MetricMixin(ABC, Generic[TOutput]):
 
 class EvaluateMixin(ABC, Generic[TOutput]):
     @abstractmethod
-    def evaluate(self) -> TOutput:
+    def evaluate(self, *args, **kwargs) -> TOutput:
         """Abstract method to calculate metric based off of constructor parameters"""
 
 

dataeval/_internal/metrics/ber.py

@@ -10,59 +10,11 @@ https://arxiv.org/abs/1811.06419
 from typing import Callable, Dict, Literal, Tuple
 
 import numpy as np
-from maite.protocols import ArrayLike
-from scipy.sparse import coo_matrix
-from scipy.stats import mode
 
+from dataeval._internal.functional.ber import ber_knn, ber_mst
+from dataeval._internal.interop import ArrayLike, to_numpy
 from dataeval._internal.metrics.base import EvaluateMixin, MethodsMixin
 
-from .utils import compute_neighbors, get_classes_counts, minimum_spanning_tree
-
-
-def _mst(X: np.ndarray, y: np.ndarray, _: int) -> Tuple[float, float]:
-    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 _knn(X: np.ndarray, y: np.ndarray, k: int) -> Tuple[float, float]:
-    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))))
-
-
 _METHODS = Literal["MST", "KNN"]
 _FUNCTION = Callable[[np.ndarray, np.ndarray, int], Tuple[float, float]]
 
@@ -73,10 +25,6 @@ class BER(EvaluateMixin, MethodsMixin[_METHODS, _FUNCTION]):
 
     Parameters
     ----------
-    data : np.ndarray
-        Array of images or image embeddings
-    labels : np.ndarray
-        Array of labels for each image or image embedding
     method : Literal["MST", "KNN"], default "KNN"
         Method to use when estimating the Bayes error rate
     k : int, default 1
@@ -89,22 +37,25 @@ class BER(EvaluateMixin, MethodsMixin[_METHODS, _FUNCTION]):
 
     """
 
-    def __init__(self, data: ArrayLike, labels: ArrayLike, method: _METHODS = "KNN", k: int = 1) -> None:
-        self.data = data
-        self.labels = labels
-        self.k = k
+    def __init__(self, method: _METHODS = "KNN", k: int = 1) -> None:
+        self.k: int = k
         self._set_method(method)
 
     @classmethod
-    def _methods(
-        cls,
-    ) -> Dict[str, _FUNCTION]:
-        return {"MST": _mst, "KNN": _knn}
+    def _methods(cls) -> Dict[str, _FUNCTION]:
+        return {"KNN": ber_knn, "MST": ber_mst}
 
-    def evaluate(self) -> Dict[str, float]:
+    def evaluate(self, images: ArrayLike, labels: ArrayLike) -> Dict[str, float]:
         """
         Calculates the Bayes Error Rate estimate using the provided method
 
+        Parameters
+        ----------
+        images : ArrayLike (N, : )
+            Array of images or image embeddings
+        labels : ArrayLike (N, 1)
+            Array of labels for each image or image embedding
+
         Returns
         -------
         Dict[str, float]
@@ -118,7 +69,6 @@ class BER(EvaluateMixin, MethodsMixin[_METHODS, _FUNCTION]):
         ValueError
             If unique classes M < 2
         """
-        data = np.asarray(self.data)
-        labels = np.asarray(self.labels)
-        upper, lower = self._method(data, labels, self.k)
+
+        upper, lower = self._method(to_numpy(images), to_numpy(labels), self.k)
         return {"ber": upper, "ber_lower": lower}

dataeval/_internal/metrics/coverage.py

@@ -1,55 +1,71 @@
-import math
 from typing import Literal, Tuple
 
 import numpy as np
-from scipy.spatial.distance import pdist, squareform
 
+from dataeval._internal.functional.coverage import coverage
+from dataeval._internal.interop import ArrayLike, to_numpy
+from dataeval._internal.metrics.base import EvaluateMixin
 
-class Coverage:
+
+class Coverage(EvaluateMixin):
     """
     Class for evaluating coverage and identifying images/samples that are in undercovered regions.
 
-    This implementation is based on https://dl.acm.org/doi/abs/10.1145/3448016.3457315.
-
     Parameters
     ----------
-    embeddings : np.ndarray
-        n x p array of image embeddings from the dataset.
     radius_type : Literal["adaptive", "naive"], default "adaptive"
         The function used to determine radius.
     k: int, default 20
         Number of observations required in order to be covered.
+        [1] suggests that a minimum of 20-50 samples is necessary.
     percent: np.float64, default np.float(0.01)
         Percent of observations to be considered uncovered. Only applies to adaptive radius.
 
-    Note
-    ----
-    Embeddings should be on the unit interval.
+    Reference
+    ---------
+    This implementation is based on https://dl.acm.org/doi/abs/10.1145/3448016.3457315.
+    [1] Seymour Sudman. 1976. Applied sampling. Academic Press New York (1976).
+
+    Examples
+    --------
+    Initialize the Coverage class:
+
+    >>> cover = Coverage()
+
+    Adjusting parameters:
+
+    >>> cover = Coverage(k=5, percent=0.1)
     """
 
     def __init__(
         self,
-        embeddings: np.ndarray,
         radius_type: Literal["adaptive", "naive"] = "adaptive",
         k: int = 20,
         percent: np.float64 = np.float64(0.01),
     ):
-        self.embeddings = embeddings
-        self.radius_type = radius_type
-        self.k = k
-        self.percent = percent
+        self.radius_type: Literal["adaptive", "naive"] = radius_type
+        self.k: int = k
+        self.percent: np.float64 = percent
 
-    def evaluate(self) -> Tuple[np.ndarray, np.ndarray]:
+    def evaluate(self, embeddings: ArrayLike) -> Tuple[np.ndarray, np.ndarray, float]:
         """
         Perform a one-way chi-squared test between observation frequencies and expected frequencies that
         tests the null hypothesis that the observed data has the expected frequencies.
 
+        Parameters
+        ----------
+        embeddings : ArrayLike, shape - (N, P)
+            A dataset in an ArrayLike format.
+            Function expects the data to have 2 dimensions, N number of observations in a P-dimesionial space.
+
         Returns
         -------
         np.ndarray
             Array of uncovered indices
         np.ndarray
             Array of critical value radii
+        float
+            Radius for coverage
 
         Raises
         ------
@@ -57,24 +73,24 @@ class Coverage:
             If length of embeddings is less than or equal to k
         ValueError
             If radius_type is unknown
+
+        Note
+        ----
+        Embeddings should be on the unit interval.
+
+        Example
+        -------
+        >>> cover.evaluate(embeddings)
+        (array([31,  7, 22, 37, 11]), array([0.35938604, 0.26462789, 0.20319609, 0.34140912, 0.31069921,
+               0.2308378 , 0.33300179, 0.69881025, 0.53587532, 0.35689803,
+               0.39333634, 0.67497874, 0.21788128, 0.43510162, 0.38601861,
+               0.34171868, 0.16941337, 0.66438044, 0.20319609, 0.19732733,
+               0.48660288, 0.5135814 , 0.69352653, 0.26946943, 0.31120605,
+               0.33067705, 0.30508271, 0.32802489, 0.51805702, 0.31120605,
+               0.40843265, 0.74996768, 0.31069921, 0.52263763, 0.26654013,
+               0.33113507, 0.40814838, 0.67723008, 0.48124375, 0.37243185,
+               0.29760001, 0.30907904, 0.59023236, 0.57778087, 0.21839853,
+               0.46067782, 0.31078966, 0.65199049, 0.26410603, 0.19542706]))
         """
 
-        # Calculate distance matrix, look at the (k+1)th farthest neighbor for each image.
-        n = len(self.embeddings)
-        if n <= self.k:
-            raise ValueError("Number of observations less than or equal to the specified number of neighbors.")
-        mat = squareform(pdist(self.embeddings))
-        sorted_dists = np.sort(mat, axis=1)
-        crit = sorted_dists[:, self.k + 1]
-
-        d = np.shape(self.embeddings)[1]
-        if self.radius_type == "naive":
-            self.rho = (1 / math.sqrt(math.pi)) * ((2 * self.k * math.gamma(d / 2 + 1)) / (n)) ** (1 / d)
-            pvals = np.where(crit > self.rho)[0]
-        elif self.radius_type == "adaptive":
-            # Use data adaptive cutoff
-            cutoff = int(n * self.percent)
-            pvals = np.argsort(crit)[::-1][:cutoff]
-        else:
-            raise ValueError("Invalid radius type.")
-        return pvals, crit
+        return coverage(to_numpy(embeddings), self.radius_type, self.k, self.percent)