Add hamming, jensen-shannon, kl-divergence, correlation and russellrao distance metrics

cpp/CMakeLists.txt

@@ -249,11 +249,16 @@ if(BUILD_CUML_CPP_LIBRARY)
     src/metrics/pairwise_distance.cu
     src/metrics/pairwise_distance_canberra.cu
     src/metrics/pairwise_distance_chebyshev.cu
+    src/metrics/pairwise_distance_correlation.cu
     src/metrics/pairwise_distance_cosine.cu
     src/metrics/pairwise_distance_euclidean.cu
+    src/metrics/pairwise_distance_hamming.cu
     src/metrics/pairwise_distance_hellinger.cu
+    src/metrics/pairwise_distance_jensen_shannon.cu
+    src/metrics/pairwise_distance_kl_divergence.cu
     src/metrics/pairwise_distance_l1.cu
     src/metrics/pairwise_distance_minkowski.cu
+    src/metrics/pairwise_distance_russell_rao.cu
     src/metrics/r2_score.cu
     src/metrics/rand_index.cu
     src/metrics/silhouette_score.cu

cpp/src/metrics/pairwise_distance.cu

@@ -22,11 +22,16 @@
 #include <raft/sparse/distance/distance.cuh>
 #include "pairwise_distance_canberra.cuh"
 #include "pairwise_distance_chebyshev.cuh"
+#include "pairwise_distance_correlation.cuh"
 #include "pairwise_distance_cosine.cuh"
 #include "pairwise_distance_euclidean.cuh"
+#include "pairwise_distance_hamming.cuh"
 #include "pairwise_distance_hellinger.cuh"
+#include "pairwise_distance_jensen_shannon.cuh"
+#include "pairwise_distance_kl_divergence.cuh"
 #include "pairwise_distance_l1.cuh"
 #include "pairwise_distance_minkowski.cuh"
+#include "pairwise_distance_russell_rao.cuh"
 
 namespace ML {
 
@@ -50,22 +55,37 @@ void pairwise_distance(const raft::handle_t& handle,
       pairwise_distance_euclidean(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::CosineExpanded:
-      pairwise_distance_cosine(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_cosine(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::L1:
-      pairwise_distance_l1(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_l1(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::Linf:
-      pairwise_distance_chebyshev(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_chebyshev(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::HellingerExpanded:
-      pairwise_distance_hellinger(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_hellinger(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::LpUnexpanded:
-      pairwise_distance_minkowski(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_minkowski(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::Canberra:
-      pairwise_distance_canberra(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_canberra(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::CorrelationExpanded:
+      pairwise_distance_correlation(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::HammingUnexpanded:
+      pairwise_distance_hamming(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::JensenShannon:
+      pairwise_distance_jensen_shannon(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::KLDivergence:
+      pairwise_distance_kl_divergence(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::RusselRaoExpanded:
+      pairwise_distance_russell_rao(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     default: THROW("Unknown or unsupported distance metric '%d'!", (int)metric);
   };
@@ -90,22 +110,37 @@ void pairwise_distance(const raft::handle_t& handle,
       pairwise_distance_euclidean(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::CosineExpanded:
-      pairwise_distance_cosine(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_cosine(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::L1:
-      pairwise_distance_l1(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_l1(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::Linf:
-      pairwise_distance_chebyshev(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_chebyshev(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::HellingerExpanded:
-      pairwise_distance_hellinger(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_hellinger(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::LpUnexpanded:
-      pairwise_distance_minkowski(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_minkowski(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     case raft::distance::DistanceType::Canberra:
-      pairwise_distance_canberra(handle, x, y, dist, m, n, k, metric, isRowMajor, metric_arg);
+      pairwise_distance_canberra(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::CorrelationExpanded:
+      pairwise_distance_correlation(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::HammingUnexpanded:
+      pairwise_distance_hamming(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::JensenShannon:
+      pairwise_distance_jensen_shannon(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::KLDivergence:
+      pairwise_distance_kl_divergence(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
+    case raft::distance::DistanceType::RusselRaoExpanded:
+      pairwise_distance_russell_rao(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
     default: THROW("Unknown or unsupported distance metric '%d'!", (int)metric);
   };

cpp/src/metrics/pairwise_distance_canberra.cu

@@ -15,9 +15,9 @@
  * limitations under the License.
  */
 
-//#include <cuml/metrics/metrics.hpp>
 #include <raft/distance/distance.cuh>
 #include <raft/handle.hpp>
+#include "pairwise_distance_canberra.cuh"
 
 namespace ML {
 
@@ -29,25 +29,15 @@ void pairwise_distance_canberra(const raft::handle_t& handle,
                                 int m,
                                 int n,
                                 int k,
-                                raft::distance::DistanceType metric,
                                 bool isRowMajor,
                                 double metric_arg)
 {
   // Allocate workspace
   raft::mr::device::buffer<char> workspace(handle.get_device_allocator(), handle.get_stream(), 1);
 
   // Call the distance function
-  /*  raft::distance::pairwise_distance(x, y, dist, m, n, k, workspace, metric,
-                                    handle.get_stream(), isRowMajor,
-                                    metric_arg);*/
-
-  switch (metric) {
-    case raft::distance::DistanceType::Canberra:
-      raft::distance::pairwise_distance_impl<double, int, raft::distance::DistanceType::Canberra>(
-        x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
-      break;
-    default: THROW("Unknown or unsupported distance metric '%d'!", (int)metric);
-  }
+  raft::distance::pairwise_distance_impl<double, int, raft::distance::DistanceType::Canberra>(
+    x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
 }
 
 void pairwise_distance_canberra(const raft::handle_t& handle,
@@ -57,25 +47,15 @@ void pairwise_distance_canberra(const raft::handle_t& handle,
                                 int m,
                                 int n,
                                 int k,
-                                raft::distance::DistanceType metric,
                                 bool isRowMajor,
                                 float metric_arg)
 {
   // Allocate workspace
   raft::mr::device::buffer<char> workspace(handle.get_device_allocator(), handle.get_stream(), 1);
 
   // Call the distance function
-  /*  raft::distance::pairwise_distance(x, y, dist, m, n, k, workspace, metric,
-                                    handle.get_stream(), isRowMajor,
-                                    metric_arg);*/
-
-  switch (metric) {
-    case raft::distance::DistanceType::Canberra:
-      raft::distance::pairwise_distance_impl<float, int, raft::distance::DistanceType::Canberra>(
-        x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
-      break;
-    default: THROW("Unknown or unsupported distance metric '%d'!", (int)metric);
-  }
+  raft::distance::pairwise_distance_impl<float, int, raft::distance::DistanceType::Canberra>(
+    x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
 }
 
 }  // namespace Metrics

cpp/src/metrics/pairwise_distance_canberra.cuh

@@ -30,7 +30,6 @@ void pairwise_distance_canberra(const raft::handle_t& handle,
                                 int m,
                                 int n,
                                 int k,
-                                raft::distance::DistanceType metric,
                                 bool isRowMajor,
                                 double metric_arg);
 
@@ -41,7 +40,6 @@ void pairwise_distance_canberra(const raft::handle_t& handle,
                                 int m,
                                 int n,
                                 int k,
-                                raft::distance::DistanceType metric,
                                 bool isRowMajor,
                                 float metric_arg);
 

cpp/src/metrics/pairwise_distance_chebyshev.cu

@@ -28,20 +28,14 @@ void pairwise_distance_chebyshev(const raft::handle_t& handle,
                                  int m,
                                  int n,
                                  int k,
-                                 raft::distance::DistanceType metric,
                                  bool isRowMajor,
                                  double metric_arg)
 {
   // Allocate workspace
   raft::mr::device::buffer<char> workspace(handle.get_device_allocator(), handle.get_stream(), 1);
   // Call the distance function
-  switch (metric) {
-    case raft::distance::DistanceType::Linf:
-      raft::distance::pairwise_distance_impl<double, int, raft::distance::DistanceType::Linf>(
-        x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
-      break;
-    default: THROW("Unknown or unsupported distance metric '%d'!", (int)metric);
-  }
+  raft::distance::pairwise_distance_impl<double, int, raft::distance::DistanceType::Linf>(
+    x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
 }
 
 void pairwise_distance_chebyshev(const raft::handle_t& handle,
@@ -51,20 +45,14 @@ void pairwise_distance_chebyshev(const raft::handle_t& handle,
                                  int m,
                                  int n,
                                  int k,
-                                 raft::distance::DistanceType metric,
                                  bool isRowMajor,
                                  float metric_arg)
 {
   // Allocate workspace
   raft::mr::device::buffer<char> workspace(handle.get_device_allocator(), handle.get_stream(), 1);
   // Call the distance function
-  switch (metric) {
-    case raft::distance::DistanceType::Linf:
-      raft::distance::pairwise_distance_impl<float, int, raft::distance::DistanceType::Linf>(
-        x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
-      break;
-    default: THROW("Unknown or unsupported distance metric '%d'!", (int)metric);
-  }
+  raft::distance::pairwise_distance_impl<float, int, raft::distance::DistanceType::Linf>(
+    x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
 }
 
 }  // namespace Metrics

cpp/src/metrics/pairwise_distance_chebyshev.cuh

@@ -28,7 +28,6 @@ void pairwise_distance_chebyshev(const raft::handle_t& handle,
                                  int m,
                                  int n,
                                  int k,
-                                 raft::distance::DistanceType metric,
                                  bool isRowMajor,
                                  double metric_arg);
 
@@ -39,7 +38,6 @@ void pairwise_distance_chebyshev(const raft::handle_t& handle,
                                  int m,
                                  int n,
                                  int k,
-                                 raft::distance::DistanceType metric,
                                  bool isRowMajor,
                                  float metric_arg);
 

cpp/src/metrics/pairwise_distance_correlation.cu

@@ -0,0 +1,64 @@
+
+/*
+ * Copyright (c) 2021, 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 <raft/distance/distance.cuh>
+#include <raft/handle.hpp>
+#include "pairwise_distance_correlation.cuh"
+
+namespace ML {
+
+namespace Metrics {
+void pairwise_distance_correlation(const raft::handle_t& handle,
+                                   const double* x,
+                                   const double* y,
+                                   double* dist,
+                                   int m,
+                                   int n,
+                                   int k,
+                                   bool isRowMajor,
+                                   double metric_arg)
+{
+  // Allocate workspace
+  raft::mr::device::buffer<char> workspace(handle.get_device_allocator(), handle.get_stream(), 1);
+
+  // Call the distance function
+  raft::distance::
+    pairwise_distance_impl<double, int, raft::distance::DistanceType::CorrelationExpanded>(
+      x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
+}
+
+void pairwise_distance_correlation(const raft::handle_t& handle,
+                                   const float* x,
+                                   const float* y,
+                                   float* dist,
+                                   int m,
+                                   int n,
+                                   int k,
+                                   bool isRowMajor,
+                                   float metric_arg)
+{
+  // Allocate workspace
+  raft::mr::device::buffer<char> workspace(handle.get_device_allocator(), handle.get_stream(), 1);
+
+  // Call the distance function
+  raft::distance::
+    pairwise_distance_impl<float, int, raft::distance::DistanceType::CorrelationExpanded>(
+      x, y, dist, m, n, k, workspace, handle.get_stream(), isRowMajor);
+}
+
+}  // namespace Metrics
+}  // namespace ML

cpp/src/metrics/pairwise_distance_correlation.cuh

@@ -0,0 +1,47 @@
+
+/*
+ * Copyright (c) 2021, 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 <raft/distance/distance.cuh>
+#include <raft/handle.hpp>
+
+namespace ML {
+
+namespace Metrics {
+void pairwise_distance_correlation(const raft::handle_t& handle,
+                                   const double* x,
+                                   const double* y,
+                                   double* dist,
+                                   int m,
+                                   int n,
+                                   int k,
+                                   bool isRowMajor,
+                                   double metric_arg);
+
+void pairwise_distance_correlation(const raft::handle_t& handle,
+                                   const float* x,
+                                   const float* y,
+                                   float* dist,
+                                   int m,
+                                   int n,
+                                   int k,
+                                   bool isRowMajor,
+                                   float metric_arg);
+
+}  // namespace Metrics
+}  // namespace ML