dataeval 0.76.1__py3-none-any.whl → 0.82.0__py3-none-any.whl

dataeval/metrics/bias/_coverage.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+__all__ = []
+
+import math
+from typing import Literal
+
+import numpy as np
+from scipy.spatial.distance import pdist, squareform
+
+from dataeval.outputs import CoverageOutput
+from dataeval.outputs._base import set_metadata
+from dataeval.typing import ArrayLike
+from dataeval.utils._array import ensure_embeddings, flatten
+
+
+@set_metadata
+def coverage(
+    embeddings: ArrayLike,
+    radius_type: Literal["adaptive", "naive"] = "adaptive",
+    num_observations: int = 20,
+    percent: float = 0.01,
+) -> CoverageOutput:
+    """
+    Class for evaluating :term:`coverage<Coverage>` and identifying images/samples that are in undercovered regions.
+
+    Parameters
+    ----------
+    embeddings : ArrayLike, shape - (N, P)
+        Dataset embeddings as unit interval [0, 1].
+        Function expects the data to have 2 dimensions, N number of observations in a P-dimensional space.
+    radius_type : {"adaptive", "naive"}, default "adaptive"
+        The function used to determine radius.
+    num_observations : int, default 20
+        Number of observations required in order to be covered.
+        [1] suggests that a minimum of 20-50 samples is necessary.
+    percent : float, default 0.01
+        Percent of observations to be considered uncovered. Only applies to adaptive radius.
+
+    Returns
+    -------
+    CoverageOutput
+        Array of uncovered indices, critical value radii, and the radius for coverage
+
+    Raises
+    ------
+    ValueError
+        If embeddings are not unit interval [0-1]
+    ValueError
+        If length of :term:`embeddings<Embeddings>` is less than or equal to num_observations
+    ValueError
+        If radius_type is unknown
+
+    Note
+    ----
+    Embeddings should be on the unit interval [0-1].
+
+    Example
+    -------
+    >>> results = coverage(embeddings)
+    >>> results.uncovered_indices
+    array([447, 412,   8,  32,  63])
+    >>> results.coverage_radius
+    0.17592147193757596
+
+    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).
+    """
+
+    # Calculate distance matrix, look at the (num_observations + 1)th farthest neighbor for each image.
+    embeddings = ensure_embeddings(embeddings, dtype=np.float64, unit_interval=True)
+    len_embeddings = len(embeddings)
+    if len_embeddings <= num_observations:
+        raise ValueError(
+            f"Length of embeddings ({len_embeddings}) is less than or equal to the specified number of \
+                observations ({num_observations})."
+        )
+    embeddings_matrix = squareform(pdist(flatten(embeddings))).astype(np.float64)
+    sorted_dists = np.sort(embeddings_matrix, axis=1)
+    critical_value_radii = sorted_dists[:, num_observations + 1]
+
+    d = embeddings.shape[1]
+    if radius_type == "naive":
+        coverage_radius = (1 / math.sqrt(math.pi)) * (
+            (2 * num_observations * math.gamma(d / 2 + 1)) / (len_embeddings)
+        ) ** (1 / d)
+        uncovered_indices = np.where(critical_value_radii > coverage_radius)[0]
+    elif radius_type == "adaptive":
+        # Use data adaptive cutoff as coverage_radius
+        selection = int(max(len_embeddings * percent, 1))
+        uncovered_indices = np.argsort(critical_value_radii)[::-1][:selection]
+        coverage_radius = float(np.mean(np.sort(critical_value_radii)[::-1][selection - 1 : selection + 1]))
+    else:
+        raise ValueError(f"{radius_type} is an invalid radius type. Expected 'adaptive' or 'naive'")
+    return CoverageOutput(uncovered_indices, critical_value_radii, coverage_radius)

dataeval/metrics/bias/{diversity.py → _diversity.py}

@@ -2,113 +2,17 @@ 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 ArrayLike, NDArray
+from numpy.typing import NDArray
 
-from dataeval.output import Output, set_metadata
-from dataeval.utils.metadata import Metadata, get_counts
-from dataeval.utils.plot import heatmap
-from dataeval.utils.shared import get_method
-
-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=(10, 10))
-
-    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_list : NDArray[Any]
-        Class labels for each value in the dataset
-    """
-
-    diversity_index: NDArray[np.double]
-    classwise: NDArray[np.double]
-    factor_names: list[str]
-    class_list: NDArray[Any]
-
-    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_list
-            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
+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.data import Metadata
 
 
 def diversity_shannon(
@@ -191,6 +95,9 @@ def diversity_simpson(
     return ev_index
 
 
+_DIVERSITY_FN_MAP = {"simpson": diversity_simpson, "shannon": diversity_shannon}
+
+
 @set_metadata
 def diversity(
     metadata: Metadata,
@@ -210,7 +117,7 @@ def diversity(
     Parameters
     ----------
     metadata : Metadata
-        Preprocessed metadata from :func:`dataeval.utils.metadata.preprocess`
+        Preprocessed metadata
     method : "simpson" or "shannon", default "simpson"
         The methodology used for defining diversity
 
@@ -231,27 +138,27 @@ 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
     """
-    diversity_fn = get_method({"simpson": diversity_simpson, "shannon": diversity_shannon}, method)
+    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)
     num_bins = np.bincount(np.nonzero(cnts)[1])

dataeval/metrics/bias/{parity.py → _parity.py}

@@ -3,39 +3,18 @@ from __future__ import annotations
 __all__ = []
 
 import warnings
-from dataclasses import dataclass
-from typing import Any, Generic, TypeVar
+from typing import Any
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import NDArray
 from scipy.stats import chisquare
 from scipy.stats.contingency import chi2_contingency, crosstab
 
-from dataeval.interop import as_numpy, to_numpy
-from dataeval.output import Output, set_metadata
-from dataeval.utils.metadata import Metadata
-
-TData = TypeVar("TData", np.float64, NDArray[np.float64])
-
-
-@dataclass(frozen=True)
-class ParityOutput(Generic[TData], Output):
-    """
-    Output class for :func:`parity` and :func:`label_parity` :term:`bias<Bias>` metrics.
-
-    Attributes
-    ----------
-    score : np.float64 | NDArray[np.float64]
-        chi-squared score(s) of the test
-    p_value : np.float64 | NDArray[np.float64]
-        p-value(s) of the test
-    metadata_names : list[str] | None
-        Names of each metadata factor
-    """
-
-    score: TData
-    p_value: TData
-    metadata_names: list[str] | None
+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
 
 
 def normalize_expected_dist(expected_dist: NDArray[Any], observed_dist: NDArray[Any]) -> NDArray[Any]:
@@ -109,7 +88,7 @@ def validate_dist(label_dist: NDArray[Any], label_name: str) -> None:
         raise ValueError(f"No labels found in the {label_name} dataset")
     if np.any(label_dist < 5):
         warnings.warn(
-            f"Labels {np.where(label_dist<5)[0]} in {label_name}"
+            f"Labels {np.where(label_dist < 5)[0]} in {label_name}"
             " dataset have frequencies less than 5. This may lead"
             " to invalid chi-squared evaluation.",
             UserWarning,
@@ -121,7 +100,7 @@ def label_parity(
     expected_labels: ArrayLike,
     observed_labels: ArrayLike,
     num_classes: int | None = None,
-) -> ParityOutput[np.float64]:
+) -> LabelParityOutput:
     """
     Calculate the chi-square statistic to assess the :term:`parity<Parity>` \
     between expected and observed label distributions.
@@ -142,7 +121,7 @@ def label_parity(
 
     Returns
     -------
-    ParityOutput[np.float64]
+    LabelParityOutput
         chi-squared score and :term`P-Value` of the test
 
     Raises
@@ -171,7 +150,7 @@ def label_parity(
     >>> expected_labels = rng.choice([0, 1, 2, 3, 4], (100))
     >>> observed_labels = rng.choice([2, 3, 0, 4, 1], (100))
     >>> label_parity(expected_labels, observed_labels)
-    ParityOutput(score=14.007374204742625, p_value=0.0072715574616218, metadata_names=None)
+    LabelParityOutput(score=14.007374204742625, p_value=0.0072715574616218)
     """
 
     # Calculate
@@ -179,8 +158,8 @@ def label_parity(
         num_classes = 0
 
     # Calculate the class frequencies associated with the datasets
-    observed_dist = np.bincount(to_numpy(observed_labels), minlength=num_classes)
-    expected_dist = np.bincount(to_numpy(expected_labels), minlength=num_classes)
+    observed_dist = np.bincount(as_numpy(observed_labels), minlength=num_classes)
+    expected_dist = np.bincount(as_numpy(expected_labels), minlength=num_classes)
 
     # Validate
     validate_dist(observed_dist, "observed")
@@ -202,11 +181,11 @@ def label_parity(
         )
 
     cs, p = chisquare(f_obs=observed_dist, f_exp=expected_dist)
-    return ParityOutput(cs, p, None)
+    return LabelParityOutput(cs, p)
 
 
 @set_metadata
-def parity(metadata: Metadata) -> ParityOutput[NDArray[np.float64]]:
+def parity(metadata: Metadata) -> ParityOutput:
     """
     Calculate chi-square statistics to assess the linear relationship \
     between multiple factors and class labels.
@@ -218,7 +197,7 @@ def parity(metadata: Metadata) -> ParityOutput[NDArray[np.float64]]:
     Parameters
     ----------
     metadata : Metadata
-        Preprocessed metadata from :func:`dataeval.utils.metadata.preprocess`
+        Preprocessed metadata
 
     Returns
     -------
@@ -250,22 +229,22 @@ def parity(metadata: Metadata) -> ParityOutput[NDArray[np.float64]]:
     --------
     Randomly creating some "continuous" and categorical variables using ``np.random.default_rng``
 
-    >>> from dataeval.utils.metadata import preprocess
-    >>> rng = np.random.default_rng(175)
-    >>> labels = rng.choice([0, 1, 2], (100))
-    >>> metadata_dict = {
-    ...         "age": list(rng.choice([25, 30, 35, 45], (100))),
-    ...         "income": list(rng.choice([50000, 65000, 80000], (100))),
-    ...         "gender": list(rng.choice(["M", "F"], (100))),
-    ... }
-    >>> continuous_factor_bincounts = {"age": 4, "income": 3}
-    >>> metadata = preprocess(metadata_dict, labels, continuous_factor_bincounts)
+    >>> metadata = generate_random_metadata(
+    ...     labels=["doctor", "artist", "teacher"],
+    ...     factors={
+    ...         "age": [25, 30, 35, 45],
+    ...         "income": [50000, 65000, 80000],
+    ...         "gender": ["M", "F"]},
+    ...     length=100,
+    ...     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]), metadata_names=['age', 'income', 'gender'])
+    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
+
     chi_scores = np.zeros(metadata.discrete_data.shape[1])
     p_values = np.zeros_like(chi_scores)
-    not_enough_data = {}
+    insufficient_data = {}
     for i, col_data in enumerate(metadata.discrete_data.T):
         # Builds a contingency matrix where entry at index (r,c) represents
         # the frequency of current_factor_name achieving value unique_factor_values[r]
@@ -279,14 +258,14 @@ def parity(metadata: Metadata) -> ParityOutput[NDArray[np.float64]]:
         current_factor_name = metadata.discrete_factor_names[i]
         for int_factor, int_class in zip(counts[0], counts[1]):
             if contingency_matrix[int_factor, int_class] > 0:
-                factor_category = unique_factor_values[int_factor]
-                if current_factor_name not in not_enough_data:
-                    not_enough_data[current_factor_name] = {}
-                if factor_category not in not_enough_data[current_factor_name]:
-                    not_enough_data[current_factor_name][factor_category] = []
-                not_enough_data[current_factor_name][factor_category].append(
-                    (metadata.class_names[int_class], int(contingency_matrix[int_factor, int_class]))
-                )
+                factor_category = unique_factor_values[int_factor].item()
+                if current_factor_name not in insufficient_data:
+                    insufficient_data[current_factor_name] = {}
+                if factor_category not in insufficient_data[current_factor_name]:
+                    insufficient_data[current_factor_name][factor_category] = {}
+                class_name = metadata.class_names[int_class]
+                class_count = contingency_matrix[int_factor, int_class].item()
+                insufficient_data[current_factor_name][factor_category][class_name] = class_count
 
         # This deletes rows containing only zeros,
         # because scipy.stats.chi2_contingency fails when there are rows containing only zeros.
@@ -299,24 +278,7 @@ def parity(metadata: Metadata) -> ParityOutput[NDArray[np.float64]]:
         chi_scores[i] = chi2
         p_values[i] = p
 
-    if not_enough_data:
-        factor_msg = []
-        for factor, fact_dict in not_enough_data.items():
-            stacked_msg = []
-            for key, value in fact_dict.items():
-                msg = []
-                for item in value:
-                    msg.append(f"label {item[0]}: {item[1]} occurrences")
-                flat_msg = "\n\t\t".join(msg)
-                stacked_msg.append(f"value {key} - {flat_msg}\n\t")
-            factor_msg.append(factor + " - " + "".join(stacked_msg))
-
-        message = "\n".join(factor_msg)
-
-        warnings.warn(
-            f"The following factors did not meet the recommended 5 occurrences for each value-label combination. \n\
-            Recommend rerunning parity after adjusting the following factor-value-label combinations: \n{message}",
-            UserWarning,
-        )
+    if insufficient_data:
+        warnings.warn("Some factors did not meet the recommended 5 occurrences for each value-label combination.")
 
-    return ParityOutput(chi_scores, p_values, metadata.discrete_factor_names)
+    return ParityOutput(chi_scores, p_values, metadata.discrete_factor_names, insufficient_data)

dataeval/metrics/estimators/__init__.py

@@ -2,8 +2,19 @@
 Estimators calculate performance bounds and the statistical distance between datasets.
 """
 
-__all__ = ["ber", "divergence", "uap", "BEROutput", "DivergenceOutput", "UAPOutput"]
+__all__ = [
+    "ber",
+    "clusterer",
+    "divergence",
+    "uap",
+    "BEROutput",
+    "ClustererOutput",
+    "DivergenceOutput",
+    "UAPOutput",
+]
 
-from dataeval.metrics.estimators.ber import BEROutput, ber
-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 → _ber.py}

@@ -12,35 +12,19 @@ from __future__ import annotations
 
 __all__ = []
 
-from dataclasses import dataclass
 from typing import Literal
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import NDArray
 from scipy.sparse import coo_matrix
 from scipy.stats import mode
 
-from dataeval.interop import as_numpy
-from dataeval.output import Output, set_metadata
-from dataeval.utils.shared import compute_neighbors, get_classes_counts, get_method, 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
+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
 
 
 def ber_mst(images: NDArray[np.float64], labels: NDArray[np.int_], k: int = 1) -> tuple[float, float]:
@@ -116,18 +100,21 @@ def knn_lowerbound(value: float, classes: int, k: int) -> float:
     return ((classes - 1) / classes) * (1 - np.sqrt(max(0, 1 - ((classes / (classes - 1)) * value))))
 
 
+_BER_FN_MAP = {"KNN": ber_knn, "MST": ber_mst}
+
+
 @set_metadata
-def ber(images: ArrayLike, labels: ArrayLike, k: int = 1, method: Literal["KNN", "MST"] = "KNN") -> BEROutput:
+def ber(embeddings: ArrayLike, labels: ArrayLike, k: int = 1, method: Literal["KNN", "MST"] = "KNN") -> BEROutput:
     """
     An estimator for Multi-class :term:`Bayes error rate<Bayes Error Rate (BER)>` \
     using FR or KNN test statistic basis.
 
     Parameters
     ----------
-    images : ArrayLike (N, ... )
-        Array of images or image :term:`embeddings<Embeddings>`
+    embeddings : ArrayLike (N, ... )
+        Array of image :term:`embeddings<Embeddings>`
     labels : ArrayLike (N, 1)
-        Array of labels for each image or image embedding
+        Array of labels for each image
     k : int, default 1
         Number of nearest neighbors for KNN estimator -- ignored by MST estimator
     method : Literal["KNN", "MST"], default "KNN"
@@ -152,8 +139,34 @@ def ber(images: ArrayLike, labels: ArrayLike, k: int = 1, method: Literal["KNN",
     >>> ber(images, labels)
     BEROutput(ber=0.04, ber_lower=0.020416847668728033)
     """
-    ber_fn = get_method({"KNN": ber_knn, "MST": ber_mst}, method)
-    X = as_numpy(images)
+    ber_fn = get_method(_BER_FN_MAP, method)
+    X = ensure_embeddings(embeddings, dtype=np.float64)
     y = as_numpy(labels)
     upper, lower = ber_fn(X, y, k)
     return BEROutput(upper, lower)
+
+
+def get_classes_counts(labels: NDArray[np.int_]) -> tuple[int, int]:
+    """
+    Returns the classes and counts of from an array of labels
+
+    Parameters
+    ----------
+    label : NDArray
+        Numpy labels array
+
+    Returns
+    -------
+        Classes and counts
+
+    Raises
+    ------
+    ValueError
+        If the number of unique classes is less than 2
+    """
+    classes, counts = np.unique(labels, return_counts=True)
+    M = len(classes)
+    if M < 2:
+        raise ValueError("Label vector contains less than 2 classes!")
+    N = int(np.sum(counts))
+    return M, N

dataeval/metrics/estimators/_clusterer.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+__all__ = []
+
+
+from dataeval.outputs import ClustererOutput
+from dataeval.typing import ArrayLike
+from dataeval.utils._array import as_numpy
+
+
+def clusterer(data: ArrayLike) -> ClustererOutput:
+    """
+    Uses hierarchical clustering on the flattened data and returns clustering
+    information.
+
+    Parameters
+    ----------
+    data : ArrayLike, shape - (N, ...)
+        A dataset in an ArrayLike format. Function expects the data to have 2
+        or more dimensions which will flatten to (N, P) where N number of
+        observations in a P-dimensional space.
+
+    Returns
+    -------
+    :class:`.ClustererOutput`
+
+    Note
+    ----
+    The clusterer works best when the length of the feature dimension, P, is
+    less than 500. If flattening a CxHxW image results in a dimension larger
+    than 500, then it is recommended to reduce the dimensions.
+
+    Example
+    -------
+    >>> clusterer(clusterer_images).clusters
+    array([ 2,  0,  0,  0,  0,  0,  4,  0,  3,  1,  1,  0,  2,  0,  0,  0,  0,
+            4,  2,  0,  0,  1,  2,  0,  1,  3,  0,  3,  3,  4,  0,  0,  3,  0,
+            3, -1,  0,  0,  2,  4,  3,  4,  0,  1,  0, -1,  3,  0,  0,  0])
+    """
+    # Delay load numba compiled functions
+    from dataeval.utils._clusterer import cluster
+
+    c = cluster(data)
+    return ClustererOutput(c.clusters, c.mst, c.linkage_tree, as_numpy(c.condensed_tree), c.membership_strengths)