Enable dice metric for UMAP and Pairwise Distances

cpp/CMakeLists.txt

@@ -444,6 +444,7 @@ if(BUILD_CUML_CPP_LIBRARY)
         src/metrics/pairwise_distance_chebyshev.cu
         src/metrics/pairwise_distance_correlation.cu
         src/metrics/pairwise_distance_cosine.cu
+        src/metrics/pairwise_distance_dice.cu
         src/metrics/pairwise_distance_euclidean.cu
         src/metrics/pairwise_distance_hamming.cu
         src/metrics/pairwise_distance_hellinger.cu

cpp/src/metrics/pairwise_distance.cu

@@ -19,6 +19,7 @@
 #include "pairwise_distance_chebyshev.cuh"
 #include "pairwise_distance_correlation.cuh"
 #include "pairwise_distance_cosine.cuh"
+#include "pairwise_distance_dice.cuh"
 #include "pairwise_distance_euclidean.cuh"
 #include "pairwise_distance_hamming.cuh"
 #include "pairwise_distance_hellinger.cuh"
@@ -88,6 +89,9 @@ void pairwise_distance(const raft::handle_t& handle,
     case raft::distance::DistanceType::RusselRaoExpanded:
       pairwise_distance_russell_rao(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
+    case raft::distance::DistanceType::DiceExpanded:
+      pairwise_distance_dice(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
+      break;
     default: THROW("Unknown or unsupported distance metric '%d'!", (int)metric);
   };
 }
@@ -143,6 +147,9 @@ void pairwise_distance(const raft::handle_t& handle,
     case raft::distance::DistanceType::RusselRaoExpanded:
       pairwise_distance_russell_rao(handle, x, y, dist, m, n, k, isRowMajor, metric_arg);
       break;
+    case raft::distance::DistanceType::DiceExpanded:
+      pairwise_distance_dice(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_dice.cu

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

cpp/src/metrics/pairwise_distance_dice.cuh

@@ -0,0 +1,46 @@
+
+/*
+ * Copyright (c) 2021-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 <raft/core/handle.hpp>
+#include <raft/distance/distance.cuh>
+
+namespace ML {
+
+namespace Metrics {
+void pairwise_distance_dice(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_dice(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

python/cuml/manifold/umap_utils.pyx

@@ -150,7 +150,8 @@ metric_parsing = {
     "hellinger": DistanceType.HellingerExpanded,
     "hamming": DistanceType.HammingUnexpanded,
     "jaccard": DistanceType.JaccardExpanded,
-    "canberra": DistanceType.Canberra
+    "canberra": DistanceType.Canberra,
+    "dice": DistanceType.DiceExpanded,
 }
 
 
@@ -166,6 +167,7 @@ DENSE_SUPPORTED_METRICS = [
     DistanceType.L2Unexpanded,
     DistanceType.Linf,
     DistanceType.LpUnexpanded,
+    DistanceType.DiceExpanded,
 ]
 
 
@@ -181,4 +183,5 @@ SPARSE_SUPPORTED_METRICS = [
     DistanceType.L2Unexpanded,
     DistanceType.Linf,
     DistanceType.LpUnexpanded,
+    DistanceType.DiceExpanded,
 ]

python/cuml/metrics/pairwise_distances.pyx

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2020-2023, NVIDIA CORPORATION.
+# Copyright (c) 2020-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.
@@ -80,7 +80,8 @@ PAIRWISE_DISTANCE_METRICS = {
     "hamming": DistanceType.HammingUnexpanded,
     "kldivergence": DistanceType.KLDivergence,
     "russellrao": DistanceType.RusselRaoExpanded,
-    "nan_euclidean": DistanceType.L2Expanded
+    "nan_euclidean": DistanceType.L2Expanded,
+    "dice": DistanceType.DiceExpanded
 }
 
 PAIRWISE_DISTANCE_SPARSE_METRICS = {
@@ -344,7 +345,7 @@ def pairwise_distances(X, Y=None, metric="euclidean", handle=None,
     if metric in ['nan_euclidean']:
         return nan_euclidean_distances(X, Y, **kwds)
 
-    if metric in ['russellrao'] and not np.all(X.data == 1.):
+    if metric in ['russellrao', 'dice'] and not np.all(X.data == 1.):
         warnings.warn("X was converted to boolean for metric {}"
                       .format(metric))
         X = np.where(X != 0., 1.0, 0.0)
@@ -367,7 +368,7 @@ def pairwise_distances(X, Y=None, metric="euclidean", handle=None,
         if (n_samples_x == 1 or n_features_x == 1):
             input_order = "K"
 
-        if metric in ['russellrao'] and not np.all(Y.data == 1.):
+        if metric in ['russellrao', 'dice'] and not np.all(Y.data == 1.):
             warnings.warn("Y was converted to boolean for metric {}"
                           .format(metric))
             Y = np.where(Y != 0., 1.0, 0.0)

python/cuml/tests/test_umap.py

@@ -685,6 +685,7 @@ def test_fuzzy_simplicial_set(n_rows, n_features, n_neighbors):
         ("chebyshev", True),
         ("cosine", True),
         ("correlation", True),
+        ("dice", True),
         ("jaccard", False),
         ("hamming", True),
         ("canberra", True),
@@ -738,6 +739,7 @@ def test_umap_distance_metrics_fit_transform_trust(metric, supported):
         ("chebyshev", True, True),
         ("cosine", True, True),
         ("correlation", True, True),
+        ("dice", True, True),
         ("jaccard", True, True),
         ("hamming", True, True),
         ("canberra", True, True),