Implement metric choice in main class

Author: quentinhaenn

.coverage

@@ -102,7 +102,7 @@ def _check_symmetric(self, a: np.ndarray, tol: float = 1e-8) -> bool:
             return False
         return np.allclose(a, a.T, atol=tol)
 
-    def fit(self, X: np.ndarray, y: None = None) -> "RadiusClustering":
+    def fit(self, X: np.ndarray, y: None = None, metric: str | callable = "euclidean") -> "RadiusClustering":
         """
         Fit the MDS clustering model to the input data.
 
@@ -130,6 +130,35 @@ def fit(self, X: np.ndarray, y: None = None) -> "RadiusClustering":
         y : Ignored
             Not used, present here for API consistency by convention.
 
+        metric : str | callable, optional (default="euclidean")
+            The metric to use when computing the distance matrix.
+            The default is "euclidean".
+            This should be a valid metric string from
+            `sklearn.metrics.pairwise_distances` or a callable that computes
+            the distance between two points.
+        
+        .. note::
+            The metric parameter *MUST* be a valid metric string from
+            `sklearn.metrics.pairwise_distances` or a callable that computes
+            the distance between two points.
+            Valid metric strings include :
+            - "euclidean"
+            - "manhattan"
+            - "cosine"
+            - "minkowski"
+            - and many more supported by scikit-learn.
+            please refer to the
+            `sklearn.metrics.pairwise_distances` documentation for a full list.
+        
+        .. attention::
+            If the input is a distance matrix, the metric parameter is ignored.
+            The distance matrix should be symmetric and square.
+        
+        .. warning::
+            If the parameter is a callable, it should :
+            - Accept two 1D arrays as input.
+            - Return a single float value representing the distance between the two points.
+
         Returns:
         --------
         self : object
@@ -157,10 +186,13 @@ def fit(self, X: np.ndarray, y: None = None) -> "RadiusClustering":
 
         # Create dist and adj matrices
         if not self._check_symmetric(self.X_checked_):
-            dist_mat = pairwise_distances(self.X_checked_, metric="euclidean")
+            dist_mat = pairwise_distances(self.X_checked_, metric=metric)
         else:
             dist_mat = self.X_checked_
-
+        
+        if not self._check_symmetric(dist_mat):
+            raise ValueError("Input distance matrix must be symmetric. Got a non-symmetric matrix.")
+        self.dist_mat_ = dist_mat
         if not isinstance(self.radius, (float, int)):
             raise ValueError("Radius must be a positive float.")
         if self.radius <= 0:
@@ -177,15 +209,14 @@ def fit(self, X: np.ndarray, y: None = None) -> "RadiusClustering":
             np.uint32
         )  # Edges in the adjacency matrix
         # uint32 is used to use less memory. Max number of features is 2^32-1
-        self.dist_mat_ = dist_mat
 
         self._clustering()
         self._compute_effective_radius()
         self._compute_labels()
 
         return self
 
-    def fit_predict(self, X: np.ndarray, y: None = None) -> np.ndarray:
+    def fit_predict(self, X: np.ndarray, y: None = None, metric: str | callable = "euclidean") -> np.ndarray:
         """
         Fit the model and return the cluster labels.
 
@@ -201,6 +232,11 @@ def fit_predict(self, X: np.ndarray, y: None = None) -> np.ndarray:
             the distance matrix will be computed.
         y : Ignored
             Not used, present here for API consistency by convention.
+        
+        metric : str | callable, optional (default="euclidean")
+            The metric to use when computing the distance matrix.
+            The default is "euclidean".
+            Refer to the `fit` method for more details on valid metrics.
 
         Returns:
         --------

src/radius_clustering/radius_clustering.py

@@ -1,11 +1,11 @@
 from radius_clustering import RadiusClustering
 import pytest
+import numpy as np
 
 def test_symmetric():
     """
     Test that the RadiusClustering class can handle symmetric distance matrices.
     """
-    import numpy as np
 
     # Check 1D array input
 
@@ -35,12 +35,11 @@ def test_symmetric():
     assert not clustering._check_symmetric(X_non_square), "The matrix should not be symmetric."
 
 
-def test_fit():
+def test_fit_distance_matrix():
     """
-    Test that the RadiusClustering class can fit to a distance matrix and to a feature matrix.
+    Test that the RadiusClustering class can fit to a distance matrix.
     This test checks both the exact and approximate methods of clustering.
     """
-    import numpy as np
 
     # Create a symmetric distance matrix
     X = np.array([[0, 1, 2],
@@ -55,14 +54,27 @@ def test_fit():
     assert clustering.nb_edges_ > 0, "There should be edges in the graph."
     assert np.array_equal(clustering.X_checked_, clustering.dist_mat_), "X_checked_ should be equal to dist_mat_ because X is a distance matrix."
 
+@pytest.mark.parametrize(
+        "test_data", [
+            ("euclidean",1.5), 
+            ("manhattan", 2.1), 
+            ("cosine", 1.0)
+        ]
+)
+def test_fit_features(test_data):
+    """
+    Test that the RadiusClustering class can fit to feature data.
+    This test checks both the exact and approximate methods of clustering
+    and multiple metrics methods.
+    """
     # Create a feature matrix
     X_features = np.array([[0, 1],
                            [1, 0],
                            [2, 1]])
+    metric, radius = test_data
 
-    clustering = RadiusClustering(manner="approx", radius=1.5)
-    clustering.fit(X_features)
-
+    clustering = RadiusClustering(manner="approx", radius=radius)
+    clustering.fit(X_features, metric=metric)
     # Check that the labels are assigned correctly
     assert len(clustering.labels_) == X_features.shape[0], "Labels length should match number of samples."
     assert clustering.nb_edges_ > 0, "There should be edges in the graph."