distclassipy 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

distclassipy/classifier.py

@@ -3,6 +3,15 @@
 This module contains the DistanceMetricClassifier introduced by Chaini et al. (2024)
 in "Light Curve Classification with DistClassiPy: a new distance-based classifier"
 
+
+.. autoclass:: distclassipy.classifier.DistanceMetricClassifier
+   :members:
+   :exclude-members: set_fit_request, set_predict_request
+
+.. doctest-skip::
+
+.. skip::
+
 Copyright (C) 2024  Siddharth Chaini
 -----
 This program is free software: you can redistribute it and/or modify
@@ -19,7 +28,7 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-from typing import Callable
+from typing import Callable, Tuple
 
 import numpy as np
 
@@ -28,11 +37,12 @@ import pandas as pd
 import scipy
 
 from sklearn.base import BaseEstimator, ClassifierMixin
-from sklearn.neighbors import KernelDensity
+from sklearn.metrics import accuracy_score
+from sklearn.model_selection import train_test_split
 from sklearn.utils.multiclass import unique_labels
 from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
 
-from .distances import Distance
+from .distances import Distance, _ALL_METRICS
 
 # Hardcoded source packages to check for distance metrics.
 METRIC_SOURCES_ = {
@@ -41,6 +51,52 @@ METRIC_SOURCES_ = {
 }
 
 
+def initialize_metric_function(metric):
+    """Set the metric function based on the provided metric.
+
+    If the metric is a string, the function will look for a corresponding
+    function in scipy.spatial.distance or distances.Distance. If the metric
+    is a function, it will be used directly.
+    """
+    if callable(metric):
+        metric_fn_ = metric
+        metric_arg_ = metric
+
+    elif isinstance(metric, str):
+        metric_str_lowercase = metric.lower()
+        metric_found = False
+        for package_str, source in METRIC_SOURCES_.items():
+
+            # Don't use scipy for jaccard as their implementation only works with
+            # booleans - use custom jaccard instead
+            if (
+                package_str == "scipy.spatial.distance"
+                and metric_str_lowercase == "jaccard"
+            ):
+                continue
+
+            if hasattr(source, metric_str_lowercase):
+                metric_fn_ = getattr(source, metric_str_lowercase)
+                metric_found = True
+
+                # Use the string as an argument if it belongs to scipy as it is
+                # optimized
+                metric_arg_ = (
+                    metric if package_str == "scipy.spatial.distance" else metric_fn_
+                )
+                break
+        if not metric_found:
+            raise ValueError(
+                f"{metric} metric not found. Please pass a string of the "
+                "name of a metric in scipy.spatial.distance or "
+                "distances.Distance, or pass a metric function directly. For a "
+                "list of available metrics, see: "
+                "https://sidchaini.github.io/DistClassiPy/distances.html or "
+                "https://docs.scipy.org/doc/scipy/reference/spatial.distance.html"
+            )
+    return metric_fn_, metric_arg_
+
+
 class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
     """A distance-based classifier that supports different distance metrics.
 
@@ -54,8 +110,6 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
 
     Parameters
     ----------
-    metric : str or callable, default="euclidean"
-        The distance metric to use for calculating the distance between features.
     scale : bool, default=True
         Whether to scale the distance between the test object and the centroid for a
         class in the feature space. If True, the data will be scaled based on the
@@ -70,36 +124,15 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
 
         .. versionadded:: 0.1.0
 
-    calculate_kde : bool, default=False
-        Whether to calculate a kernel density estimate based confidence parameter.
-    calculate_1d_dist : bool, default=False
-        Whether to calculate the 1-dimensional distance based confidence parameter.
 
     Attributes
     ----------
-    metric : str or callable
-        The distance metric used for classification.
     scale : bool
         Indicates whether the data is scaled.
     central_stat : str
         The statistic used for calculating central tendency.
     dispersion_stat : str
         The statistic used for calculating dispersion.
-    calculate_kde : bool
-        Indicates whether a kernel density estimate is calculated.
-    calculate_1d_dist : bool
-        Indicates whether 1-dimensional distances are calculated.
-
-    See Also
-    --------
-    scipy.spatial.dist : Other distance metrics provided in SciPy
-    distclassipy.Distance : Distance metrics included with DistClassiPy
-
-    Notes
-    -----
-    If using distance metrics supported by SciPy, it is desirable to pass a string,
-    which allows SciPy to use an optimized C version of the code instead of the slower
-    Python version.
 
     References
     ----------
@@ -113,77 +146,27 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
     >>> X, y = make_classification(n_samples=1000, n_features=4,
     ...                            n_informative=2, n_redundant=0,
     ...                            random_state=0, shuffle=False)
-    >>> clf = dcpy.DistanceMetricClassifier(metric="canberra")
+    >>> clf = dcpy.DistanceMetricClassifier()
     >>> clf.fit(X, y)
     DistanceMetricClassifier(...)
-    >>> print(clf.predict([[0, 0, 0, 0]]))
+    >>> print(clf.predict([[0, 0, 0, 0]], metric="canberra"))
     [0]
     """
 
     def __init__(
         self,
-        metric: str | Callable = "euclidean",
         scale: bool = True,
         central_stat: str = "median",
         dispersion_stat: str = "std",
-        calculate_kde: bool = True,
-        calculate_1d_dist: bool = True,
-    ):
+    ) -> None:
         """Initialize the classifier with specified parameters."""
-        self.metric = metric
         self.scale = scale
         self.central_stat = central_stat
         self.dispersion_stat = dispersion_stat
-        self.calculate_kde = calculate_kde
-        self.calculate_1d_dist = calculate_1d_dist
-
-    def initialize_metric_function(self):
-        """Set the metric function based on the provided metric.
-
-        If the metric is a string, the function will look for a corresponding
-        function in scipy.spatial.distance or distances.Distance. If the metric
-        is a function, it will be used directly.
-        """
-        if callable(self.metric):
-            self.metric_fn_ = self.metric
-            self.metric_arg_ = self.metric
-
-        elif isinstance(self.metric, str):
-            metric_str_lowercase = self.metric.lower()
-            metric_found = False
-            for package_str, source in METRIC_SOURCES_.items():
-
-                # Don't use scipy for jaccard as their implementation only works with
-                # booleans - use custom jaccard instead
-                if (
-                    package_str == "scipy.spatial.distance"
-                    and metric_str_lowercase == "jaccard"
-                ):
-                    continue
-
-                if hasattr(source, metric_str_lowercase):
-                    self.metric_fn_ = getattr(source, metric_str_lowercase)
-                    metric_found = True
-
-                    # Use the string as an argument if it belongs to scipy as it is
-                    # optimized
-                    self.metric_arg_ = (
-                        self.metric
-                        if package_str == "scipy.spatial.distance"
-                        else self.metric_fn_
-                    )
-                    break
-            if not metric_found:
-                raise ValueError(
-                    f"{self.metric} metric not found. Please pass a string of the "
-                    "name of a metric in scipy.spatial.distance or "
-                    "distances.Distance, or pass a metric function directly. For a "
-                    "list of available metrics, see: "
-                    "https://sidchaini.github.io/DistClassiPy/distances.html or "
-                    "https://docs.scipy.org/doc/scipy/reference/spatial.distance.html"
-                )
 
-    def fit(self, X: np.array, y: np.array, feat_labels: list[str] = None):
+    def fit(
+        self, X: np.array, y: np.array, feat_labels: list[str] = None
+    ) -> "DistanceMetricClassifier":
         """Calculate the feature space centroid for all classes.
 
         This function calculates the feature space centroid in the training
@@ -209,9 +192,9 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
         """
         X, y = check_X_y(X, y)
         self.classes_ = unique_labels(y)
-        self.n_features_in_ = X.shape[1]
-
-        self.initialize_metric_function()
+        self.n_features_in_ = X.shape[
+            1
+        ]  # Number of features seen during fit - required for sklearn compatibility.
 
         if feat_labels is None:
             feat_labels = [f"Feature_{x}" for x in range(X.shape[1])]
@@ -256,27 +239,15 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
             )
             self.df_iqr_ = df_iqr
 
-        if self.calculate_kde:
-            self.kde_dict_ = {}
-
-            for cl in self.classes_:
-                subX = X[y == cl]
-                # Implement the following in an if-else to save computational time.
-                # kde = KernelDensity(bandwidth='scott', metric=self.metric)
-                # kde.fit(subX)
-                kde = KernelDensity(
-                    bandwidth="scott",
-                    metric="pyfunc",
-                    metric_params={"func": self.metric_fn_},
-                )
-                kde.fit(subX)
-                self.kde_dict_[cl] = kde
-
         self.is_fitted_ = True
 
         return self
 
-    def predict(self, X: np.array):
+    def predict(
+        self,
+        X: np.array,
+        metric: str | Callable = "euclidean",
+    ) -> np.ndarray:
         """Predict the class labels for the provided X.
 
         The prediction is based on the distance of each data point in the input sample
@@ -287,18 +258,35 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
         ----------
         X : array-like of shape (n_samples, n_features)
             The input samples.
+        metric : str or callable, default="euclidean"
+            The distance metric to use for calculating the distance between features.
+
+            .. versionchanged:: 0.2.0
+               The metric is now specified at prediction time rather
+               than during initialization, providing greater flexibility.
 
         Returns
         -------
         y : ndarray of shape (n_samples,)
             The predicted classes.
+
+        See Also
+        --------
+        scipy.spatial.dist : Other distance metrics provided in SciPy
+        distclassipy.Distance : Distance metrics included with DistClassiPy
+
+        Notes
+        -----
+        If using distance metrics supported by SciPy, it is desirable to pass a string,
+        which allows SciPy to use an optimized C version of the code instead of the
+        slower Python version.
         """
         check_is_fitted(self, "is_fitted_")
         X = check_array(X)
-
+        metric_fn_, metric_arg_ = initialize_metric_function(metric)
         if not self.scale:
             dist_arr = scipy.spatial.distance.cdist(
-                XA=X, XB=self.df_centroid_.to_numpy(), metric=self.metric_arg_
+                XA=X, XB=self.df_centroid_.to_numpy(), metric=metric_arg_
             )
 
         else:
@@ -315,16 +303,18 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
                 w = wtdf.loc[cl].to_numpy()  # 1/std dev
                 XB = XB * w  # w is for this class only
                 XA = X * w  # w is for this class only
-                cl_dist = scipy.spatial.distance.cdist(
-                    XA=XA, XB=XB, metric=self.metric_arg_
-                )
+                cl_dist = scipy.spatial.distance.cdist(XA=XA, XB=XB, metric=metric_arg_)
                 dist_arr_list.append(cl_dist)
             dist_arr = np.column_stack(dist_arr_list)
 
         y_pred = self.classes_[dist_arr.argmin(axis=1)]
         return y_pred
 
-    def predict_and_analyse(self, X: np.array):
+    def predict_and_analyse(
+        self,
+        X: np.array,
+        metric: str | Callable = "euclidean",
+    ) -> np.ndarray:
         """Predict the class labels for the provided X and perform analysis.
 
         The prediction is based on the distance of each data point in the input sample
@@ -338,18 +328,35 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
         ----------
         X : array-like of shape (n_samples, n_features)
             The input samples.
+        metric : str or callable, default="euclidean"
+            The distance metric to use for calculating the distance between features.
+
 
         Returns
         -------
         y : ndarray of shape (n_samples,)
             The predicted classes.
+
+        See Also
+        --------
+        scipy.spatial.dist : Other distance metrics provided in SciPy
+        distclassipy.Distance : Distance metrics included with DistClassiPy
+
+        Notes
+        -----
+        If using distance metrics supported by SciPy, it is desirable to pass a string,
+        which allows SciPy to use an optimized C version of the code instead
+        of the slower Python version.
+
         """
         check_is_fitted(self, "is_fitted_")
         X = check_array(X)
 
+        metric_fn_, metric_arg_ = initialize_metric_function(metric)
+
         if not self.scale:
             dist_arr = scipy.spatial.distance.cdist(
-                XA=X, XB=self.df_centroid_.to_numpy(), metric=self.metric_arg_
+                XA=X, XB=self.df_centroid_.to_numpy(), metric=metric_arg_
             )
 
         else:
@@ -366,9 +373,7 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
                 w = wtdf.loc[cl].to_numpy()  # 1/std dev
                 XB = XB * w  # w is for this class only
                 XA = X * w  # w is for this class only
-                cl_dist = scipy.spatial.distance.cdist(
-                    XA=XA, XB=XB, metric=self.metric_arg_
-                )
+                cl_dist = scipy.spatial.distance.cdist(XA=XA, XB=XB, metric=metric_arg_)
                 dist_arr_list.append(cl_dist)
             dist_arr = np.column_stack(dist_arr_list)
 
@@ -381,68 +386,15 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
 
         y_pred = self.classes_[dist_arr.argmin(axis=1)]
 
-        if self.calculate_kde:
-            # NEW: Rescale in terms of median likelihoods - calculate here
-            scale_factors = np.exp(
-                [
-                    self.kde_dict_[cl].score_samples(
-                        self.df_centroid_.loc[cl].to_numpy().reshape(1, -1)
-                    )[0]
-                    for cl in self.classes_
-                ]
-            )
-
-            likelihood_arr = []
-            for k in self.kde_dict_.keys():
-                log_pdf = self.kde_dict_[k].score_samples(X)
-                likelihood_val = np.exp(log_pdf)
-                likelihood_arr.append(likelihood_val)
-            self.likelihood_arr_ = np.array(likelihood_arr).T
-
-            # NEW: Rescale in terms of median likelihoods - rescale here
-            self.likelihood_arr_ = self.likelihood_arr_ / scale_factors
-
-        if self.calculate_1d_dist:
-            conf_cl = []
-            Xdf_temp = pd.DataFrame(data=X, columns=self.df_centroid_.columns)
-            for cl in self.classes_:
-                sum_1d_dists = np.zeros(shape=(len(Xdf_temp)))
-                for feat in Xdf_temp.columns:
-                    dists = scipy.spatial.distance.cdist(
-                        XA=np.zeros(shape=(1, 1)),
-                        XB=(self.df_centroid_.loc[cl] - Xdf_temp)[feat]
-                        .to_numpy()
-                        .reshape(-1, 1),
-                        metric=self.metric_arg_,
-                    ).ravel()
-                    if self.scale and self.dispersion_stat == "std":
-                        sum_1d_dists = sum_1d_dists + dists / self.df_std_.loc[cl, feat]
-                    elif self.scale and self.dispersion_stat == "std":
-                        sum_1d_dists = sum_1d_dists + dists / self.df_iqr_.loc[cl, feat]
-                    else:
-                        sum_1d_dists = sum_1d_dists + dists
-                confs = 1 / np.clip(sum_1d_dists, a_min=np.finfo(float).eps, a_max=None)
-                conf_cl.append(confs)
-            conf_cl = np.array(conf_cl)
-            self.conf_cl_ = conf_cl
-
         self.analyis_ = True
 
         return y_pred
 
-    def calculate_confidence(self, method: str = "distance_inverse"):
+    def calculate_confidence(self):
         """Calculate the confidence for each prediction.
 
-        The confidence is calculated based on either the distance of each data point to
-        the centroids of the training data, optionally the kernel density estimate or
-        1-dimensional distance.
-
-        Parameters
-        ----------
-        method : {"distance_inverse", "1d_distance_inverse","kde_likelihood"},
-                 default="distance_inverse"
-            The method to use for calculating confidence. Default is
-            'distance_inverse'.
+        The confidence is calculated as the inverse of the distance of each data point
+        to the centroids of the training data.
         """
         check_is_fitted(self, "is_fitted_")
         if not hasattr(self, "analyis_"):
@@ -452,34 +404,278 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
             )
 
         # Calculate confidence for each prediction
-        if method == "distance_inverse":
-            self.confidence_df_ = 1 / np.clip(
-                self.centroid_dist_df_, a_min=np.finfo(float).eps, a_max=None
-            )
-            self.confidence_df_.columns = [
-                x.replace("_dist", "_conf") for x in self.confidence_df_.columns
-            ]
-
-        elif method == "1d_distance_inverse":
-            if not self.calculate_1d_dist:
-                raise ValueError(
-                    "method='1d_distance_inverse' is only valid if calculate_1d_dist "
-                    "is set to True"
-                )
-            self.confidence_df_ = pd.DataFrame(
-                data=self.conf_cl_.T, columns=[f"{x}_conf" for x in self.classes_]
+        self.confidence_df_ = 1 / np.clip(
+            self.centroid_dist_df_, a_min=np.finfo(float).eps, a_max=None
+        )
+        self.confidence_df_.columns = [
+            x.replace("_dist", "_conf") for x in self.confidence_df_.columns
+        ]
+
+        return self.confidence_df_.to_numpy()
+
+    def score(self, X, y, metric: str | Callable = "euclidean") -> float:
+        """Return the mean accuracy on the given test data and labels.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Test samples.
+        y : array-like of shape (n_samples,)
+            True labels for X.
+        metric : str or callable, default="euclidean"
+            The distance metric to use for calculating the distance between features.
+
+        Returns
+        -------
+        score : float
+            Mean accuracy of self.predict(X) wrt. y.
+        """
+        y_pred = self.predict(X, metric=metric)
+        return accuracy_score(y, y_pred)
+
+
+def find_best_metrics(
+    clf: "DistanceMetricClassifier",
+    X: np.ndarray,
+    y: np.ndarray,
+    feat_idx: int,
+    n_quantiles: int = 4,
+    metrics_to_consider: list[str] = None,
+) -> Tuple[pd.DataFrame, pd.Series, np.ndarray]:
+    """Evaluate and find the best distance metrics for a given feature.
+
+    This function evaluates different distance metrics to determine which
+    performs best for a specific feature in the dataset. It splits the data
+    into quantiles based on the specified feature and calculates the accuracy
+    of the classifier for each metric within these quantiles.
+
+    .. versionadded:: 0.2.0
+
+    Parameters
+    ----------
+    clf : DistanceMetricClassifier
+        The classifier instance to be used for evaluation.
+    X : np.ndarray
+        The input feature matrix.
+    y : np.ndarray
+        The target labels.
+    feat_idx : int
+        The index of the feature to be used for quantile splitting.
+    n_quantiles : int, default=4
+        The number of quantiles to split the data into.
+    metrics_to_consider : list of str, optional
+        A list of distance metrics to evaluate. If None, all available
+        metrics within DistClassiPy will be considered.
+
+    Returns
+    -------
+    quantile_scores_df : pd.DataFrame
+        A DataFrame containing the accuracy scores for each metric across
+        different quantiles.
+    best_metrics_per_quantile : pd.Series
+        A Series indicating the best-performing metric for each quantile.
+    group_bins : np.ndarray
+        The bins used for quantile splitting.
+    """
+    X = check_array(X)
+    feature_labels = [f"Feature_{i}" for i in range(X.shape[1])]
+    feature_name = f"Feature_{feat_idx}"
+
+    if metrics_to_consider is None:
+        metrics_to_consider = _ALL_METRICS
+
+    X_df = pd.DataFrame(X, columns=feature_labels)
+    y_df = pd.DataFrame(y, columns=["Target"])
+    quantiles, group_bins = pd.qcut(X_df[feature_name], q=n_quantiles, retbins=True)
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X_df, y_df, test_size=0.25, stratify=quantiles
+    )
+
+    clf.fit(X_train, y_train.to_numpy().ravel())
+    grouped_test_data = X_test.groupby(quantiles, observed=False)
+
+    quantile_scores = []
+    for metric in metrics_to_consider:
+        scores_for_metric = [
+            accuracy_score(
+                y_test.loc[subdf.index], clf.predict(subdf.to_numpy(), metric=metric)
             )
+            for _, subdf in grouped_test_data
+        ]
+        quantile_scores.append(scores_for_metric)
+
+    quantile_scores = np.array(quantile_scores) * 100
+    quantile_scores_df = pd.DataFrame(
+        data=quantile_scores,
+        index=metrics_to_consider,
+        columns=[f"Quantile {i+1}" for i in range(n_quantiles)],
+    )
+
+    best_metrics_per_quantile = quantile_scores_df.idxmax()
+
+    return quantile_scores_df, best_metrics_per_quantile, group_bins
+
+
+class EnsembleDistanceClassifier(BaseEstimator, ClassifierMixin):
+    """An ensemble classifier that uses different metrics for each quantile.
+
+    This classifier splits the data into quantiles based on a specified
+    feature and uses different distance metrics for each quantile to
+    construct an ensemble classifier for each quantile, generally leading
+    to better performance.
+    Note, however, this involves fitting the training set for each metric
+    to evaluate performance, making this more computationally expensive.
+
+    .. versionadded:: 0.2.0
+    """
+
+    def __init__(
+        self,
+        feat_idx: int,
+        scale: bool = True,
+        central_stat: str = "median",
+        dispersion_stat: str = "std",
+        metrics_to_consider: list[str] = None,
+    ) -> None:
+        """Initialize the classifier with specified parameters.
+
+        Parameters
+        ----------
+        feat_idx : int
+            The index of the feature to be used for quantile splitting.
+        scale : bool, default=True
+            Whether to scale the distance between the test object and the centroid.
+        central_stat : str, default="median"
+            The statistic used to calculate the central tendency of the data.
+        dispersion_stat : str, default="std"
+            The statistic used to calculate the dispersion of the data.
+        metrics_to_consider : list of str, optional
+            A list of distance metrics to evaluate. If None, all available
+            metrics within DistClassiPy will be considered.
+        """
+        self.feat_idx = feat_idx
+        self.scale = scale
+        self.central_stat = central_stat
+        self.dispersion_stat = dispersion_stat
+        self.metrics_to_consider = metrics_to_consider
+
+    def fit(
+        self, X: np.ndarray, y: np.ndarray, n_quantiles: int = 4
+    ) -> "EnsembleDistanceClassifier":
+        """Fit the ensemble classifier using the best metrics for each quantile.
+
+        Parameters
+        ----------
+        X : np.ndarray
+            The input feature matrix.
+        y : np.ndarray
+            The target labels.
+        n_quantiles : int, default=4
+            The number of quantiles to split the data into.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+        self.clf_ = DistanceMetricClassifier(
+            scale=self.scale,
+            central_stat=self.central_stat,
+            dispersion_stat=self.dispersion_stat,
+        )
+
+        # Find best metrics based on training set quantiles
+        self.quantile_scores_df_, self.best_metrics_per_quantile_, self.group_bins = (
+            self.evaluate_metrics(X, y, n_quantiles)
+        )
+
+        # Ensure the bins work with values outside of training data
+        self.group_bins[0] = -np.inf
+        self.group_bins[-1] = np.inf
+
+        self.group_labels = [f"Quantile {i+1}" for i in range(n_quantiles)]
+        self.clf_.fit(X, y)
+        self.is_fitted_ = True
+        return self
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Predict class labels using the best metric for each quantile.
 
-        elif method == "kde_likelihood":
-            if not self.calculate_kde:
-                raise ValueError(
-                    "method='kde_likelihood' is only valid if calculate_kde is set "
-                    "to True"
+        Parameters
+        ----------
+        X : np.ndarray
+            The input samples.
+
+        Returns
+        -------
+        predictions : np.ndarray
+            The predicted class labels.
+        """
+        check_is_fitted(self, "is_fitted_")
+        X = check_array(X)
+
+        # notes for pred during best:
+        # option 1:
+        # loop through each metric, merge quantiles for each metric
+        # pred on this
+        # option 2, easier, but slower:
+        # loop through each quantile, and append pred
+
+        quantiles = pd.cut(
+            X[:, self.feat_idx], bins=self.group_bins, labels=self.group_labels
+        )
+        # grouped_data = pd.DataFrame(X).groupby(quantiles, observed=False)
+        quantile_indices = quantiles.codes  # Get integer codes for quantiles
+        predictions = np.empty(X.shape[0], dtype=int)
+        # for i, (lim, subdf) in enumerate(grouped_data):
+        #     best_metric = self.best_metrics_per_quantile_.loc[self.group_labels[i]]
+        #     preds = self.clf_.predict(subdf.to_numpy(), metric=best_metric)
+        #     predictions[subdf.index] = preds
+        # Precompute predictions for each quantile
+        quantile_predictions = {}
+        for i, label in enumerate(self.group_labels):
+            best_metric = self.best_metrics_per_quantile_.loc[label]
+            quantile_data = X[quantile_indices == i]
+            if quantile_data.size > 0:
+                quantile_predictions[i] = self.clf_.predict(
+                    quantile_data, metric=best_metric
                 )
 
-            self.confidence_df_ = pd.DataFrame(
-                data=self.likelihood_arr_,
-                columns=[f"{x}_conf" for x in self.kde_dict_.keys()],
-            )
+        # Assign predictions to the corresponding indices
+        for i, preds in quantile_predictions.items():
+            predictions[quantile_indices == i] = preds
 
-        return self.confidence_df_.to_numpy()
+        return predictions
+
+    def evaluate_metrics(
+        self, X: np.ndarray, y: np.ndarray, n_quantiles: int = 4
+    ) -> Tuple[pd.DataFrame, pd.Series, np.ndarray]:
+        """Evaluate and find the best distance metrics for the specified feature.
+
+        This method uses the standalone `find_best_metrics` function to evaluate
+        different distance metrics and determine the best-performing ones for
+        each quantile.
+
+        Parameters
+        ----------
+        X : np.ndarray
+            The input feature matrix.
+        y : np.ndarray
+            The target labels.
+        n_quantiles : int, default=4
+            The number of quantiles to split the data into.
+
+        Returns
+        -------
+        quantile_scores_df : pd.DataFrame
+            A DataFrame containing the accuracy scores for each metric across
+            different quantiles.
+        best_metrics_per_quantile : pd.Series
+            A Series indicating the best-performing metric for each quantile.
+        group_bins : np.ndarray
+            The bins used for quantile splitting.
+        """
+        return find_best_metrics(
+            self.clf_, X, y, self.feat_idx, n_quantiles, self.metrics_to_consider
+        )