Moving more ling prims to raft

cpp/bench/prims/rng.cu

@@ -89,25 +89,15 @@ static std::vector<Params<T>> getInputs()
     {32 * 1024 * 1024 + 1, RNG_Uniform, GenPhilox, T(-1.0), T(1.0)},
     {1024 * 1024 * 1024 + 1, RNG_Uniform, GenPhilox, T(-1.0), T(1.0)},
 
-    {1024 * 1024, RNG_Uniform, GenTaps, T(-1.0), T(1.0)},
-    {32 * 1024 * 1024, RNG_Uniform, GenTaps, T(-1.0), T(1.0)},
-    {1024 * 1024 * 1024, RNG_Uniform, GenTaps, T(-1.0), T(1.0)},
-    {1024 * 1024 + 2, RNG_Uniform, GenTaps, T(-1.0), T(1.0)},
-    {32 * 1024 * 1024 + 2, RNG_Uniform, GenTaps, T(-1.0), T(1.0)},
-    {1024 * 1024 * 1024 + 2, RNG_Uniform, GenTaps, T(-1.0), T(1.0)},
-    {1024 * 1024 + 1, RNG_Uniform, GenTaps, T(-1.0), T(1.0)},
-    {32 * 1024 * 1024 + 1, RNG_Uniform, GenTaps, T(-1.0), T(1.0)},
-    {1024 * 1024 * 1024 + 1, RNG_Uniform, GenTaps, T(-1.0), T(1.0)},
-
-    {1024 * 1024, RNG_Uniform, GenKiss99, T(-1.0), T(1.0)},
-    {32 * 1024 * 1024, RNG_Uniform, GenKiss99, T(-1.0), T(1.0)},
-    {1024 * 1024 * 1024, RNG_Uniform, GenKiss99, T(-1.0), T(1.0)},
-    {1024 * 1024 + 2, RNG_Uniform, GenKiss99, T(-1.0), T(1.0)},
-    {32 * 1024 * 1024 + 2, RNG_Uniform, GenKiss99, T(-1.0), T(1.0)},
-    {1024 * 1024 * 1024 + 2, RNG_Uniform, GenKiss99, T(-1.0), T(1.0)},
-    {1024 * 1024 + 1, RNG_Uniform, GenKiss99, T(-1.0), T(1.0)},
-    {32 * 1024 * 1024 + 1, RNG_Uniform, GenKiss99, T(-1.0), T(1.0)},
-    {1024 * 1024 * 1024 + 1, RNG_Uniform, GenKiss99, T(-1.0), T(1.0)},
+    {1024 * 1024, RNG_Uniform, GenPC, T(-1.0), T(1.0)},
+    {32 * 1024 * 1024, RNG_Uniform, GenPC, T(-1.0), T(1.0)},
+    {1024 * 1024 * 1024, RNG_Uniform, GenPC, T(-1.0), T(1.0)},
+    {1024 * 1024 + 2, RNG_Uniform, GenPC, T(-1.0), T(1.0)},
+    {32 * 1024 * 1024 + 2, RNG_Uniform, GenPC, T(-1.0), T(1.0)},
+    {1024 * 1024 * 1024 + 2, RNG_Uniform, GenPC, T(-1.0), T(1.0)},
+    {1024 * 1024 + 1, RNG_Uniform, GenPC, T(-1.0), T(1.0)},
+    {32 * 1024 * 1024 + 1, RNG_Uniform, GenPC, T(-1.0), T(1.0)},
+    {1024 * 1024 * 1024 + 1, RNG_Uniform, GenPC, T(-1.0), T(1.0)},
 
     {1024 * 1024, RNG_Fill, GenPhilox, T(-1.0), T(1.0)},
     {32 * 1024 * 1024, RNG_Fill, GenPhilox, T(-1.0), T(1.0)},

cpp/src/glm/glm.cu

@@ -26,8 +26,6 @@ class handle_t;
 namespace ML {
 namespace GLM {
 
-using namespace MLCommon;
-
 void olsFit(const raft::handle_t& handle,
             float* input,
             int n_rows,

cpp/src/glm/ols.cuh

@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include <linalg/lstsq.cuh>
 #include <raft/linalg/add.hpp>
 #include <raft/linalg/gemv.hpp>
+#include <raft/linalg/lstsq.hpp>
 #include <raft/linalg/norm.hpp>
 #include <raft/linalg/subtract.hpp>
 #include <raft/matrix/math.hpp>
@@ -34,8 +34,6 @@
 namespace ML {
 namespace GLM {
 
-using namespace MLCommon;
-
 /**
  * @brief fit an ordinary least squares model
  * @param handle        cuml handle
@@ -97,10 +95,12 @@ void olsFit(const raft::handle_t& handle,
 
   raft::common::nvtx::push_range("ML::GLM::olsFit/algo-%d", selectedAlgo);
   switch (selectedAlgo) {
-    case 0: LinAlg::lstsqSvdJacobi(handle, input, n_rows, n_cols, labels, coef, stream); break;
-    case 1: LinAlg::lstsqEig(handle, input, n_rows, n_cols, labels, coef, stream); break;
-    case 2: LinAlg::lstsqQR(handle, input, n_rows, n_cols, labels, coef, stream); break;
-    case 3: LinAlg::lstsqSvdQR(handle, input, n_rows, n_cols, labels, coef, stream); break;
+    case 0:
+      raft::linalg::lstsqSvdJacobi(handle, input, n_rows, n_cols, labels, coef, stream);
+      break;
+    case 1: raft::linalg::lstsqEig(handle, input, n_rows, n_cols, labels, coef, stream); break;
+    case 2: raft::linalg::lstsqQR(handle, input, n_rows, n_cols, labels, coef, stream); break;
+    case 3: raft::linalg::lstsqSvdQR(handle, input, n_rows, n_cols, labels, coef, stream); break;
     default:
       ASSERT(false, "olsFit: no algorithm with this id (%d) has been implemented", algo);
       break;

cpp/src/glm/preprocess.cuh

@@ -31,8 +31,6 @@
 namespace ML {
 namespace GLM {
 
-using namespace MLCommon;
-
 /**
  * @brief Center and scale the data, depending on the flags fit_intercept and normalize
  *

cpp/src/glm/qn/simple_mat/dense.hpp

@@ -19,11 +19,11 @@
 #include <vector>
 
 #include "base.hpp"
-#include <linalg/ternary_op.cuh>
 #include <raft/cuda_utils.cuh>
 #include <raft/cudart_utils.h>
 #include <raft/handle.hpp>
 #include <raft/linalg/add.hpp>
+#include <raft/linalg/ternary_op.cuh>
 // #TODO: Replace with public header when ready
 #include <raft/linalg/detail/cublas_wrappers.hpp>
 #include <raft/linalg/map_then_reduce.hpp>
@@ -209,7 +209,7 @@ struct SimpleDenseMat : SimpleMat<T> {
     ASSERT(ord == other2.ord, "SimpleDenseMat::assign_ternary: Storage orders must match");
     ASSERT(ord == other3.ord, "SimpleDenseMat::assign_ternary: Storage orders must match");
 
-    MLCommon::LinAlg::ternaryOp(data, other1.data, other2.data, other3.data, len, f, stream);
+    raft::linalg::ternaryOp(data, other1.data, other2.data, other3.data, len, f, stream);
   }
 
   inline void fill(const T val, cudaStream_t stream)

cpp/src/glm/qn/simple_mat/sparse.hpp

@@ -19,10 +19,10 @@
 #include <vector>
 
 #include "base.hpp"
-#include <linalg/ternary_op.cuh>
 #include <raft/cuda_utils.cuh>
 #include <raft/cudart_utils.h>
 #include <raft/handle.hpp>
+#include <raft/linalg/ternary_op.cuh>
 
 #include <raft/linalg/add.hpp>
 #include <raft/linalg/map_then_reduce.hpp>

cpp/src/glm/ridge.cuh

@@ -35,8 +35,6 @@
 namespace ML {
 namespace GLM {
 
-using namespace MLCommon;
-
 template <typename math_t>
 void ridgeSolve(const raft::handle_t& handle,
                 math_t* S,

cpp/src/kmeans/common.cuh

@@ -24,9 +24,9 @@
 
 #include <common/tensor.hpp>
 
-#include <linalg/reduce_cols_by_key.cuh>
-#include <linalg/reduce_rows_by_key.cuh>
 #include <matrix/gather.cuh>
+#include <raft/linalg/reduce_cols_by_key.cuh>
+#include <raft/linalg/reduce_rows_by_key.cuh>
 #include <random/permute.cuh>
 
 #include <raft/comms/comms.hpp>
@@ -40,7 +40,6 @@
 #include <rmm/device_scalar.hpp>
 #include <rmm/device_uvector.hpp>
 
-#include <random/permute.cuh>
 #include <random>
 
 #include <thrust/equal.h>
@@ -55,9 +54,6 @@
 #include <cuml/cluster/kmeans_mg.hpp>
 #include <cuml/common/logger.hpp>
 #include <cuml/metrics/metrics.hpp>
-#include <linalg/reduce_cols_by_key.cuh>
-#include <linalg/reduce_rows_by_key.cuh>
-#include <matrix/gather.cuh>
 
 #include <fstream>
 #include <numeric>

cpp/src/kmeans/kmeans_mg_impl.cuh

@@ -526,19 +526,19 @@ void fit(const raft::handle_t& handle,
 
     // Calculates weighted sum of all the samples assigned to cluster-i and
     // store the result in newCentroids[i]
-    MLCommon::LinAlg::reduce_rows_by_key(X.data(),
-                                         X.getSize(1),
-                                         itr,
-                                         weight.data(),
-                                         workspace.data(),
-                                         X.getSize(0),
-                                         X.getSize(1),
-                                         n_clusters,
-                                         newCentroids.data(),
-                                         stream);
+    raft::linalg::reduce_rows_by_key(X.data(),
+                                     X.getSize(1),
+                                     itr,
+                                     weight.data(),
+                                     workspace.data(),
+                                     X.getSize(0),
+                                     X.getSize(1),
+                                     n_clusters,
+                                     newCentroids.data(),
+                                     stream);
 
     // Reduce weights by key to compute weight in each cluster
-    MLCommon::LinAlg::reduce_cols_by_key(
+    raft::linalg::reduce_cols_by_key(
       weight.data(), itr, wtInCluster.data(), 1, weight.getSize(0), n_clusters, stream);
 
     // merge the local histogram from all ranks

cpp/src/kmeans/sg_impl.cuh

@@ -135,19 +135,19 @@ void fit(const raft::handle_t& handle,
 
     // Calculates weighted sum of all the samples assigned to cluster-i and store the
     // result in newCentroids[i]
-    MLCommon::LinAlg::reduce_rows_by_key(X.data(),
-                                         X.getSize(1),
-                                         itr,
-                                         weight.data(),
-                                         workspace.data(),
-                                         X.getSize(0),
-                                         X.getSize(1),
-                                         n_clusters,
-                                         newCentroids.data(),
-                                         stream);
+    raft::linalg::reduce_rows_by_key(X.data(),
+                                     X.getSize(1),
+                                     itr,
+                                     weight.data(),
+                                     workspace.data(),
+                                     X.getSize(0),
+                                     X.getSize(1),
+                                     n_clusters,
+                                     newCentroids.data(),
+                                     stream);
 
     // Reduce weights by key to compute weight in each cluster
-    MLCommon::LinAlg::reduce_cols_by_key(
+    raft::linalg::reduce_cols_by_key(
       weight.data(), itr, wtInCluster.data(), 1, weight.getSize(0), n_clusters, stream);
 
     // Computes newCentroids[i] = newCentroids[i]/wtInCluster[i] where

cpp/src/randomforest/randomforest.cuh

@@ -58,7 +58,7 @@ class RandomForest {
     auto rs = DT::fnv1a32_basis;
     rs      = DT::fnv1a32(rs, rf_params.seed);
     rs      = DT::fnv1a32(rs, tree_id);
-    raft::random::Rng rng(rs, raft::random::GeneratorType::GenKiss99);
+    raft::random::Rng rng(rs, raft::random::GenPhilox);
     if (rf_params.bootstrap) {
       // Use bootstrapped sample set
       rng.uniformInt<int>(selected_rows->data(), selected_rows->size(), 0, n_rows, stream);

cpp/src/tsvd/tsvd.cu

@@ -19,8 +19,6 @@
 
 namespace ML {
 
-using namespace MLCommon;
-
 void tsvdFit(raft::handle_t& handle,
              float* input,
              float* components,

cpp/src/tsvd/tsvd.cuh

@@ -17,13 +17,13 @@
 #pragma once
 
 #include <cuml/decomposition/params.hpp>
-#include <linalg/rsvd.cuh>
 #include <raft/cudart_utils.h>
 #include <raft/handle.hpp>
 #include <raft/linalg/add.hpp>
 #include <raft/linalg/eig.hpp>
 #include <raft/linalg/eltwise.hpp>
 #include <raft/linalg/gemm.hpp>
+#include <raft/linalg/rsvd.cuh>
 #include <raft/linalg/transpose.hpp>
 #include <raft/matrix/math.hpp>
 #include <raft/matrix/matrix.hpp>
@@ -38,8 +38,6 @@
 
 namespace ML {
 
-using namespace MLCommon;
-
 template <typename math_t>
 void calCompExpVarsSvd(const raft::handle_t& handle,
                        math_t* in,
@@ -69,22 +67,22 @@ void calCompExpVarsSvd(const raft::handle_t& handle,
 
   rmm::device_uvector<math_t> components_temp(prms.n_cols * prms.n_components, stream);
   math_t* left_eigvec = nullptr;
-  LinAlg::rsvdFixedRank(handle,
-                        in,
-                        prms.n_rows,
-                        prms.n_cols,
-                        singular_vals,
-                        left_eigvec,
-                        components_temp.data(),
-                        prms.n_components,
-                        p,
-                        true,
-                        false,
-                        true,
-                        false,
-                        (math_t)prms.tol,
-                        prms.n_iterations,
-                        stream);
+  raft::linalg::rsvdFixedRank(handle,
+                              in,
+                              prms.n_rows,
+                              prms.n_cols,
+                              singular_vals,
+                              left_eigvec,
+                              components_temp.data(),
+                              prms.n_components,
+                              p,
+                              true,
+                              false,
+                              true,
+                              false,
+                              (math_t)prms.tol,
+                              prms.n_iterations,
+                              stream);
 
   raft::linalg::transpose(
     handle, components_temp.data(), components, prms.n_cols, prms.n_components, stream);

cpp/src/umap/optimize.cuh

@@ -19,11 +19,11 @@
 #include <cuml/common/logger.hpp>
 #include <cuml/manifold/umapparams.h>
 
-#include <linalg/power.cuh>
 #include <raft/cudart_utils.h>
 #include <raft/linalg/add.hpp>
 #include <raft/linalg/eltwise.hpp>
 #include <raft/linalg/multiply.hpp>
+#include <raft/linalg/power.cuh>
 #include <raft/linalg/unary_op.hpp>
 #include <raft/matrix/math.hpp>
 #include <raft/stats/mean.hpp>