refactor!(core): Move everything into the gprat namespace

Author: timniederhausen

bindings/gprat_py.cpp

@@ -31,19 +31,19 @@ void init_gprat(py::module &m)
     // Set hyperparameters to default values in `AdamParams` class, unless
     // specified. Python object has full access to each hyperparameter and a
     // string representation `__repr__`.
-    py::class_<gprat_hyper::AdamParams>(m, "AdamParams")
+    py::class_<gprat::AdamParams>(m, "AdamParams")
         .def(py::init<double, double, double, double, int>(),
              py::arg("learning_rate") = 0.001,
              py::arg("beta1") = 0.9,
              py::arg("beta2") = 0.999,
              py::arg("epsilon") = 1e-8,
              py::arg("opt_iter") = 0)
-        .def_readwrite("learning_rate", &gprat_hyper::AdamParams::learning_rate)
-        .def_readwrite("beta1", &gprat_hyper::AdamParams::beta1)
-        .def_readwrite("beta2", &gprat_hyper::AdamParams::beta2)
-        .def_readwrite("epsilon", &gprat_hyper::AdamParams::epsilon)
-        .def_readwrite("opt_iter", &gprat_hyper::AdamParams::opt_iter)
-        .def("__repr__", &gprat_hyper::AdamParams::repr);
+        .def_readwrite("learning_rate", &gprat::AdamParams::learning_rate)
+        .def_readwrite("beta1", &gprat::AdamParams::beta1)
+        .def_readwrite("beta2", &gprat::AdamParams::beta2)
+        .def_readwrite("epsilon", &gprat::AdamParams::epsilon)
+        .def_readwrite("opt_iter", &gprat::AdamParams::opt_iter)
+        .def("__repr__", &gprat::AdamParams::repr);
 
     // Initializes Gaussian Process with `GP` class. Sets default parameters for
     // squared exponential kernel, number of regressors and trainable, unless

bindings/utils_py.cpp

@@ -32,7 +32,7 @@ void start_hpx_wrapper(std::vector<std::string> args, std::size_t n_cores)
     }
     argv.push_back(nullptr);
     int argc = static_cast<int>(args.size());
-    utils::start_hpx_runtime(argc, argv.data());
+    gprat::start_hpx_runtime(argc, argv.data());
 }
 
 /**
@@ -43,7 +43,7 @@ void start_hpx_wrapper(std::vector<std::string> args, std::size_t n_cores)
 void init_utils(py::module &m)
 {
     m.def("compute_train_tiles",
-          &utils::compute_train_tiles,
+          &gprat::compute_train_tiles,
           py::arg("n_samples"),
           py::arg("n_tile_size"),
           R"pbdoc(
@@ -58,7 +58,7 @@ void init_utils(py::module &m)
           )pbdoc");
 
     m.def("compute_train_tile_size",
-          &utils::compute_train_tile_size,
+          &gprat::compute_train_tile_size,
           py::arg("n_samples"),
           py::arg("n_tiles"),
           R"pbdoc(
@@ -73,7 +73,7 @@ void init_utils(py::module &m)
           )pbdoc");
 
     m.def("compute_test_tiles",
-          &utils::compute_test_tiles,
+          &gprat::compute_test_tiles,
           py::arg("m_samples"),
           py::arg("n_tiles"),
           py::arg("n_tile_size"),
@@ -90,19 +90,19 @@ void init_utils(py::module &m)
           )pbdoc");
 
     m.def("print_vector",
-          &utils::print_vector,
+          &gprat::print_vector,
           py::arg("vec"),
           py::arg("start") = 0,
           py::arg("end") = -1,
           py::arg("separator") = " ",
           "Print elements of a vector with optional start, end, and separator parameters");
 
     m.def("start_hpx", &start_hpx_wrapper, py::arg("args"), py::arg("n_cores"));  // Using the wrapper function
-    m.def("resume_hpx", &utils::resume_hpx_runtime);
-    m.def("suspend_hpx", &utils::suspend_hpx_runtime);
-    m.def("stop_hpx", &utils::stop_hpx_runtime);
+    m.def("resume_hpx", &gprat::resume_hpx_runtime);
+    m.def("suspend_hpx", &gprat::suspend_hpx_runtime);
+    m.def("stop_hpx", &gprat::stop_hpx_runtime);
 
-    m.def("compiled_with_cuda", &utils::compiled_with_cuda, "Check if the code was compiled with CUDA support");
+    m.def("compiled_with_cuda", &gprat::compiled_with_cuda, "Check if the code was compiled with CUDA support");
 
     m.def("print_available_gpus", &gprat::print_available_gpus, "Print available GPUs with their properties");
     m.def("gpu_count", &gprat::gpu_count, "Return the number of available GPUs");

core/include/gprat/cpu/adapter_cblas_fp32.hpp

@@ -1,8 +1,15 @@
-#ifndef CPU_ADAPTER_CBLAS_FP32_H
-#define CPU_ADAPTER_CBLAS_FP32_H
+#ifndef GPRAT_CPU_ADAPTER_CBLAS_FP32_HPP
+#define GPRAT_CPU_ADAPTER_CBLAS_FP32_HPP
+
+#pragma once
+
+#include <gprat/detail/config.hpp>
 
 #include <hpx/future.hpp>
 #include <vector>
+
+GPRAT_NS_BEGIN
+
 using vector_future = hpx::shared_future<std::vector<float>>;
 
 // Constants that are compatible with CBLAS
@@ -145,4 +152,6 @@ vector_future axpy(vector_future f_y, vector_future f_x, const int N);
  */
 float dot(std::vector<float> a, std::vector<float> b, const int N);
 
-#endif  // end of CPU_ADAPTER_CBLAS_FP32_H
+GPRAT_NS_END
+
+#endif

core/include/gprat/cpu/adapter_cblas_fp64.hpp

@@ -1,13 +1,18 @@
-#ifndef CPU_ADAPTER_CBLAS_FP64_H
-#define CPU_ADAPTER_CBLAS_FP64_H
+#ifndef GPRAT_CPU_ADAPTER_CBLAS_FP64_HPP
+#define GPRAT_CPU_ADAPTER_CBLAS_FP64_HPP
+
+#pragma once
+
+#include <gprat/detail/config.hpp>
 
 #include <hpx/future.hpp>
 #include <vector>
 
+GPRAT_NS_BEGIN
+
 using vector_future = hpx::shared_future<std::vector<double>>;
 
 // Constants that are compatible with CBLAS
-
 typedef enum BLAS_TRANSPOSE { Blas_no_trans = 111, Blas_trans = 112 } BLAS_TRANSPOSE;
 
 typedef enum BLAS_SIDE { Blas_left = 141, Blas_right = 142 } BLAS_SIDE;
@@ -147,4 +152,6 @@ vector_future axpy(vector_future f_y, vector_future f_x, const int N);
  */
 double dot(std::vector<double> a, std::vector<double> b, const int N);
 
-#endif  // end of CPU_ADAPTER_CBLAS_FP64_H
+GPRAT_NS_END
+
+#endif

core/include/gprat/cpu/gp_algorithms.hpp

@@ -1,9 +1,15 @@
-#ifndef CPU_GP_ALGORITHMS_H
-#define CPU_GP_ALGORITHMS_H
+#ifndef GPRAT_CPU_GP_ALGORITHMS_HPP
+#define GPRAT_CPU_GP_ALGORITHMS_HPP
 
-#include "gp_kernels.hpp"
+#pragma once
+
+#include <gprat/detail/config.hpp>
+
+#include <gprat/gp_kernels.hpp>
 #include <vector>
 
+GPRAT_NS_BEGIN
+
 namespace cpu
 {
 
@@ -22,7 +28,7 @@ namespace cpu
 double compute_covariance_function(std::size_t i_global,
                                    std::size_t j_global,
                                    std::size_t n_regressors,
-                                   const gprat_hyper::SEKParams &sek_params,
+                                   const SEKParams &sek_params,
                                    const std::vector<double> &i_input,
                                    const std::vector<double> &j_input);
 
@@ -44,7 +50,7 @@ std::vector<double> gen_tile_covariance(
     std::size_t col,
     std::size_t N,
     std::size_t n_regressors,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &input);
 
 /**
@@ -66,7 +72,7 @@ std::vector<double> gen_tile_full_prior_covariance(
     std::size_t col,
     std::size_t N,
     std::size_t n_regressors,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &input);
 
 /**
@@ -88,7 +94,7 @@ std::vector<double> gen_tile_prior_covariance(
     std::size_t col,
     std::size_t N,
     std::size_t n_regressors,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &input);
 
 /**
@@ -111,7 +117,7 @@ std::vector<double> gen_tile_cross_covariance(
     std::size_t N_row,
     std::size_t N_col,
     std::size_t n_regressors,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &row_input,
     const std::vector<double> &col_input);
 
@@ -170,4 +176,6 @@ std::vector<double> gen_tile_identity(std::size_t N);
 
 }  // end of namespace cpu
 
-#endif  // end of CPU_GP_ALGORITHMS_H
+GPRAT_NS_END
+
+#endif

core/include/gprat/cpu/gp_functions.hpp

@@ -1,10 +1,16 @@
-#ifndef CPU_GP_FUNCTIONS_H
-#define CPU_GP_FUNCTIONS_H
+#ifndef GPRAT_CPU_GP_FUNCTIONS_HPP
+#define GPRAT_CPU_GP_FUNCTIONS_HPP
 
-#include "gp_hyperparameters.hpp"
-#include "gp_kernels.hpp"
+#pragma once
+
+#include <gprat/detail/config.hpp>
+
+#include "gprat/gp_hyperparameters.hpp"
+#include "gprat/gp_kernels.hpp"
 #include <vector>
 
+GPRAT_NS_BEGIN
+
 namespace cpu
 {
 
@@ -22,7 +28,7 @@ namespace cpu
  */
 std::vector<std::vector<double>>
 cholesky(const std::vector<double> &training_input,
-         const gprat_hyper::SEKParams &sek_params,
+         const SEKParams &sek_params,
          int n_tiles,
          int n_tile_size,
          int n_regressors);
@@ -46,7 +52,7 @@ std::vector<double>
 predict(const std::vector<double> &training_input,
         const std::vector<double> &training_output,
         const std::vector<double> &test_input,
-        const gprat_hyper::SEKParams &sek_params,
+        const SEKParams &sek_params,
         int n_tiles,
         int n_tile_size,
         int m_tiles,
@@ -72,7 +78,7 @@ std::vector<std::vector<double>> predict_with_uncertainty(
     const std::vector<double> &training_input,
     const std::vector<double> &training_output,
     const std::vector<double> &test_input,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     int n_tiles,
     int n_tile_size,
     int m_tiles,
@@ -98,7 +104,7 @@ std::vector<std::vector<double>> predict_with_full_cov(
     const std::vector<double> &training_input,
     const std::vector<double> &training_output,
     const std::vector<double> &test_data,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     int n_tiles,
     int n_tile_size,
     int m_tiles,
@@ -119,7 +125,7 @@ std::vector<std::vector<double>> predict_with_full_cov(
  */
 double compute_loss(const std::vector<double> &training_input,
                     const std::vector<double> &training_output,
-                    const gprat_hyper::SEKParams &sek_params,
+                    const SEKParams &sek_params,
                     int n_tiles,
                     int n_tile_size,
                     int n_regressors);
@@ -146,8 +152,8 @@ optimize(const std::vector<double> &training_input,
          int n_tiles,
          int n_tile_size,
          int n_regressors,
-         const gprat_hyper::AdamParams &adam_params,
-         gprat_hyper::SEKParams &sek_params,
+         const AdamParams &adam_params,
+         SEKParams &sek_params,
          std::vector<bool> trainable_params);
 
 /**
@@ -173,11 +179,13 @@ double optimize_step(const std::vector<double> &training_input,
                      int n_tiles,
                      int n_tile_size,
                      int n_regressors,
-                     gprat_hyper::AdamParams &adam_params,
-                     gprat_hyper::SEKParams &sek_params,
+                     AdamParams &adam_params,
+                     SEKParams &sek_params,
                      std::vector<bool> trainable_params,
                      int iter);
 
 }  // end of namespace cpu
 
-#endif  // end of CPU_GP_FUNCTIONS_H
+GPRAT_NS_END
+
+#endif

core/include/gprat/cpu/gp_optimizer.hpp

@@ -1,10 +1,16 @@
-#ifndef CPU_GP_OPTIMIZER_H
-#define CPU_GP_OPTIMIZER_H
+#ifndef GPRAT_CPU_GP_OPTIMIZER_H
+#define GPRAT_CPU_GP_OPTIMIZER_H
 
-#include "gp_hyperparameters.hpp"
-#include "gp_kernels.hpp"
+#pragma once
+
+#include <gprat/detail/config.hpp>
+
+#include "gprat/gp_hyperparameters.hpp"
+#include "gprat/gp_kernels.hpp"
 #include <vector>
 
+GPRAT_NS_BEGIN
+
 namespace cpu
 {
 
@@ -54,7 +60,7 @@ double compute_sigmoid(double parameter);
 double compute_covariance_distance(std::size_t i_global,
                                    std::size_t j_global,
                                    std::size_t n_regressors,
-                                   const gprat_hyper::SEKParams &sek_params,
+                                   const SEKParams &sek_params,
                                    const std::vector<double> &i_input,
                                    const std::vector<double> &j_input);
 
@@ -75,7 +81,7 @@ std::vector<double> gen_tile_distance(
     std::size_t col,
     std::size_t N,
     std::size_t n_regressors,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &input);
 
 /**
@@ -93,7 +99,7 @@ std::vector<double> gen_tile_covariance_with_distance(
     std::size_t row,
     std::size_t col,
     std::size_t N,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &distance);
 
 /**
@@ -106,7 +112,7 @@ std::vector<double> gen_tile_covariance_with_distance(
  * @return A quadratic tile of the derivative of v of size N x N
  */
 std::vector<double>
-gen_tile_grad_v(std::size_t N, const gprat_hyper::SEKParams &sek_params, const std::vector<double> &distance);
+gen_tile_grad_v(std::size_t N, const SEKParams &sek_params, const std::vector<double> &distance);
 
 /**
  * @brief  Generate a derivative tile w.r.t. lengthscale l
@@ -118,7 +124,7 @@ gen_tile_grad_v(std::size_t N, const gprat_hyper::SEKParams &sek_params, const s
  * @return A quadratic tile of the derivative of l of size N x N
  */
 std::vector<double>
-gen_tile_grad_l(std::size_t N, const gprat_hyper::SEKParams &sek_params, const std::vector<double> &distance);
+gen_tile_grad_l(std::size_t N, const SEKParams &sek_params, const std::vector<double> &distance);
 
 /**
  * @brief Update biased first raw moment estimate: m_T+1 = beta_1 * m_T + (1 - beta_1) * g_T.
@@ -154,7 +160,7 @@ double update_second_moment(double gradient, double v_T, double beta_2);
  * @return The updated hyperparameter
  */
 double adam_step(const double unconstrained_hyperparam,
-                 const gprat_hyper::AdamParams &adam_params,
+                 const AdamParams &adam_params,
                  double m_T,
                  double v_T,
                  std::size_t iter);
@@ -230,4 +236,6 @@ double compute_trace_diag(const std::vector<double> &tile, double trace, std::si
 
 }  // end of namespace cpu
 
-#endif  // end of CPU_GP_OPTIMIZER_H
+GPRAT_NS_END
+
+#endif