distclassipy 0.2.0a0__tar.gz → 0.2.1__tar.gz

{distclassipy-0.2.0a0 → distclassipy-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: distclassipy
-Version: 0.2.0a0
+Version: 0.2.1
 Summary: A python package for a distance-based classifier which can use several different distance metrics.
 Author-email: Siddharth Chaini <sidchaini@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -740,17 +740,25 @@ X, y = make_classification(
     random_state=0,
     shuffle=False,
 )
+# Example usage of DistanceMetricClassifier
 clf = dcpy.DistanceMetricClassifier()
 clf.fit(X, y)
-print(clf.predict([[0, 0, 0, 0]]), metric="canberra")
+print(clf.predict([[0, 0, 0, 0]], metric="canberra"))
+
+# Example usage of EnsembleDistanceClassifier
+ensemble_clf = dcpy.EnsembleDistanceClassifier(feat_idx=0)
+ensemble_clf.fit(X, y)
+print(ensemble_clf.predict(X))
 ```
 
 ## Features
 - **Distance Metric-Based Classification**: Utilizes a variety of distance metrics for classification.
 - **Customizable for Scientific Goals**: Allows fine-tuning based on scientific objectives by selecting appropriate distance metrics and features, enhancing both computational efficiency and model performance.
 - **Interpretable Results**: Offers improved interpretability of classification outcomes by directly using distance metrics and feature importance, making it ideal for scientific applications.
-- **Efficient and Scalable**: Demonstrates lower computational requirements compared to traditional methods like Random Forests, making it suitable for large datasets
-- **Open Source and Accessible**: Available as an open-source Python package on PyPI, encouraging broad application in astronomy and beyond
+- **Efficient and Scalable**: Demonstrates lower computational requirements compared to traditional methods like Random Forests, making it suitable for large datasets.
+- **Open Source and Accessible**: Available as an open-source Python package on PyPI, encouraging broad application in astronomy and beyond.
+- **(NEW) Ensemble Distance Classification**: Leverages an ensemble approach to use different distance metrics for each quantile, improving classification performance across diverse data distributions.
+- **(NEW) Expanded Distance Metrics**: DistClassiPy now offers 43 built-in distance metrics, an increase from the previous 18. Additionally, users can still define and use custom distance metrics as needed.
 
 ## Documentation
 

{distclassipy-0.2.0a0 → distclassipy-0.2.1}/README.md

@@ -40,17 +40,25 @@ X, y = make_classification(
     random_state=0,
     shuffle=False,
 )
+# Example usage of DistanceMetricClassifier
 clf = dcpy.DistanceMetricClassifier()
 clf.fit(X, y)
-print(clf.predict([[0, 0, 0, 0]]), metric="canberra")
+print(clf.predict([[0, 0, 0, 0]], metric="canberra"))
+
+# Example usage of EnsembleDistanceClassifier
+ensemble_clf = dcpy.EnsembleDistanceClassifier(feat_idx=0)
+ensemble_clf.fit(X, y)
+print(ensemble_clf.predict(X))
 ```
 
 ## Features
 - **Distance Metric-Based Classification**: Utilizes a variety of distance metrics for classification.
 - **Customizable for Scientific Goals**: Allows fine-tuning based on scientific objectives by selecting appropriate distance metrics and features, enhancing both computational efficiency and model performance.
 - **Interpretable Results**: Offers improved interpretability of classification outcomes by directly using distance metrics and feature importance, making it ideal for scientific applications.
-- **Efficient and Scalable**: Demonstrates lower computational requirements compared to traditional methods like Random Forests, making it suitable for large datasets
-- **Open Source and Accessible**: Available as an open-source Python package on PyPI, encouraging broad application in astronomy and beyond
+- **Efficient and Scalable**: Demonstrates lower computational requirements compared to traditional methods like Random Forests, making it suitable for large datasets.
+- **Open Source and Accessible**: Available as an open-source Python package on PyPI, encouraging broad application in astronomy and beyond.
+- **(NEW) Ensemble Distance Classification**: Leverages an ensemble approach to use different distance metrics for each quantile, improving classification performance across diverse data distributions.
+- **(NEW) Expanded Distance Metrics**: DistClassiPy now offers 43 built-in distance metrics, an increase from the previous 18. Additionally, users can still define and use custom distance metrics as needed.
 
 ## Documentation
 

{distclassipy-0.2.0a0 → distclassipy-0.2.1}/distclassipy/__init__.py

@@ -22,7 +22,17 @@ 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 .classifier import DistanceMetricClassifier  # noqa
-from .distances import Distance  # noqa
+from .classifier import (
+    DistanceMetricClassifier,
+    EnsembleDistanceClassifier,
+)
+from .distances import Distance, _ALL_METRICS
 
-__version__ = "0.2.0a0"
+__version__ = "0.2.1"
+
+__all__ = [
+    "DistanceMetricClassifier",
+    "EnsembleDistanceClassifier",
+    "Distance",
+    "_ALL_METRICS",
+]

{distclassipy-0.2.0a0 → distclassipy-0.2.1}/distclassipy/classifier.py

@@ -3,6 +3,21 @@
 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:
+   :inherited-members:
+   :exclude-members: set_fit_request, set_predict_request
+
+.. autoclass:: distclassipy.classifier.EnsembleDistanceClassifier
+   :members:
+   :inherited-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 +34,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,10 +43,12 @@ import pandas as pd
 import scipy
 
 from sklearn.base import BaseEstimator, ClassifierMixin
+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_ = {
@@ -113,16 +130,6 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
 
         .. versionadded:: 0.1.0
 
-
-    Attributes
-    ----------
-    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.
-
     References
     ----------
     .. [1] "Light Curve Classification with DistClassiPy: a new distance-based
@@ -135,10 +142,10 @@ 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]
     """
 
@@ -147,13 +154,15 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
         scale: bool = True,
         central_stat: str = "median",
         dispersion_stat: str = "std",
-    ):
+    ) -> None:
         """Initialize the classifier with specified parameters."""
         self.scale = scale
         self.central_stat = central_stat
         self.dispersion_stat = dispersion_stat
 
-    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
@@ -234,7 +243,7 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
         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
@@ -248,6 +257,10 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
         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,)
@@ -266,9 +279,7 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
         """
         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=metric_arg_
@@ -299,7 +310,7 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
         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
@@ -397,3 +408,289 @@ class DistanceMetricClassifier(BaseEstimator, ClassifierMixin):
         ]
 
         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)
+
+
+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,
+        random_state: int = 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.
+        random_state : int, RandomState instance or None, optional (default=None)
+            Controls the randomness of the estimator. Pass an int for reproducible
+            output across multiple function calls.
+
+            .. versionadded:: 0.2.1
+        """
+        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
+        self.random_state = random_state
+
+    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.
+
+        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=object)  # Change dtype to object
+        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
+        #         )
+
+        # Assign predictions to the corresponding indices
+        # for i, preds in quantile_predictions.items():
+        #     predictions[quantile_indices == i] = preds
+
+        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,
+            self.random_state,
+        )
+
+
+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,
+    random_state: int = 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.
+    random_state : int, RandomState instance or None, optional (default=None)
+        Controls the randomness of the estimator. Pass an int for reproducible
+        output across multiple function calls.
+
+        .. versionadded:: 0.2.1
+
+    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, random_state=random_state
+    )
+
+    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

{distclassipy-0.2.0a0 → distclassipy-0.2.1}/distclassipy/distances.py

@@ -48,6 +48,52 @@ import numpy as np
 
 import scipy
 
+_ALL_METRICS = [
+    "euclidean",
+    "braycurtis",
+    "canberra",
+    "cityblock",
+    "chebyshev",
+    "clark",
+    "correlation",
+    "cosine",
+    "hellinger",
+    "jaccard",
+    "lorentzian",
+    "marylandbridge",
+    "meehl",
+    "motyka",
+    "soergel",
+    "wave_hedges",
+    "kulczynski",
+    "add_chisq",
+    "acc",
+    "chebyshev_min",
+    "czekanowski",
+    "dice",
+    "divergence",
+    "google",
+    "gower",
+    "jeffreys",
+    "jensenshannon_divergence",
+    "jensen_difference",
+    "kumarjohnson",
+    "matusita",
+    "minkowski",
+    "penroseshape",
+    "prob_chisq",
+    "ruzicka",
+    "sorensen",
+    "squared_chisq",
+    "squaredchord",
+    "squared_euclidean",
+    "taneja",
+    "tanimoto",
+    "topsoe",
+    "vicis_symmetric_chisq",
+    "vicis_wave_hedges",
+]
+
 
 class Distance:
     """A class to calculate various distance metrics between vectors.
@@ -352,7 +398,11 @@ class Distance:
               1(4), 300-307.
         """
         u, v = np.asarray(u), np.asarray(v)
-        return np.sqrt(2 * np.sum((np.sqrt(u) - np.sqrt(v)) ** 2))
+        # Clip negative values to zero for valid sqrt
+        with np.errstate(divide="ignore", invalid="ignore"):
+            u = np.clip(u, a_min=0, a_max=None)
+            v = np.clip(v, a_min=0, a_max=None)
+            return np.sqrt(2 * np.sum((np.sqrt(u) - np.sqrt(v)) ** 2))
 
     def jaccard(self, u, v):
         """Calculate the Jaccard distance between two vectors.
@@ -402,7 +452,8 @@ class Distance:
             eschew the log of zero.
         """
         u, v = np.asarray(u), np.asarray(v)
-        return np.sum(np.log(np.abs(u - v) + 1))
+        with np.errstate(divide="ignore", invalid="ignore"):
+            return np.sum(np.log(np.abs(u - v) + 1))
 
     def marylandbridge(self, u, v):
         """Calculate the Maryland Bridge distance between two vectors.
@@ -633,7 +684,8 @@ class Distance:
     #         3. https://en.wikipedia.org/wiki/Bhattacharyya_distance
     #     """
     #     u, v = np.asarray(u), np.asarray(v)
-    #     return -np.log(np.sum(np.sqrt(u * v)))
+    #     with np.errstate(divide="ignore", invalid="ignore"):
+    #         return -np.log(np.sum(np.sqrt(u * v)))
 
     def chebyshev_min(self, u, v):
         """Calculate the minimum value distance between two vectors.
@@ -808,9 +860,12 @@ class Distance:
         # vectors could be ignored or masked (see below).
         # u = ma.masked_where(u == 0, u)
         # v = ma.masked_where(v == 0, u)
-        u = np.where(u == 0, self.epsilon, u)
-        v = np.where(v == 0, self.epsilon, v)
-        return np.sum((u - v) * np.log(u / v))
+        with np.errstate(divide="ignore", invalid="ignore"):
+            u[u == 0] = self.epsilon
+            v[v == 0] = self.epsilon
+            # Clip negative values to zero for valid log
+            udivv = np.clip(u / v, a_min=self.epsilon, a_max=None)
+            return np.sum((u - v) * np.log(udivv))
 
     def jensenshannon_divergence(self, u, v):
         """Calculate the Jensen-Shannon divergence between two vectors.
@@ -844,11 +899,17 @@ class Distance:
             return np.sum(el1 - el2 * el3)
         """
         u, v = np.asarray(u), np.asarray(v)
-        u = np.where(u == 0, self.epsilon, u)
-        v = np.where(v == 0, self.epsilon, v)
-        dl = u * np.log(2 * u / (u + v))
-        dr = v * np.log(2 * v / (u + v))
-        return (np.sum(dl) + np.sum(dr)) / 2
+        with np.errstate(divide="ignore", invalid="ignore"):
+            # Clip negative values to zero for valid log
+            u[u == 0] = self.epsilon
+            v[v == 0] = self.epsilon
+
+            term1 = np.clip(2 * u / (u + v), a_min=self.epsilon, a_max=None)
+            term2 = np.clip(2 * v / (u + v), a_min=self.epsilon, a_max=None)
+
+            dl = u * np.log(term1)
+            dr = v * np.log(term2)
+            return (np.sum(dl) + np.sum(dr)) / 2
 
     def jensen_difference(self, u, v):
         """Calculate the Jensen difference between two vectors.
@@ -877,11 +938,14 @@ class Distance:
                1(4), 300-307.
         """
         u, v = np.asarray(u), np.asarray(v)
-        u = np.where(u == 0, self.epsilon, u)
-        v = np.where(v == 0, self.epsilon, v)
-        el1 = (u * np.log(u) + v * np.log(v)) / 2
-        el2 = (u + v) / 2
-        return np.sum(el1 - el2 * np.log(el2))
+
+        with np.errstate(divide="ignore", invalid="ignore"):
+            # Clip negative values to eps for valid log
+            u = np.clip(u, self.epsilon, None)
+            v = np.clip(v, self.epsilon, None)
+            el1 = (u * np.log(u) + v * np.log(v)) / 2
+            el2 = np.clip((u + v) / 2, a_min=self.epsilon, a_max=None)
+            return np.sum(el1 - el2 * np.log(el2))
 
     def kumarjohnson(self, u, v):
         """Calculate the Kumar-Johnson distance between two vectors.
@@ -934,7 +998,8 @@ class Distance:
             Equals square root of Squared-chord distance.
         """
         u, v = np.asarray(u), np.asarray(v)
-        return np.sqrt(np.sum((np.sqrt(u) - np.sqrt(v)) ** 2))
+        with np.errstate(divide="ignore", invalid="ignore"):
+            return np.sqrt(np.sum((np.sqrt(u) - np.sqrt(v)) ** 2))
 
     def minkowski(self, u, v, p=2):
         """Calculate the Minkowski distance between two vectors.
@@ -981,7 +1046,8 @@ class Distance:
         u, v = np.asarray(u), np.asarray(v)
         umu = np.mean(u)
         vmu = np.mean(v)
-        return np.sqrt(np.sum(((u - umu) - (v - vmu)) ** 2))
+        with np.errstate(divide="ignore", invalid="ignore"):
+            return np.sqrt(np.sum(((u - umu) - (v - vmu)) ** 2))
 
     def prob_chisq(self, u, v):
         """Calculate the Probabilistic chi-square distance between two vectors.
@@ -1093,7 +1159,8 @@ class Distance:
             Equals to squared Matusita distance.
         """
         u, v = np.asarray(u), np.asarray(v)
-        return np.sum((np.sqrt(u) - np.sqrt(v)) ** 2)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            return np.sum((np.sqrt(u) - np.sqrt(v)) ** 2)
 
     def squared_euclidean(self, u, v):
         """Calculate the Squared Euclidean distance between two vectors.
@@ -1145,10 +1212,14 @@ class Distance:
                1(4), 300-307.
         """
         u, v = np.asarray(u), np.asarray(v)
-        u = np.where(u == 0, self.epsilon, u)
-        v = np.where(v == 0, self.epsilon, v)
-        uvsum = u + v
-        return np.sum((uvsum / 2) * np.log(uvsum / (2 * np.sqrt(u * v))))
+        with np.errstate(divide="ignore", invalid="ignore"):
+            u[u == 0] = self.epsilon
+            v[v == 0] = self.epsilon
+            uvsum = u + v
+            logarg = np.clip(
+                uvsum / (2 * np.sqrt(u * v)), a_min=self.epsilon, a_max=None
+            )
+            return np.sum((uvsum / 2) * np.log(logarg))
 
     def tanimoto(self, u, v):
         """Calculate the Tanimoto distance between two vectors.
@@ -1202,11 +1273,14 @@ class Distance:
             Equals two times Jensen-Shannon divergence.
         """
         u, v = np.asarray(u), np.asarray(v)
-        u = np.where(u == 0, self.epsilon, u)
-        v = np.where(v == 0, self.epsilon, v)
-        dl = u * np.log(2 * u / (u + v))
-        dr = v * np.log(2 * v / (u + v))
-        return np.sum(dl + dr)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            u[u == 0] = self.epsilon
+            v[v == 0] = self.epsilon
+            logarg1 = np.clip(2 * u / (u + v), a_min=self.epsilon, a_max=None)
+            logarg2 = np.clip(2 * v / (u + v), a_min=self.epsilon, a_max=None)
+            dl = u * np.log(logarg1)
+            dr = v * np.log(logarg2)
+            return np.sum(dl + dr)
 
     def vicis_symmetric_chisq(self, u, v):
         """Calculate the Vicis Symmetric chi-square distance.
@@ -1330,9 +1404,10 @@ class Distance:
     #            1(4), 300-307.
     #     """
     #     u, v = np.asarray(u), np.asarray(v)
-    #     u = np.where(u == 0, self.epsilon, u)
-    #     v = np.where(v == 0, self.epsilon, v)
-    #     return np.sum(u * np.log(2 * u / (u + v)))
+    #     u[u == 0] = self.epsilon
+    #     v[v == 0] = self.epsilon
+    #     with np.errstate(divide="ignore", invalid="ignore"):
+    #         return np.sum(u * np.log(2 * u / (u + v)))
 
     # def kl_divergence(self, u, v):
     #     """Calculate the Kullback-Leibler divergence between two vectors.
@@ -1358,9 +1433,10 @@ class Distance:
     #            1(4):300-307.
     #     """
     #     u, v = np.asarray(u), np.asarray(v)
-    #     u = np.where(u == 0, self.epsilon, u)
-    #     v = np.where(v == 0, self.epsilon, v)
-    #     return np.sum(u * np.log(u / v))
+    #     u[u == 0] = self.epsilon
+    #     v[v == 0] = self.epsilon
+    #     with np.errstate(divide="ignore", invalid="ignore"):
+    #         return np.sum(u * np.log(u / v))
 
     # def max_symmetric_chisq(self, u, v):
     #     """Calculate the maximum symmetric chi-square distance.

{distclassipy-0.2.0a0 → distclassipy-0.2.1}/distclassipy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: distclassipy
-Version: 0.2.0a0
+Version: 0.2.1
 Summary: A python package for a distance-based classifier which can use several different distance metrics.
 Author-email: Siddharth Chaini <sidchaini@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -740,17 +740,25 @@ X, y = make_classification(
     random_state=0,
     shuffle=False,
 )
+# Example usage of DistanceMetricClassifier
 clf = dcpy.DistanceMetricClassifier()
 clf.fit(X, y)
-print(clf.predict([[0, 0, 0, 0]]), metric="canberra")
+print(clf.predict([[0, 0, 0, 0]], metric="canberra"))
+
+# Example usage of EnsembleDistanceClassifier
+ensemble_clf = dcpy.EnsembleDistanceClassifier(feat_idx=0)
+ensemble_clf.fit(X, y)
+print(ensemble_clf.predict(X))
 ```
 
 ## Features
 - **Distance Metric-Based Classification**: Utilizes a variety of distance metrics for classification.
 - **Customizable for Scientific Goals**: Allows fine-tuning based on scientific objectives by selecting appropriate distance metrics and features, enhancing both computational efficiency and model performance.
 - **Interpretable Results**: Offers improved interpretability of classification outcomes by directly using distance metrics and feature importance, making it ideal for scientific applications.
-- **Efficient and Scalable**: Demonstrates lower computational requirements compared to traditional methods like Random Forests, making it suitable for large datasets
-- **Open Source and Accessible**: Available as an open-source Python package on PyPI, encouraging broad application in astronomy and beyond
+- **Efficient and Scalable**: Demonstrates lower computational requirements compared to traditional methods like Random Forests, making it suitable for large datasets.
+- **Open Source and Accessible**: Available as an open-source Python package on PyPI, encouraging broad application in astronomy and beyond.
+- **(NEW) Ensemble Distance Classification**: Leverages an ensemble approach to use different distance metrics for each quantile, improving classification performance across diverse data distributions.
+- **(NEW) Expanded Distance Metrics**: DistClassiPy now offers 43 built-in distance metrics, an increase from the previous 18. Additionally, users can still define and use custom distance metrics as needed.
 
 ## Documentation
 

{distclassipy-0.2.0a0 → distclassipy-0.2.1}/tests/test_classifier.py

@@ -1,9 +1,13 @@
-from distclassipy.classifier import DistanceMetricClassifier
+from distclassipy.classifier import (
+    DistanceMetricClassifier,
+    EnsembleDistanceClassifier,
+)
 
 import numpy as np
 
 import pytest
 
+from sklearn.datasets import make_classification
 from sklearn.utils.estimator_checks import check_estimator
 
 
@@ -28,7 +32,7 @@ def test_fit():
 
 
 # Test making predictions with the classifier
-def test_predict():
+def test_dcpy():
     X = np.array([[1, 2], [3, 4], [5, 6]])  # Sample feature set
     y = np.array([0, 1, 0])  # Sample target values
     clf = DistanceMetricClassifier()
@@ -59,7 +63,7 @@ def test_metric_scipy():
 
 
 # Test using different distance metrics - from distclassipy
-def test_metric_dcpy():
+def test_metric_pred():
     X = np.array([[1, 2], [3, 4], [5, 6]])  # Sample feature set
     y = np.array([0, 1, 0])  # Sample target values
     clf = DistanceMetricClassifier()
@@ -134,3 +138,18 @@ def test_confidence_calculation():
     clf.predict_and_analyse(X)
     distance_confidence = clf.calculate_confidence()
     assert distance_confidence.shape == (3, len(np.unique(y)))
+
+
+# Test basic functionality of EnsembleDistanceClassifier
+def test_ensemble_distance_classifier():
+    X, y = make_classification(
+        n_samples=1000,
+        n_features=4,
+        n_informative=2,
+        shuffle=True,
+    )
+    clf = EnsembleDistanceClassifier(feat_idx=0)
+    clf.fit(X, y)
+    predictions = clf.predict(X)
+    assert len(predictions) == len(y)
+    assert set(predictions).issubset(set(y))

{distclassipy-0.2.0a0 → distclassipy-0.2.1}/tests/test_distances_prop.py

@@ -1,6 +1,6 @@
 import math
 
-from distclassipy.distances import Distance
+from distclassipy.distances import Distance, _ALL_METRICS
 
 from hypothesis import given, strategies as st
 
@@ -38,51 +38,6 @@ arrays = st.integers(min_value=1, max_value=20).flatmap(
         ).map(np.array),
     )
 )
-# List of all distance metrics
-_ALL_METRICS = [
-    "euclidean",
-    "braycurtis",
-    "canberra",
-    "cityblock",
-    "chebyshev",
-    "clark",
-    "correlation",
-    "cosine",
-    "hellinger",
-    "jaccard",
-    "lorentzian",
-    "marylandbridge",
-    "meehl",
-    "motyka",
-    "soergel",
-    "wave_hedges",
-    "kulczynski",
-    "add_chisq",
-    "acc",
-    "chebyshev_min",
-    "czekanowski",
-    "dice",
-    "divergence",
-    "google",
-    "gower",
-    "jeffreys",
-    "jensenshannon_divergence",
-    "jensen_difference",
-    "kumarjohnson",
-    "matusita",
-    "minkowski",
-    "penroseshape",
-    "prob_chisq",
-    "ruzicka",
-    "sorensen",
-    "squared_chisq",
-    "squaredchord",
-    "squared_euclidean",
-    "taneja",
-    "tanimoto",
-    "topsoe",
-    "vicis_symmetric_chisq",
-]
 
 
 @pytest.mark.parametrize(