Kernel PCA: C++ Algorithm Implementation

cpp/CMakeLists.txt

@@ -469,6 +469,12 @@ if(BUILD_CUML_CPP_LIBRARY)
         src/pca/pca.cu)
   endif()
 
+  if(all_algo OR kpca_algo)
+    target_sources(${CUML_CPP_TARGET}
+      PRIVATE
+        src/kpca/kpca.cu)
+  endif()
+
   if(all_algo OR randomforest_algo)
     target_sources(${CUML_CPP_TARGET}
       PRIVATE

cpp/cmake/modules/ConfigureAlgorithms.cmake

@@ -1,5 +1,5 @@
 #=============================================================================
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -52,6 +52,7 @@ else()
     if(decomposition_algo)
       set(pca_algo ON)
       set(tsvd_algo ON)
+      set(kpca_algo ON)
     endif()
 
     if(ensemble_algo)

cpp/include/cuml/decomposition/kpca.hpp

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "params.hpp"
+
+namespace raft {
+class handle_t;
+}
+
+namespace ML {
+
+void kpcaFit(raft::handle_t& handle,
+             float* input,
+             float* eigenvectors,
+             float* eigenvalues,
+             int* n_components,
+             const paramsKPCA& prms);
+
+void kpcaFit(raft::handle_t& handle,
+             double* input,
+             double* eigenvectors,
+             double* eigenvalues,
+             int* n_components,
+             const paramsKPCA& prms);
+
+void kpcaTransformWithFitData(raft::handle_t& handle,
+                              float* eigenvectors,
+                              float* eigenvalues,
+                              float* trans_input,
+                              const paramsKPCA& prms);
+
+void kpcaTransformWithFitData(raft::handle_t& handle,
+                              double* eigenvectors,
+                              double* eigenvalues,
+                              double* trans_input,
+                              const paramsKPCA& prms);
+
+void kpcaTransform(const raft::handle_t& handle,
+                   float* fit_input,
+                   float* input,
+                   float* eigenvectors,
+                   float* eigenvalues,
+                   float* trans_input,
+                   const paramsKPCA& prms);
+
+void kpcaTransform(const raft::handle_t& handle,
+                   double* fit_input,
+                   double* input,
+                   double* eigenvectors,
+                   double* eigenvalues,
+                   double* trans_input,
+                   const paramsKPCA& prms);
+
+};  // end namespace ML

cpp/include/cuml/decomposition/params.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2022, NVIDIA CORPORATION.
+ * Copyright (c) 2018-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,6 +15,7 @@
  */
 
 #pragma once
+#include <cuml/matrix/kernelparams.h>
 
 #include <cstdint>
 
@@ -78,8 +79,19 @@ class paramsPCATemplate : public paramsTSVDTemplate<enum_solver> {
   bool whiten = false;
 };
 
+template <typename enum_solver = solver>
+class paramsKPCATemplate : public paramsTSVDTemplate<enum_solver> {
+ public:
+  MLCommon::Matrix::KernelParams kernel;
+  size_t n_training_samples  = 0;
+  bool copy                  = true;  // TODO unused
+  bool remove_zero_eig       = false;
+  bool fit_inverse_transform = false;  // TODO unused
+};
+
 typedef paramsTSVDTemplate<> paramsTSVD;
 typedef paramsPCATemplate<> paramsPCA;
+typedef paramsKPCATemplate<> paramsKPCA;
 
 enum class mg_solver { COV_EIG_DQ, COV_EIG_JACOBI, QR };
 

cpp/src/kpca/kpca.cu

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "kpca.cuh"
+
+#include <cuml/decomposition/kpca.hpp>
+namespace ML {
+
+void kpcaFit(raft::handle_t& handle,
+             float* input,
+             float* eigenvectors,
+             float* eigenvalues,
+             int* n_components,
+             const ML::paramsKPCA& prms)
+{
+  kpcaFit(handle, input, eigenvectors, eigenvalues, n_components, prms, handle.get_stream());
+}
+
+void kpcaFit(raft::handle_t& handle,
+             double* input,
+             double* eigenvectors,
+             double* eigenvalues,
+             int* n_components,
+             const ML::paramsKPCA& prms)
+{
+  kpcaFit(handle, input, eigenvectors, eigenvalues, n_components, prms, handle.get_stream());
+}
+
+void kpcaTransformWithFitData(raft::handle_t& handle,
+                              float* eigenvectors,
+                              float* eigenvalues,
+                              float* trans_input,
+                              const ML::paramsKPCA& prms)
+{
+  kpcaTransformWithFitData(
+    handle, eigenvectors, eigenvalues, trans_input, prms, handle.get_stream());
+}
+
+void kpcaTransformWithFitData(raft::handle_t& handle,
+                              double* eigenvectors,
+                              double* eigenvalues,
+                              double* trans_input,
+                              const paramsKPCA& prms)
+{
+  kpcaTransformWithFitData(
+    handle, eigenvectors, eigenvalues, trans_input, prms, handle.get_stream());
+}
+
+void kpcaTransform(const raft::handle_t& handle,
+                   float* fit_input,
+                   float* input,
+                   float* eigenvectors,
+                   float* eigenvalues,
+                   float* trans_input,
+                   const ML::paramsKPCA& prms)
+{
+  kpcaTransform(
+    handle, fit_input, input, eigenvectors, eigenvalues, trans_input, prms, handle.get_stream());
+}
+
+void kpcaTransform(const raft::handle_t& handle,
+                   double* fit_input,
+                   double* input,
+                   double* eigenvectors,
+                   double* eigenvalues,
+                   double* trans_input,
+                   const ML::paramsKPCA& prms)
+{
+  kpcaTransform(
+    handle, fit_input, input, eigenvectors, eigenvalues, trans_input, prms, handle.get_stream());
+}
+
+}  // namespace ML