Reconciling primitives moved to RAFT

cpp/cmake/thirdparty/get_raft.cmake

@@ -22,10 +22,7 @@ function(find_and_configure_raft)
     cmake_parse_arguments(PKG "${options}" "${oneValueArgs}"
             "${multiValueArgs}" ${ARGN} )
 
-    if(PKG_CLONE_ON_PIN AND NOT PKG_PINNED_TAG STREQUAL "branch-${CUML_BRANCH_VERSION_raft}")
-        message(STATUS "CUML: RAFT pinned tag found: ${PKG_PINNED_TAG}. Cloning raft locally.")
-        set(CPM_DOWNLOAD_raft ON)
-    endif()
+    set(CPM_DOWNLOAD_raft ON)
 
     if(PKG_USE_RAFT_STATIC)
         message(STATUS "CUML: Cloning raft locally to build static libraries.")

cpp/src/arima/batched_arima.cu

@@ -30,12 +30,12 @@
 
 #include <common/nvtx.hpp>
 #include <linalg/batched/matrix.cuh>
-#include <metrics/batched/information_criterion.cuh>
 #include <raft/common/nvtx.hpp>
 #include <raft/cuda_utils.cuh>
 #include <raft/cudart_utils.h>
 #include <raft/handle.hpp>
 #include <raft/linalg/matrix_vector_op.hpp>
+#include <raft/stats/information_criterion.hpp>
 #include <rmm/device_uvector.hpp>
 #include <timeSeries/arima_helpers.cuh>
 #include <timeSeries/fillna.cuh>
@@ -612,14 +612,13 @@ void information_criterion(raft::handle_t& handle,
     handle, arima_mem, d_y, d_exog, batch_size, n_obs, order, params, d_ic, false, false, MLE);
 
   /* Compute information criterion from log-likelihood and base term */
-  MLCommon::Metrics::Batched::information_criterion(
-    d_ic,
-    d_ic,
-    static_cast<MLCommon::Metrics::IC_Type>(ic_type),
-    order.complexity(),
-    batch_size,
-    n_obs - order.n_diff(),
-    stream);
+  raft::stats::information_criterion_batched(d_ic,
+                                             d_ic,
+                                             static_cast<raft::stats::IC_Type>(ic_type),
+                                             order.complexity(),
+                                             batch_size,
+                                             n_obs - order.n_diff(),
+                                             stream);
 }
 
 /**

cpp/src/hdbscan/detail/reachability.cuh

@@ -33,6 +33,7 @@
 
 #include <cuml/neighbors/knn.hpp>
 #include <raft/distance/distance.hpp>
+#include <raft/spatial/knn/specializations.hpp>
 
 #include <thrust/transform.h>
 

cpp/src/hdbscan/hdbscan.cu

@@ -16,6 +16,7 @@
 
 #include "detail/condense.cuh"
 #include <cuml/cluster/hdbscan.hpp>
+#include <raft/spatial/knn/specializations.hpp>
 
 #include "runner.h"
 

cpp/src/knn/knn_opg_common.cuh

@@ -28,6 +28,7 @@
 #include <raft/cuda_utils.cuh>
 #include <raft/cudart_utils.h>
 #include <raft/spatial/knn/knn.hpp>
+#include <raft/spatial/knn/specializations.hpp>
 
 #include <cstddef>
 #include <memory>

cpp/src/knn/knn_sparse.cu

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,7 @@
 #include <cuml/neighbors/knn_sparse.hpp>
 
 #include <raft/sparse/selection/knn.hpp>
+#include <raft/spatial/knn/specializations.hpp>
 
 #include <cusparse_v2.h>
 

cpp/src/metrics/accuracy_score.cu

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
  */
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/scores.cuh>
+#include <raft/stats/accuracy.hpp>
 
 namespace ML {
 
@@ -27,7 +27,7 @@ float accuracy_score_py(const raft::handle_t& handle,
                         const int* ref_predictions,
                         int n)
 {
-  return MLCommon::Score::accuracy_score(predictions, ref_predictions, n, handle.get_stream());
+  return raft::stats::accuracy(predictions, ref_predictions, n, handle.get_stream());
 }
 }  // namespace Metrics
 }  // namespace ML

cpp/src/metrics/adjusted_rand_index.cu

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
  */
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/adjusted_rand_index.cuh>
+#include <raft/stats/adjusted_rand_index.hpp>
 
 namespace ML {
 
@@ -26,7 +26,7 @@ double adjusted_rand_index(const raft::handle_t& handle,
                            const int64_t* y_hat,
                            const int64_t n)
 {
-  return MLCommon::Metrics::compute_adjusted_rand_index<int64_t, unsigned long long>(
+  return raft::stats::adjusted_rand_index<int64_t, unsigned long long>(
     y, y_hat, n, handle.get_stream());
 }
 
@@ -35,7 +35,7 @@ double adjusted_rand_index(const raft::handle_t& handle,
                            const int* y_hat,
                            const int n)
 {
-  return MLCommon::Metrics::compute_adjusted_rand_index<int, unsigned long long>(
+  return raft::stats::adjusted_rand_index<int, unsigned long long>(
     y, y_hat, n, handle.get_stream());
 }
 }  // namespace Metrics

cpp/src/metrics/completeness_score.cu

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
  */
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/homogeneity_score.cuh>
+#include <raft/stats/completeness_score.hpp>
 
 namespace ML {
 
@@ -29,7 +29,7 @@ double completeness_score(const raft::handle_t& handle,
                           const int lower_class_range,
                           const int upper_class_range)
 {
-  return MLCommon::Metrics::homogeneity_score(
+  return raft::stats::completeness_score(
     y_hat, y, n, lower_class_range, upper_class_range, handle.get_stream());
 }
 

cpp/src/metrics/entropy.cu

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
  */
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/entropy.cuh>
+#include <raft/stats/entropy.hpp>
 
 namespace ML {
 
@@ -27,8 +27,7 @@ double entropy(const raft::handle_t& handle,
                const int lower_class_range,
                const int upper_class_range)
 {
-  return MLCommon::Metrics::entropy(
-    y, n, lower_class_range, upper_class_range, handle.get_stream());
+  return raft::stats::entropy(y, n, lower_class_range, upper_class_range, handle.get_stream());
 }
 }  // namespace Metrics
 }  // namespace ML

cpp/src/metrics/homogeneity_score.cu

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
  */
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/homogeneity_score.cuh>
+#include <raft/stats/homogeneity_score.hpp>
 
 namespace ML {
 
@@ -29,7 +29,7 @@ double homogeneity_score(const raft::handle_t& handle,
                          const int lower_class_range,
                          const int upper_class_range)
 {
-  return MLCommon::Metrics::homogeneity_score(
+  return raft::stats::homogeneity_score(
     y, y_hat, n, lower_class_range, upper_class_range, handle.get_stream());
 }
 }  // namespace Metrics

cpp/src/metrics/kl_divergence.cu

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,20 +16,20 @@
  */
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/kl_divergence.cuh>
+#include <raft/stats/kl_divergence.hpp>
 
 namespace ML {
 
 namespace Metrics {
 
 double kl_divergence(const raft::handle_t& handle, const double* y, const double* y_hat, int n)
 {
-  return MLCommon::Metrics::kl_divergence(y, y_hat, n, handle.get_stream());
+  return raft::stats::kl_divergence(y, y_hat, n, handle.get_stream());
 }
 
 float kl_divergence(const raft::handle_t& handle, const float* y, const float* y_hat, int n)
 {
-  return MLCommon::Metrics::kl_divergence(y, y_hat, n, handle.get_stream());
+  return raft::stats::kl_divergence(y, y_hat, n, handle.get_stream());
 }
 }  // namespace Metrics
 }  // namespace ML

cpp/src/metrics/mutual_info_score.cu

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@
 #include <raft/handle.hpp>
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/mutual_info_score.cuh>
+#include <raft/stats/mutual_info_score.hpp>
 
 namespace ML {
 
@@ -31,7 +31,7 @@ double mutual_info_score(const raft::handle_t& handle,
                          const int lower_class_range,
                          const int upper_class_range)
 {
-  return MLCommon::Metrics::mutual_info_score(
+  return raft::stats::mutual_info_score(
     y, y_hat, n, lower_class_range, upper_class_range, handle.get_stream());
 }
 

cpp/src/metrics/r2_score.cu

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, 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,20 +15,20 @@
  */
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/scores.cuh>
+#include <raft/stats/r2_score.hpp>
 
 namespace ML {
 
 namespace Metrics {
 
 float r2_score_py(const raft::handle_t& handle, float* y, float* y_hat, int n)
 {
-  return MLCommon::Score::r2_score(y, y_hat, n, handle.get_stream());
+  return raft::stats::r2_score(y, y_hat, n, handle.get_stream());
 }
 
 double r2_score_py(const raft::handle_t& handle, double* y, double* y_hat, int n)
 {
-  return MLCommon::Score::r2_score(y, y_hat, n, handle.get_stream());
+  return raft::stats::r2_score(y, y_hat, n, handle.get_stream());
 }
 
 }  // namespace Metrics

cpp/src/metrics/rand_index.cu

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (c) 2019-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,15 +18,15 @@
 #include <raft/handle.hpp>
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/rand_index.cuh>
+#include <raft/stats/rand_index.hpp>
 
 namespace ML {
 
 namespace Metrics {
 
 double rand_index(const raft::handle_t& handle, const double* y, const double* y_hat, int n)
 {
-  return MLCommon::Metrics::compute_rand_index(y, y_hat, (uint64_t)n, handle.get_stream());
+  return raft::stats::rand_index(y, y_hat, (uint64_t)n, handle.get_stream());
 }
 }  // namespace Metrics
 }  // namespace ML

cpp/src/metrics/silhouette_score.cu

@@ -16,9 +16,8 @@
  */
 
 #include <cuml/metrics/metrics.hpp>
-#include <metrics/batched/silhouette_score.cuh>
-#include <metrics/silhouette_score.cuh>
 #include <raft/distance/distance_type.hpp>
+#include <raft/stats/silhouette_score.hpp>
 
 namespace ML {
 
@@ -32,7 +31,7 @@ double silhouette_score(const raft::handle_t& handle,
                         double* silScores,
                         raft::distance::DistanceType metric)
 {
-  return MLCommon::Metrics::silhouette_score<double, int>(
+  return raft::stats::silhouette_score<double, int>(
     handle, y, nRows, nCols, labels, nLabels, silScores, handle.get_stream(), metric);
 }
 
@@ -48,7 +47,7 @@ float silhouette_score(const raft::handle_t& handle,
                        int chunk,
                        raft::distance::DistanceType metric)
 {
-  return MLCommon::Metrics::Batched::silhouette_score<float, int, int>(
+  return raft::stats::silhouette_score_batched<float, int, int>(
     handle, X, n_rows, n_cols, y, n_labels, scores, chunk, metric);
 }
 
@@ -62,7 +61,7 @@ double silhouette_score(const raft::handle_t& handle,
                         int chunk,
                         raft::distance::DistanceType metric)
 {
-  return MLCommon::Metrics::Batched::silhouette_score<double, int, int>(
+  return raft::stats::silhouette_score_batched<double, int, int>(
     handle, X, n_rows, n_cols, y, n_labels, scores, chunk, metric);
 }