SpectralClustering in cuml.accel

docs/source/cuml-accel/faq.rst

@@ -51,6 +51,7 @@ the following estimators are mostly or entirely accelerated when run with
 * Scikit-Learn
     * ``sklearn.cluster.KMeans``
     * ``sklearn.cluster.DBSCAN``
+    * ``sklearn.cluster.SpectralClustering``
     * ``sklearn.covariance.LedoitWolf``
     * ``sklearn.decomposition.PCA``
     * ``sklearn.decomposition.TruncatedSVD``

docs/source/cuml-accel/limitations.rst

@@ -106,6 +106,18 @@ KMeans
 - If a callable ``init`` is provided.
 - If ``X`` is sparse.
 
+SpectralClustering
+^^^^^^^^^^^^^^^^^^
+
+``SpectralClustering`` will fall back to CPU in the following cases:
+
+- If ``assign_labels`` is not ``"kmeans"``.
+- If ``affinity`` is not ``"nearest_neighbors"`` or ``"precomputed"``.
+
+The following fitted attributes are currently not computed:
+
+- ``affinity_matrix_``
+
 DBSCAN
 ^^^^^^
 

python/cuml/cuml/accel/_wrappers/sklearn/cluster.py

@@ -1,5 +1,5 @@
 #
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
 # SPDX-License-Identifier: Apache-2.0
 #
 
@@ -10,7 +10,7 @@
 from cuml.accel.estimator_proxy import ProxyBase
 from cuml.internals.interop import UnsupportedOnGPU
 
-__all__ = ("KMeans", "DBSCAN")
+__all__ = ("KMeans", "DBSCAN", "SpectralClustering")
 
 
 class KMeans(ProxyBase):
@@ -44,3 +44,8 @@ def _gpu_fit(self, X, y=None, sample_weight=None):
     def _gpu_fit_predict(self, X, y=None, sample_weight=None):
         # Fixes signature mismatch with cuml.DBSCAN. Can be removed after #6741.
         return self._gpu.fit_predict(X, y=y, sample_weight=sample_weight)
+
+
+class SpectralClustering(ProxyBase):
+    _gpu_class = cuml.cluster.SpectralClustering
+    _not_implemented_attributes = frozenset(("affinity_matrix_",))

python/cuml/cuml/cluster/spectral_clustering.pyx

@@ -14,6 +14,13 @@ from cuml.common.array_descriptor import CumlArrayDescriptor
 from cuml.internals.array import CumlArray
 from cuml.internals.base import Base, get_handle
 from cuml.internals.input_utils import input_to_cupy_array
+from cuml.internals.interop import (
+    InteropMixin,
+    UnsupportedOnGPU,
+    to_cpu,
+    to_gpu,
+)
+from cuml.internals.mixins import ClusterMixin, CMajorInputTagMixin
 from cuml.internals.utils import check_random_seed
 
 from libc.stdint cimport uint64_t, uintptr_t
@@ -254,7 +261,10 @@ def spectral_clustering(
     return labels
 
 
-class SpectralClustering(Base):
+class SpectralClustering(Base,
+                         InteropMixin,
+                         ClusterMixin,
+                         CMajorInputTagMixin):
     """Apply spectral clustering from the normalized Laplacian.
 
     In practice spectral clustering is very useful when the structure of
@@ -352,6 +362,54 @@ class SpectralClustering(Base):
     """
     labels_ = CumlArrayDescriptor()
 
+    _cpu_class_path = "sklearn.cluster.SpectralClustering"
+
+    _SUPPORTED_AFFINITIES = frozenset(("nearest_neighbors", "precomputed"))
+
+    @classmethod
+    def _params_from_cpu(cls, model):
+        if model.affinity not in cls._SUPPORTED_AFFINITIES:
+            raise UnsupportedOnGPU(
+                f"`affinity={model.affinity!r}` is not supported"
+            )
+        if model.assign_labels != "kmeans":
+            raise UnsupportedOnGPU(
+                f"`assign_labels={model.assign_labels!r}` is not supported"
+            )
+        return {
+            "n_clusters": model.n_clusters,
+            "n_components": model.n_components,
+            "random_state": model.random_state,
+            "n_neighbors": model.n_neighbors,
+            "n_init": model.n_init,
+            "eigen_tol": model.eigen_tol,
+            "affinity": model.affinity,
+        }
+
+    def _params_to_cpu(self):
+        return {
+            "n_clusters": self.n_clusters,
+            "n_components": self.n_components,
+            "random_state": self.random_state,
+            "n_neighbors": self.n_neighbors,
+            "n_init": self.n_init,
+            "eigen_tol": self.eigen_tol,
+            "affinity": self.affinity,
+            "assign_labels": "kmeans",
+        }
+
+    def _attrs_from_cpu(self, model):
+        return {
+            "labels_": to_gpu(model.labels_, order="C"),
+            **super()._attrs_from_cpu(model),
+        }
+
+    def _attrs_to_cpu(self, model):
+        return {
+            "labels_": to_cpu(self.labels_, order="C"),
+            **super()._attrs_to_cpu(model),
+        }
+
     def __init__(
         self,
         n_clusters=8,

python/cuml/cuml_accel_tests/integration/test_spectral_clustering.py

@@ -0,0 +1,149 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION.
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import numpy as np
+import pytest
+from sklearn.cluster import SpectralClustering
+from sklearn.datasets import make_blobs
+from sklearn.metrics import adjusted_rand_score
+
+
+@pytest.fixture(scope="module")
+def clustering_data():
+    X, y = make_blobs(
+        n_samples=300, centers=3, cluster_std=1.0, random_state=42
+    )
+    return X.astype(np.float32), y
+
+
+def test_spectral_clustering_default(clustering_data):
+    X, y = clustering_data
+    sc = SpectralClustering(affinity="nearest_neighbors", random_state=42).fit(
+        X
+    )
+    assert sc.labels_.shape == y.shape
+
+
+@pytest.mark.parametrize("n_clusters", [2, 3, 4, 5])
+def test_spectral_clustering_n_clusters(clustering_data, n_clusters):
+    X, y_true = clustering_data
+    sc = SpectralClustering(
+        n_clusters=n_clusters,
+        affinity="nearest_neighbors",
+        random_state=42,
+    ).fit(X)
+    y_pred = sc.labels_
+    adjusted_rand_score(y_true, y_pred)
+
+
+@pytest.mark.parametrize("n_neighbors", [5, 10, 20])
+def test_spectral_clustering_n_neighbors(clustering_data, n_neighbors):
+    X, y_true = clustering_data
+    sc = SpectralClustering(
+        n_clusters=3,
+        affinity="nearest_neighbors",
+        n_neighbors=n_neighbors,
+        random_state=42,
+    ).fit(X)
+    y_pred = sc.labels_
+    adjusted_rand_score(y_true, y_pred)
+
+
+@pytest.mark.parametrize("n_components", [2, 3, 5])
+def test_spectral_clustering_n_components(clustering_data, n_components):
+    X, y_true = clustering_data
+    sc = SpectralClustering(
+        n_clusters=3,
+        n_components=n_components,
+        affinity="nearest_neighbors",
+        random_state=42,
+    ).fit(X)
+    y_pred = sc.labels_
+    adjusted_rand_score(y_true, y_pred)
+
+
+@pytest.mark.parametrize("n_init", [1, 5, 10])
+def test_spectral_clustering_n_init(clustering_data, n_init):
+    X, y_true = clustering_data
+    sc = SpectralClustering(
+        n_clusters=3,
+        affinity="nearest_neighbors",
+        n_init=n_init,
+        random_state=42,
+    ).fit(X)
+    y_pred = sc.labels_
+    adjusted_rand_score(y_true, y_pred)
+
+
+@pytest.mark.parametrize("eigen_tol", ["auto", 0.0, 1e-4])
+def test_spectral_clustering_eigen_tol(clustering_data, eigen_tol):
+    X, y_true = clustering_data
+    sc = SpectralClustering(
+        n_clusters=3,
+        affinity="nearest_neighbors",
+        eigen_tol=eigen_tol,
+        random_state=42,
+    ).fit(X)
+    y_pred = sc.labels_
+    adjusted_rand_score(y_true, y_pred)
+
+
+@pytest.mark.parametrize(
+    "assign_labels", ["kmeans", "discretize", "cluster_qr"]
+)
+def test_spectral_clustering_assign_labels(clustering_data, assign_labels):
+    X, y_true = clustering_data
+    sc = SpectralClustering(
+        n_clusters=3,
+        affinity="nearest_neighbors",
+        assign_labels=assign_labels,
+        random_state=42,
+    ).fit(X)
+    y_pred = sc.labels_
+    adjusted_rand_score(y_true, y_pred)
+
+
+def test_spectral_clustering_precomputed(clustering_data):
+    from sklearn.neighbors import kneighbors_graph
+
+    X, y_true = clustering_data
+    connectivity = kneighbors_graph(X, n_neighbors=10, include_self=True)
+    affinity_matrix = 0.5 * (connectivity + connectivity.T)
+    sc = SpectralClustering(
+        n_clusters=3,
+        affinity="precomputed",
+        random_state=42,
+    ).fit(affinity_matrix)
+    y_pred = sc.labels_
+    adjusted_rand_score(y_true, y_pred)
+
+
+def test_spectral_clustering_fit_predict(clustering_data):
+    X, y_true = clustering_data
+    sc = SpectralClustering(
+        n_clusters=3,
+        affinity="nearest_neighbors",
+        random_state=42,
+    )
+    labels = sc.fit_predict(X)
+    assert labels.shape == y_true.shape
+    assert np.array_equal(labels, sc.labels_)
+
+
+def test_spectral_clustering_random_state(clustering_data):
+    X, _ = clustering_data
+    sc1 = SpectralClustering(
+        n_clusters=3,
+        affinity="nearest_neighbors",
+        random_state=42,
+    ).fit(X)
+    sc2 = SpectralClustering(
+        n_clusters=3,
+        affinity="nearest_neighbors",
+        random_state=42,
+    ).fit(X)
+    assert np.array_equal(sc1.labels_, sc2.labels_), (
+        "Results should be consistent with the same random_state"
+    )

python/cuml/cuml_accel_tests/test_basic_estimators.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION.
 # SPDX-License-Identifier: Apache-2.0
 
-from sklearn.cluster import DBSCAN, KMeans
+from sklearn.cluster import DBSCAN, KMeans, SpectralClustering
 from sklearn.datasets import make_blobs, make_classification, make_regression
 from sklearn.decomposition import PCA, TruncatedSVD
 from sklearn.linear_model import (
@@ -32,6 +32,15 @@ def test_dbscan():
     clf.labels_
 
 
+def test_spectral_clustering():
+    X, y_true = make_blobs(n_samples=100, centers=3, random_state=42)
+    X = X.astype("float32")
+    sc = SpectralClustering(
+        n_clusters=3, affinity="nearest_neighbors", random_state=42
+    ).fit(X)
+    sc.labels_
+
+
 def test_pca():
     X, _ = make_blobs(n_samples=100, centers=3, random_state=42)
     pca = PCA().fit(X)

python/cuml/cuml_accel_tests/upstream/scikit-learn/xfail-list.yaml

@@ -406,6 +406,7 @@
   - "sklearn.tests.test_multioutput::test_multi_target_sparse_regression[lil_matrix]"
   - "sklearn.tests.test_public_functions::test_class_wrapper_param_validation[sklearn.cluster.dbscan-sklearn.cluster.DBSCAN]"
   - "sklearn.tests.test_public_functions::test_class_wrapper_param_validation[sklearn.cluster.k_means-sklearn.cluster.KMeans]"
+  - "sklearn.tests.test_public_functions::test_class_wrapper_param_validation[sklearn.cluster.spectral_clustering-sklearn.cluster.SpectralClustering]"
   - "sklearn.tests.test_public_functions::test_class_wrapper_param_validation[sklearn.covariance.ledoit_wolf-sklearn.covariance.LedoitWolf]"
   - "sklearn.utils.tests.test_estimator_checks::test_check_dataframe_column_names_consistency"
   - "sklearn.utils.tests.test_estimator_checks::test_check_estimator"
@@ -1610,6 +1611,9 @@
   tests:
   - "sklearn.manifold.tests.test_t_sne::test_fit_transform_csr_matrix[csr_array-random-exact]"
   - "sklearn.manifold.tests.test_t_sne::test_fit_transform_csr_matrix[csr_matrix-random-exact]"
+- reason: Pipeline precomputed path falls back to CPU while compact path uses GPU, which won't have exact label matches
+  tests:
+  - "sklearn.neighbors.tests.test_neighbors_pipeline::test_spectral_clustering"
 - reason: Ridge doesn't implement n_iter yet
   tests:
   - "sklearn.linear_model.tests.test_ridge::test_n_iter"
@@ -1651,6 +1655,14 @@
 - reason: The sklearn test has the error message accidentally flipped, our message is correct
   tests:
   - "sklearn.linear_model.tests.test_ridge::test_ridge_individual_penalties"
+- reason: cuML SpectralClustering does not emit "not fully connected" UserWarning
+  condition: scikit-learn<1.7,>=1.5
+  tests:
+  - "sklearn.cluster.tests.test_spectral::test_affinities"
+- reason: cuML SpectralClustering does not emit "not fully connected" UserWarning
+  condition: scikit-learn>=1.7
+  tests:
+  - "sklearn.cluster.tests.test_spectral::test_affinities[42]"
 - reason: cuML TSNE barnes_hut produces poor quality embeddings with sparse input
   condition: scikit-learn>=1.8
   tests:

python/cuml/tests/test_sklearn_import_export.py

@@ -32,7 +32,7 @@
 from sklearn.utils.validation import check_is_fitted
 
 import cuml
-from cuml.cluster import DBSCAN, KMeans
+from cuml.cluster import DBSCAN, KMeans, SpectralClustering
 from cuml.decomposition import PCA, TruncatedSVD
 from cuml.internals.interop import UnsupportedOnCPU, UnsupportedOnGPU
 from cuml.linear_model import (
@@ -194,6 +194,23 @@ def test_dbscan(random_state):
     assert array_equal(original.labels_, roundtrip_model.labels_)
 
 
+def test_spectral_clustering(random_state):
+    X, _ = make_blobs(
+        n_samples=100, n_features=10, centers=3, random_state=random_state
+    )
+    X = X.astype(np.float32)
+    original = SpectralClustering(
+        n_clusters=3,
+        affinity="nearest_neighbors",
+        n_neighbors=10,
+        random_state=random_state,
+    )
+    original.fit(X)
+    sklearn_model = original.as_sklearn()
+    roundtrip_model = SpectralClustering.from_sklearn(sklearn_model)
+    assert array_equal(original.labels_, roundtrip_model.labels_)
+
+
 def test_pca(random_state):
     X = np.random.RandomState(random_state).rand(50, 5)
     original = PCA(n_components=2)