Remove fit_predict()

Signed-off-by: Mickael Ide <mide@nvidia.com>

Author: lowener

cpp/include/cuvs/cluster/kmeans.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -45,8 +45,8 @@ void compute_dispersion(raft::resources const& handle,
 
   params.n_clusters = val;
 
-  cuvs::cluster::kmeans::fit_predict(
-    handle, params, X, std::nullopt, std::make_optional(centroids_view), labels, residual, n_iter);
+  cuvs::cluster::kmeans::fit(
+    handle, params, X, std::nullopt, centroids_view, residual, n_iter, std::make_optional(labels));
 
   detail::countLabels(handle, labels.data_handle(), clusterSizes.data_handle(), n, val, workspace);
 
@@ -212,14 +212,14 @@ void find_k(raft::resources const& handle,
       raft::make_device_matrix_view<value_t, idx_t>(centroids.data_handle(), best_k[0], d);
 
     params.n_clusters = best_k[0];
-    cuvs::cluster::kmeans::fit_predict(handle,
-                                       params,
-                                       X,
-                                       std::nullopt,
-                                       std::make_optional(centroids_view),
-                                       labels.view(),
-                                       residual,
-                                       n_iter);
+    cuvs::cluster::kmeans::fit(handle,
+                               params,
+                               X,
+                               std::nullopt,
+                               centroids_view,
+                               residual,
+                               n_iter,
+                               std::make_optional(labels.view()));
   }
 }
 }  // namespace  cuvs::cluster::kmeans::detail

cpp/src/cluster/detail/kmeans_auto_find_k.cuh

@@ -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
  */
 
@@ -51,14 +51,16 @@ void fit_predict(raft::resources const& handle,
                           config.n_components,
                           raft::resource::get_cuda_stream(handle));
 
-  cuvs::cluster::kmeans::fit_predict(handle,
-                                     kmeans_config,
-                                     embedding_row_major.view(),
-                                     std::nullopt,
-                                     std::nullopt,
-                                     labels,
-                                     raft::make_host_scalar_view(&inertia),
-                                     raft::make_host_scalar_view(&n_iter));
+  auto centroids =
+    raft::make_device_matrix<DataT, int>(handle, kmeans_config.n_clusters, config.n_components);
+  cuvs::cluster::kmeans::fit(handle,
+                             kmeans_config,
+                             embedding_row_major.view(),
+                             std::nullopt,
+                             centroids.view(),
+                             raft::make_host_scalar_view(&inertia),
+                             raft::make_host_scalar_view(&n_iter),
+                             labels);
 }
 
 void fit_predict(raft::resources const& handle,

cpp/src/cluster/detail/spectral.cuh

@@ -99,29 +99,6 @@ void fit(const raft::resources& handle,
                                                     labels_ptr);
 }
 
-template <typename DataT,
-          typename MathT,
-          typename IndexT,
-          typename LabelT,
-          typename MappingOpT = raft::identity_op>
-void fit_predict(const raft::resources& handle,
-                 cuvs::cluster::kmeans::balanced_params const& params,
-                 raft::device_matrix_view<const DataT, IndexT> X,
-                 raft::device_matrix_view<MathT, IndexT> centroids,
-                 raft::device_vector_view<LabelT, IndexT> labels,
-                 MappingOpT mapping_op                                = raft::identity_op(),
-                 std::optional<raft::host_scalar_view<MathT>> inertia = std::nullopt)
-{
-  if constexpr (std::is_same_v<LabelT, uint32_t>) {
-    fit<DataT, MathT, IndexT, MappingOpT>(
-      handle, params, X, centroids, mapping_op, inertia, std::make_optional(labels));
-  } else {
-    fit<DataT, MathT, IndexT, MappingOpT>(handle, params, X, centroids, mapping_op, inertia);
-    // Use the public predict API for non-uint32_t labels
-    kmeans::predict(handle, params, X, raft::make_const_mdspan(centroids), labels);
-  }
-}
-
 /**
  * @brief Predict the closest cluster each sample in X belongs to.
  *

cpp/src/cluster/kmeans_balanced.cuh

@@ -15,25 +15,15 @@ void fit(const raft::resources& handle,
          cuvs::cluster::kmeans::balanced_params const& params,
          raft::device_matrix_view<const float, int64_t> X,
          raft::device_matrix_view<float, int64_t> centroids,
-         std::optional<raft::host_scalar_view<float>> inertia)
+         std::optional<raft::host_scalar_view<float>> inertia,
+         std::optional<raft::device_vector_view<uint32_t, int64_t>> labels)
 {
-  cuvs::cluster::kmeans_balanced::fit(
-    handle, params, X, centroids, cuvs::spatial::knn::detail::utils::mapping<float>{}, inertia);
-}
-
-void fit_predict(const raft::resources& handle,
-                 cuvs::cluster::kmeans::balanced_params const& params,
-                 raft::device_matrix_view<const float, int64_t> X,
-                 raft::device_matrix_view<float, int64_t> centroids,
-                 raft::device_vector_view<uint32_t, int64_t> labels,
-                 std::optional<raft::host_scalar_view<float>> inertia)
-{
-  cuvs::cluster::kmeans_balanced::fit_predict(handle,
-                                              params,
-                                              X,
-                                              centroids,
-                                              labels,
-                                              cuvs::spatial::knn::detail::utils::mapping<float>{},
-                                              inertia);
+  cuvs::cluster::kmeans_balanced::fit(handle,
+                                      params,
+                                      X,
+                                      centroids,
+                                      cuvs::spatial::knn::detail::utils::mapping<float>{},
+                                      inertia,
+                                      labels);
 }
 }  // namespace cuvs::cluster::kmeans

cpp/src/cluster/kmeans_balanced_fit_float.cu

@@ -15,25 +15,15 @@ void fit(const raft::resources& handle,
          cuvs::cluster::kmeans::balanced_params const& params,
          raft::device_matrix_view<const half, int64_t> X,
          raft::device_matrix_view<float, int64_t> centroids,
-         std::optional<raft::host_scalar_view<float>> inertia)
+         std::optional<raft::host_scalar_view<float>> inertia,
+         std::optional<raft::device_vector_view<uint32_t, int64_t>> labels)
 {
-  cuvs::cluster::kmeans_balanced::fit(
-    handle, params, X, centroids, cuvs::spatial::knn::detail::utils::mapping<float>{}, inertia);
-}
-
-void fit_predict(const raft::resources& handle,
-                 cuvs::cluster::kmeans::balanced_params const& params,
-                 raft::device_matrix_view<const half, int64_t> X,
-                 raft::device_matrix_view<float, int64_t> centroids,
-                 raft::device_vector_view<uint32_t, int64_t> labels,
-                 std::optional<raft::host_scalar_view<float>> inertia)
-{
-  cuvs::cluster::kmeans_balanced::fit_predict(handle,
-                                              params,
-                                              X,
-                                              centroids,
-                                              labels,
-                                              cuvs::spatial::knn::detail::utils::mapping<float>{},
-                                              inertia);
+  cuvs::cluster::kmeans_balanced::fit(handle,
+                                      params,
+                                      X,
+                                      centroids,
+                                      cuvs::spatial::knn::detail::utils::mapping<float>{},
+                                      inertia,
+                                      labels);
 }
 }  // namespace cuvs::cluster::kmeans

cpp/src/cluster/kmeans_balanced_fit_half.cu

@@ -15,41 +15,15 @@ void fit(const raft::resources& handle,
          cuvs::cluster::kmeans::balanced_params const& params,
          raft::device_matrix_view<const int8_t, int64_t> X,
          raft::device_matrix_view<float, int64_t> centroids,
-         std::optional<raft::host_scalar_view<float>> inertia)
+         std::optional<raft::host_scalar_view<float>> inertia,
+         std::optional<raft::device_vector_view<uint32_t, int64_t>> labels)
 {
-  cuvs::cluster::kmeans_balanced::fit(
-    handle, params, X, centroids, cuvs::spatial::knn::detail::utils::mapping<float>{}, inertia);
-}
-
-void fit_predict(const raft::resources& handle,
-                 cuvs::cluster::kmeans::balanced_params const& params,
-                 raft::device_matrix_view<const int8_t, int64_t> X,
-                 raft::device_matrix_view<float, int64_t> centroids,
-                 raft::device_vector_view<uint32_t, int64_t> labels,
-                 std::optional<raft::host_scalar_view<float>> inertia)
-{
-  cuvs::cluster::kmeans_balanced::fit_predict(handle,
-                                              params,
-                                              X,
-                                              centroids,
-                                              labels,
-                                              cuvs::spatial::knn::detail::utils::mapping<float>{},
-                                              inertia);
-}
-
-void fit_predict(const raft::resources& handle,
-                 cuvs::cluster::kmeans::balanced_params const& params,
-                 raft::device_matrix_view<const int8_t, int64_t> X,
-                 raft::device_matrix_view<float, int64_t> centroids,
-                 raft::device_vector_view<int, int64_t> labels,
-                 std::optional<raft::host_scalar_view<float>> inertia)
-{
-  cuvs::cluster::kmeans_balanced::fit_predict(handle,
-                                              params,
-                                              X,
-                                              centroids,
-                                              labels,
-                                              cuvs::spatial::knn::detail::utils::mapping<float>{},
-                                              inertia);
+  cuvs::cluster::kmeans_balanced::fit(handle,
+                                      params,
+                                      X,
+                                      centroids,
+                                      cuvs::spatial::knn::detail::utils::mapping<float>{},
+                                      inertia,
+                                      labels);
 }
 }  // namespace cuvs::cluster::kmeans

cpp/src/cluster/kmeans_balanced_fit_int8.cu

@@ -15,25 +15,15 @@ void fit(const raft::resources& handle,
          cuvs::cluster::kmeans::balanced_params const& params,
          raft::device_matrix_view<const uint8_t, int64_t> X,
          raft::device_matrix_view<float, int64_t> centroids,
-         std::optional<raft::host_scalar_view<float>> inertia)
+         std::optional<raft::host_scalar_view<float>> inertia,
+         std::optional<raft::device_vector_view<uint32_t, int64_t>> labels)
 {
-  cuvs::cluster::kmeans_balanced::fit(
-    handle, params, X, centroids, cuvs::spatial::knn::detail::utils::mapping<float>{}, inertia);
-}
-
-void fit_predict(const raft::resources& handle,
-                 cuvs::cluster::kmeans::balanced_params const& params,
-                 raft::device_matrix_view<const uint8_t, int64_t> X,
-                 raft::device_matrix_view<float, int64_t> centroids,
-                 raft::device_vector_view<uint32_t, int64_t> labels,
-                 std::optional<raft::host_scalar_view<float>> inertia)
-{
-  cuvs::cluster::kmeans_balanced::fit_predict(handle,
-                                              params,
-                                              X,
-                                              centroids,
-                                              labels,
-                                              cuvs::spatial::knn::detail::utils::mapping<float>{},
-                                              inertia);
+  cuvs::cluster::kmeans_balanced::fit(handle,
+                                      params,
+                                      X,
+                                      centroids,
+                                      cuvs::spatial::knn::detail::utils::mapping<float>{},
+                                      inertia,
+                                      labels);
 }
 }  // namespace cuvs::cluster::kmeans

cpp/src/cluster/kmeans_balanced_fit_uint8.cu

@@ -30,10 +30,11 @@ void fit(raft::resources const& handle,
          std::optional<raft::device_vector_view<const double, int>> sample_weight,
          raft::device_matrix_view<double, int> centroids,
          raft::host_scalar_view<double> inertia,
-         raft::host_scalar_view<int> n_iter)
+         raft::host_scalar_view<int> n_iter,
+         std::optional<raft::device_vector_view<int, int>> labels)
 {
   cuvs::cluster::kmeans::fit<double, int>(
-    handle, params, X, sample_weight, centroids, inertia, n_iter);
+    handle, params, X, sample_weight, centroids, inertia, n_iter, labels);
 }
 
 void fit(raft::resources const& handle,
@@ -42,37 +43,10 @@ void fit(raft::resources const& handle,
          std::optional<raft::device_vector_view<const double, int64_t>> sample_weight,
          raft::device_matrix_view<double, int64_t> centroids,
          raft::host_scalar_view<double> inertia,
-         raft::host_scalar_view<int64_t> n_iter)
+         raft::host_scalar_view<int64_t> n_iter,
+         std::optional<raft::device_vector_view<int64_t, int64_t>> labels)
 {
   cuvs::cluster::kmeans::fit<double, int64_t>(
-    handle, params, X, sample_weight, centroids, inertia, n_iter);
-}
-
-void fit_predict(raft::resources const& handle,
-                 const kmeans::params& params,
-                 raft::device_matrix_view<const double, int> X,
-                 std::optional<raft::device_vector_view<const double, int>> sample_weight,
-                 std::optional<raft::device_matrix_view<double, int>> centroids,
-                 raft::device_vector_view<int, int> labels,
-                 raft::host_scalar_view<double> inertia,
-                 raft::host_scalar_view<int> n_iter)
-
-{
-  cuvs::cluster::kmeans::fit_predict<double, int>(
-    handle, params, X, sample_weight, centroids, labels, inertia, n_iter);
-}
-
-void fit_predict(raft::resources const& handle,
-                 const kmeans::params& params,
-                 raft::device_matrix_view<const double, int64_t> X,
-                 std::optional<raft::device_vector_view<const double, int64_t>> sample_weight,
-                 std::optional<raft::device_matrix_view<double, int64_t>> centroids,
-                 raft::device_vector_view<int64_t, int64_t> labels,
-                 raft::host_scalar_view<double> inertia,
-                 raft::host_scalar_view<int64_t> n_iter)
-
-{
-  cuvs::cluster::kmeans::fit_predict<double, int64_t>(
-    handle, params, X, sample_weight, centroids, labels, inertia, n_iter);
+    handle, params, X, sample_weight, centroids, inertia, n_iter, labels);
 }
 }  // namespace cuvs::cluster::kmeans

cpp/src/cluster/kmeans_fit_double.cu

@@ -29,10 +29,11 @@ void fit(raft::resources const& handle,
          std::optional<raft::device_vector_view<const float, int>> sample_weight,
          raft::device_matrix_view<float, int> centroids,
          raft::host_scalar_view<float> inertia,
-         raft::host_scalar_view<int> n_iter)
+         raft::host_scalar_view<int> n_iter,
+         std::optional<raft::device_vector_view<int, int>> labels)
 {
   cuvs::cluster::kmeans::fit<float, int>(
-    handle, params, X, sample_weight, centroids, inertia, n_iter);
+    handle, params, X, sample_weight, centroids, inertia, n_iter, labels);
 }
 
 void fit(raft::resources const& handle,
@@ -41,37 +42,10 @@ void fit(raft::resources const& handle,
          std::optional<raft::device_vector_view<const float, int64_t>> sample_weight,
          raft::device_matrix_view<float, int64_t> centroids,
          raft::host_scalar_view<float> inertia,
-         raft::host_scalar_view<int64_t> n_iter)
+         raft::host_scalar_view<int64_t> n_iter,
+         std::optional<raft::device_vector_view<int64_t, int64_t>> labels)
 {
   cuvs::cluster::kmeans::fit<float, int64_t>(
-    handle, params, X, sample_weight, centroids, inertia, n_iter);
-}
-
-void fit_predict(raft::resources const& handle,
-                 const kmeans::params& params,
-                 raft::device_matrix_view<const float, int> X,
-                 std::optional<raft::device_vector_view<const float, int>> sample_weight,
-                 std::optional<raft::device_matrix_view<float, int>> centroids,
-                 raft::device_vector_view<int, int> labels,
-                 raft::host_scalar_view<float> inertia,
-                 raft::host_scalar_view<int> n_iter)
-
-{
-  cuvs::cluster::kmeans::fit_predict<float, int>(
-    handle, params, X, sample_weight, centroids, labels, inertia, n_iter);
-}
-
-void fit_predict(raft::resources const& handle,
-                 const kmeans::params& params,
-                 raft::device_matrix_view<const float, int64_t> X,
-                 std::optional<raft::device_vector_view<const float, int64_t>> sample_weight,
-                 std::optional<raft::device_matrix_view<float, int64_t>> centroids,
-                 raft::device_vector_view<int64_t, int64_t> labels,
-                 raft::host_scalar_view<float> inertia,
-                 raft::host_scalar_view<int64_t> n_iter)
-
-{
-  cuvs::cluster::kmeans::fit_predict<float, int64_t>(
-    handle, params, X, sample_weight, centroids, labels, inertia, n_iter);
+    handle, params, X, sample_weight, centroids, inertia, n_iter, labels);
 }
 }  // namespace cuvs::cluster::kmeans