gbrl 1.0.0.dev1__tar.gz → 1.0.0.dev3__tar.gz

{gbrl-1.0.0.dev1/gbrl.egg-info → gbrl-1.0.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gbrl
-Version: 1.0.0.dev1
+Version: 1.0.0.dev3
 Summary: Gradient Boosted Trees for RL
 Author-email: Benjamin Fuhrer <bfuhrer@nvidia.com>, Chen Tesslr <ctessler@nvidia.com>, Gal Dalal <galal@nvidia.com>
 License-File: LICENSE

{gbrl-1.0.0.dev1 → gbrl-1.0.0.dev3}/README.md

@@ -10,9 +10,24 @@ GBRL is a Python-based GBT library designed and optimized for reinforcement lear
 
 ## Getting started
 
+### Dependencies 
+llvm
+openmp
+
+#### MAC OS 
+
+Make sure to run:
+```
+brew install libomp
+brew install llvm
+ ```
+
+xcode command line tools should be installed installed 
+
+### Installation
 ```
 pip install gbrl
-```  
+```
 
 For GPU support GBRL looks for `CUDA_PATH` or `CUDA_HOME` environment variables. Unless found, GBRL will automatically compile only for CPU.
 

{gbrl-1.0.0.dev1 → gbrl-1.0.0.dev3}/gbrl/src/cpp/fitter.cpp

@@ -335,8 +335,10 @@ int Fitter::fit_oblivious_tree(dataSet *dataset, ensembleData *edata, ensembleMe
     int *root_sample_indices = new int[n_samples];
     std::iota(root_sample_indices, root_sample_indices + n_samples, 0);
 
-    std::vector<TreeNode*> tree_nodes(1 << metadata->max_depth); 
-    std::vector<TreeNode*> child_tree_nodes(1 << metadata->max_depth); 
+    int max_n_leaves = 1 << metadata->max_depth;
+
+    std::vector<TreeNode*> tree_nodes(max_n_leaves); 
+    std::vector<TreeNode*> child_tree_nodes(max_n_leaves); 
     TreeNode *rootNode = new TreeNode(root_sample_indices, n_samples, metadata->n_num_features, metadata->n_cat_features, metadata->output_dim, metadata->policy_dim, depth, 0);
     tree_nodes[0] = rootNode;
 

{gbrl-1.0.0.dev1 → gbrl-1.0.0.dev3}/gbrl/src/cpp/gbrl.cpp

@@ -81,7 +81,7 @@ GBRL::GBRL(int output_dim, int policy_dim, int max_depth, int min_data_in_leaf,
 GBRL::GBRL(const std::string& filename){
     int status = this->loadFromFile(filename);
     if (status != 0){
-        std::cerr << "Error loading ! " <<  filename  << std::endl; 
+        std::cerr << "Error loading . " <<  filename  << std::endl; 
         throw std::runtime_error("File load error");
     }
 }
@@ -127,6 +127,8 @@ GBRL::~GBRL() {
     this->metadata = nullptr;
 }
 
+
+
 void GBRL::to_device(deviceType device){
     if (device == this->device){
         std::cout << "GBRL device is already " << deviceTypeToString(device) << std::endl;
@@ -134,11 +136,19 @@ void GBRL::to_device(deviceType device){
     }
 #ifndef USE_CUDA
     if (device == gpu)
-        std::cerr << "GBRL was not compiled for GPU! using cpu device!" << std::endl;
+        std::cerr << "GBRL was not compiled for GPU. Using cpu device" << std::endl;
     this->edata = ensemble_data_alloc(this->metadata);
     this->device = cpu;
     return;
 #else
+    
+    if (device == gpu){
+        bool is_valid = valid_device();
+        if (!is_valid){
+            std::cerr << "No GPU device found. Using cpu device" << std::endl;
+            device = cpu;
+        }
+    }
     if (this->device == unspecified){
         if (device == cpu){
             this->edata = ensemble_data_alloc(this->metadata);
@@ -146,7 +156,6 @@ void GBRL::to_device(deviceType device){
         } else {
             this->edata = ensemble_data_alloc_cuda(this->metadata);
             this->device = gpu;
-            return;
         }
     } else if (this->device == cpu && device == gpu){
         ensembleData* edata_gpu = ensemble_data_copy_cpu_gpu(this->metadata, this->edata);
@@ -160,7 +169,7 @@ void GBRL::to_device(deviceType device){
         this->device = cpu;
     }
     if (this->device == gpu && this->metadata->use_cv){
-        std::cout << "Cannot use control variates with GPU! Setting use_cv to False!" << std::endl;
+        std::cout << "Cannot use control variates with GPU. Setting use_cv to False." << std::endl;
         this->metadata->use_cv = false;
     }
 #endif 
@@ -170,7 +179,7 @@ void GBRL::to_device(deviceType device){
 void GBRL::set_bias(float *bias, const int output_dim){
     if (output_dim != this->metadata->output_dim)
     {
-        std::cerr << "Given bias vector has different dimensions than expect! " << " Given: " << output_dim << " expected: " << this->metadata->output_dim << std::endl; 
+        std::cerr << "Given bias vector has different dimensions than expect. " << " Given: " << output_dim << " expected: " << this->metadata->output_dim << std::endl; 
         throw std::runtime_error("Incompatible dimensions");
         return;
     }
@@ -183,7 +192,7 @@ void GBRL::set_bias(float *bias, const int output_dim){
 }
 
 float* GBRL::get_bias(){
-    // returns a copy! must deallocated new float pointer!
+    // returns a copy. must deallocated new float pointer!
 #ifdef USE_CUDA
     if (this->device == gpu){
         float *bias = new float[this->metadata->output_dim];
@@ -208,7 +217,7 @@ float* GBRL::predict(const float *obs, const char *categorical_obs, const int n_
     }
     if (n_num_features != metadata->n_num_features || n_cat_features != metadata->n_cat_features){
         delete[] preds;
-        std::cerr << "Error! Cannot use ensemble with this dataset! Excepted input with " << metadata->n_num_features << " numerical features followed by " << metadata->n_cat_features << " categorical features, but received " << n_num_features << " numerical features and " << n_cat_features << " categorical features!";
+        std::cerr << "Error. Cannot use ensemble with this dataset. Excepted input with " << metadata->n_num_features << " numerical features followed by " << metadata->n_cat_features << " categorical features, but received " << n_num_features << " numerical features and " << n_cat_features << " categorical features.";
         throw std::runtime_error("Incompatible dataset");
     }
 
@@ -219,7 +228,7 @@ float* GBRL::predict(const float *obs, const char *categorical_obs, const int n_
     if (this->device == gpu){
         if (this->cuda_opt == nullptr){
             this->cuda_opt = deepCopySGDOptimizerVectorToGPU(this->opts);
-            this->n_cuda_opts = this->opts.size();
+            this->n_cuda_opts = static_cast<int>(this->opts.size());
         }
         predict_cuda(&dataset, preds, this->metadata, this->edata, this->cuda_opt, this->n_cuda_opts, start_tree_idx, stop_tree_idx);
     
@@ -241,7 +250,7 @@ void GBRL::predict(const float *obs, const char *categorical_obs, float *start_p
         this->metadata->n_cat_features = n_cat_features;
     }
     if (n_num_features != metadata->n_num_features || n_cat_features != metadata->n_cat_features){
-        std::cerr << "Error! Cannot use ensemble with this dataset! Excepted input with " << metadata->n_num_features << " numerical features followed by " << metadata->n_cat_features << " categorical features, but received " << n_num_features << " numerical features and " << n_cat_features << " categorical features!";
+        std::cerr << "Error. Cannot use ensemble with this dataset. Excepted input with " << metadata->n_num_features << " numerical features followed by " << metadata->n_cat_features << " categorical features, but received " << n_num_features << " numerical features and " << n_cat_features << " categorical features.";
         throw std::runtime_error("Incompatible dataset");
         return;
     }
@@ -252,7 +261,7 @@ void GBRL::predict(const float *obs, const char *categorical_obs, float *start_p
     if (this->device == gpu){
         if (this->cuda_opt == nullptr){
             this->cuda_opt = deepCopySGDOptimizerVectorToGPU(this->opts);
-            this->n_cuda_opts = this->opts.size();
+            this->n_cuda_opts = static_cast<int>(this->opts.size());
         }
         predict_cuda(&dataset, start_preds, this->metadata, this->edata, this->cuda_opt, this->n_cuda_opts, start_tree_idx, stop_tree_idx);
     }
@@ -278,7 +287,7 @@ void GBRL::set_optimizer(optimizerAlgo algo, schedulerFunc scheduler_func, float
                         float stop_lr, int T, 
                         float beta_1, float beta_2, float eps = 1.0e-8, float shrinkage = 1.0e-5){
     if (this->opts.size() >= 2){
-        std::cerr << "Already set two optimizers! This is the limit!" << std::endl;
+        std::cerr << "Already set two optimizers. This is the limit." << std::endl;
         throw std::runtime_error("Optimizer Limit Reached");
         return;
     }
@@ -289,7 +298,7 @@ void GBRL::set_optimizer(optimizerAlgo algo, schedulerFunc scheduler_func, float
     if (algo == Adam){
 #ifdef USE_CUDA
         if (this->device == gpu){
-            std::cerr << "The Adam optimizer has cpu support only!" << std::endl;
+            std::cerr << "The Adam optimizer has cpu support only." << std::endl;
             throw std::runtime_error("Incompatible GPU optimizer");
             return;
         }
@@ -299,7 +308,7 @@ void GBRL::set_optimizer(optimizerAlgo algo, schedulerFunc scheduler_func, float
         } else if (scheduler_func == Linear){
             opt = new AdamOptimizer(scheduler_func, init_lr, stop_lr, T,  beta_1, beta_2, eps);
         } else {
-            std::cerr << "Unrecoginized scheduler func!" << std::endl;
+            std::cerr << "Unrecoginized scheduler func." << std::endl;
             throw std::runtime_error("Unrecognized scheduler func");
             opt = nullptr;
             return;
@@ -307,10 +316,10 @@ void GBRL::set_optimizer(optimizerAlgo algo, schedulerFunc scheduler_func, float
 
         if (this->opts.size() == 0){
             opt->set_indices(0, this->metadata->policy_dim);
-            std::cout << "Setting policy optimizer!" << std::endl;
+            std::cout << "Setting policy optimizer." << std::endl;
         } else {
              opt->set_indices(this->metadata->policy_dim, this->metadata->output_dim);
-             std::cout << "Setting value optimizer! Warning cannot set more optimizers" << std::endl;
+             std::cout << "Setting value optimizer. Warning cannot set more optimizers" << std::endl;
         }
 
         this->opts.push_back(opt);
@@ -321,7 +330,7 @@ void GBRL::set_optimizer(optimizerAlgo algo, schedulerFunc scheduler_func, float
         } else if (scheduler_func == Linear){
             opt = new SGDOptimizer(scheduler_func, init_lr, stop_lr, T);
         } else {
-            std::cerr << "Unrecoginized scheduler func!" << std::endl;
+            std::cerr << "Unrecoginized scheduler func." << std::endl;
             throw std::runtime_error("Unrecoginized scheduler func");
             opt = nullptr;
             return;
@@ -461,7 +470,7 @@ float GBRL::_fit_sl_gpu(dataSet *dataset, float *targets, const int n_iterations
 
     if (this->cuda_opt == nullptr){
         this->cuda_opt = deepCopySGDOptimizerVectorToGPU(this->opts);
-        this->n_cuda_opts = this->opts.size();
+        this->n_cuda_opts = static_cast<int>(this->opts.size());
     }
 
     err = cudaMalloc((void**)&device_memory_block, alloc_size);
@@ -568,7 +577,7 @@ void GBRL::fit(const float *obs, const char *categorical_obs, float *grads, cons
         this->metadata->n_cat_features = n_cat_features;
     }
     if (n_num_features != metadata->n_num_features || n_cat_features != metadata->n_cat_features){
-        std::cerr << "Error! Cannot use ensemble with this dataset! Excepted input with " << metadata->n_num_features << " numerical features followed by " << metadata->n_cat_features << " categorical features, but received " << n_num_features << " numerical features and " << n_cat_features << " categorical features!";
+        std::cerr << "Error. Cannot use ensemble with this dataset. Excepted input with " << metadata->n_num_features << " numerical features followed by " << metadata->n_cat_features << " categorical features, but received " << n_num_features << " numerical features and " << n_cat_features << " categorical features.";
         throw std::runtime_error("Incompatible dataset");
         return;
     }
@@ -590,14 +599,14 @@ float GBRL::fit_sl(float *obs, char *categorical_obs, float *targets, int iterat
     }
 
     if (n_num_features != metadata->n_num_features || n_cat_features != metadata->n_cat_features){
-        std::cerr << "Error! Cannot use ensemble with this dataset! Excepted input with " << metadata->n_num_features << " numerical features followed by " << metadata->n_cat_features << " categorical features, but received " << n_num_features << " numerical features and " << n_cat_features << " categorical features!";
+        std::cerr << "Error. Cannot use ensemble with this dataset. Excepted input with " << metadata->n_num_features << " numerical features followed by " << metadata->n_cat_features << " categorical features, but received " << n_num_features << " numerical features and " << n_cat_features << " categorical features.";
         throw std::runtime_error("Incompatible dataset");
         return -INFINITY;
     }
 
     for (auto& algo:  this->opts){
         if (algo->getAlgo() == Adam){
-            std::cerr << "Adam optimizer not supported in fit_sl function! Use SGD" << std::endl;
+            std::cerr << "Adam optimizer not supported in fit_sl function. Use SGD" << std::endl;
             throw std::runtime_error("Unsupported optimizer");
             return 0.0;
         }    
@@ -688,7 +697,7 @@ int GBRL::saveToFile(const std::string& filename){
 
     save_ensemble_data(file, this->edata, this->metadata, this->device);
 
-    int num_opts = this->opts.size();
+    int num_opts = static_cast<int>(this->opts.size());
     file.write(reinterpret_cast<char*>(&num_opts), sizeof(int));
 
     for (int i = 0; i < num_opts; ++i){
@@ -701,7 +710,7 @@ int GBRL::saveToFile(const std::string& filename){
     }
 
     if (!file.good()) {
-        std::cerr << "Error occurred at writing time!" << std::endl;
+        std::cerr << "Error occurred at writing time." << std::endl;
         throw std::runtime_error("Writing to file error");
         return -1;
     }
@@ -727,7 +736,7 @@ int GBRL::loadFromFile(const std::string& filename){
     this->metadata->use_cv = static_cast<bool>(byte);
 
     if (!file.good()) {
-        std::cerr << "Error occurred while reading the file!" << std::endl;
+        std::cerr << "Error occurred while reading the file." << std::endl;
         throw std::runtime_error("Reading file error");
         return -1;
     }
@@ -755,7 +764,7 @@ int GBRL::loadFromFile(const std::string& filename){
 
 
     if (file.fail()) {
-        std::cerr << "Error occurred at file closing time!" << std::endl;
+        std::cerr << "Error occurred at file closing time." << std::endl;
         throw std::runtime_error("File closing error");
         return -1;
     }
@@ -811,6 +820,21 @@ void GBRL::print_tree(int tree_idx){
 #endif 
 }
 
+#ifdef USE_CUDA
+bool valid_device(){
+    int device_count = 0;
+    cudaError_t error = cudaGetDeviceCount(&device_count);
+
+    if (error != cudaSuccess) {
+        std::cout << "CUDA error when querying device count: " << cudaGetErrorString(error) << std::endl;
+        return false;
+    }
+    if (device_count == 0)
+        return false; 
+    return true;
+}
+#endif
+
 #ifdef USE_GRAPHVIZ
 void GBRL::plot_tree(int tree_idx, const std::string &filename){
     ensembleData *edata_cpu = this->edata; 
@@ -820,7 +844,7 @@ void GBRL::plot_tree(int tree_idx, const std::string &filename){
     }
 #endif 
     if (tree_idx >= this->metadata->n_trees){
-        std::cerr << "ERROR - Tree idx: " << tree_idx <<  " > " << this->metadata->n_trees - 1 << " maximum index!" << std::endl;
+        std::cerr << "ERROR - Tree idx: " << tree_idx <<  " > " << this->metadata->n_trees - 1 << " maximum index." << std::endl;
         throw std::runtime_error("Invalid tree index");
         return;
     }
@@ -855,7 +879,7 @@ void GBRL::plot_tree(int tree_idx, const std::string &filename){
         
         if (nodesMap.find(nodeIndex) == nodesMap.end()) {  // Check if the root node already exists
             std::strcpy(buffer, std::to_string(nodeIndex).c_str());
-            parentNode = agnode(g, buffer, TRUE);
+            parentNode = agnode(g, buffer, true);
             std::string nodeLabel = (is_numeric) ? std::to_string(feature_idx) + ", value > " + std::to_string(feature_value) : std::to_string(feature_idx + this->metadata->n_num_features) + ", value == " + std::string(categorical_value);
             std::strcpy(buffer, nodeLabel.c_str());
             // parentNode = agnode(g, buffer, TRUE);  // Create root node or get it if already exists
@@ -878,7 +902,7 @@ void GBRL::plot_tree(int tree_idx, const std::string &filename){
         
             if (nodesMap.find(nodeIndex) == nodesMap.end()) {
                 std::strcpy(buffer, std::to_string(nodeIndex).c_str());
-                currentNode = agnode(g, buffer, TRUE);
+                currentNode = agnode(g, buffer, true);
                 std::string nodeLabel = is_numeric ? std::to_string(feature_idx) + ", value > " + std::to_string(feature_value) : std::to_string(feature_idx + this->metadata->n_num_features) + ", value == " + std::string(categorical_value) ;
                 // std::cout << "printing child node: " << nodeIndex << " with label: " << nodeLabel << std::endl;
                 std::strcpy(buffer, nodeLabel.c_str());
@@ -893,8 +917,8 @@ void GBRL::plot_tree(int tree_idx, const std::string &filename){
 
             if (edgesSet.find(edgeKey) == edgesSet.end()) {
                 std::strcpy(buffer, edgeLabel.c_str());
-                edge = agedge(g, parentNode, currentNode, buffer, TRUE);
-                agsafeset(edge, (char*)"label", buffer, (char*)"");  
+                edge = agedge(g, parentNode, currentNode, buffer, true);
+                agsafeset(edge, (char*)"label", buffer, (char*)"");
                 edgesSet.insert(edgeKey);  
             }
 
@@ -907,8 +931,8 @@ void GBRL::plot_tree(int tree_idx, const std::string &filename){
         std::string leafLabel = "val = " + VectoString(edata_cpu->values + leaf_idx*this->metadata->output_dim, this->metadata->output_dim);
         std::string uniqueLeafLabel = leafLabel + "_idx_" + std::to_string(leaf_idx); 
         std::strcpy(buffer, uniqueLeafLabel.c_str());
-        currentNode = agnode(g, buffer, TRUE);
-        edge = agedge(g, parentNode, currentNode, NULL, TRUE);
+        currentNode = agnode(g, buffer, true);
+        edge = agedge(g, parentNode, currentNode, NULL, true);
 
         agsafeset(currentNode, (char*)"label", buffer, (char*)"");
         agsafeset(currentNode, (char*)"shape", (char*)"box", (char*)"");

{gbrl-1.0.0.dev1 → gbrl-1.0.0.dev3}/gbrl/src/cpp/gbrl.h

@@ -68,7 +68,9 @@ class GBRL {
 };
 
 
-
+#ifdef USE_CUDA
+bool valid_device();
+#endif
 
 
 #endif 

{gbrl-1.0.0.dev1 → gbrl-1.0.0.dev3}/gbrl/src/cpp/gbrl_binding.cpp

@@ -88,7 +88,7 @@ PYBIND11_MODULE(gbrl_cpp, m) {
         }
         py::buffer_info info_grads = grads.request();
         float* grads_ptr = static_cast<float*>(info_grads.ptr);
-        int n_samples = info_grads.shape[0];
+        int n_samples = static_cast<int>(info_grads.shape[0]);
 
         const float* obs_ptr = nullptr;
         int n_num_features = 0;
@@ -98,7 +98,7 @@ PYBIND11_MODULE(gbrl_cpp, m) {
                 throw std::runtime_error("Arrays must be C-contiguous");
             py::buffer_info info_obs = obs_array.request();
             obs_ptr = static_cast<const float*>(info_obs.ptr);
-            n_num_features = info_obs.shape[1];
+            n_num_features = static_cast<int>(info_obs.shape[1]);
         }
         const char* cat_obs_ptr = nullptr;
         int n_cat_features = 0;
@@ -108,7 +108,7 @@ PYBIND11_MODULE(gbrl_cpp, m) {
                 throw std::runtime_error("Arrays must be C-contiguous");
             py::buffer_info info_categorical_obs = py_array.request();
             cat_obs_ptr = static_cast<const char*>(info_categorical_obs.ptr);
-            n_cat_features = info_categorical_obs.shape[1];
+            n_cat_features = static_cast<int>(info_categorical_obs.shape[1]);
         }
                     
         py::gil_scoped_release release; 
@@ -130,7 +130,7 @@ PYBIND11_MODULE(gbrl_cpp, m) {
                 throw std::runtime_error("Arrays must be C-contiguous");
             py::buffer_info info_obs = obs_array.request();
             obs_ptr = static_cast<float*>(info_obs.ptr);
-            n_num_features = info_obs.shape[1];
+            n_num_features = static_cast<int>(info_obs.shape[1]);
         }
 
         char* cat_obs_ptr = nullptr;
@@ -141,13 +141,13 @@ PYBIND11_MODULE(gbrl_cpp, m) {
                 throw std::runtime_error("Arrays must be C-contiguous");
             py::buffer_info info_categorical_obs = py_array.request();
             cat_obs_ptr = static_cast<char*>(info_categorical_obs.ptr);
-            n_cat_features = info_categorical_obs.shape[1];
+            n_cat_features = static_cast<int>(info_categorical_obs.shape[1]);
         }
 
         py::gil_scoped_release release; 
         py::buffer_info info_targets = targets.request();
         float* targets_ptr = static_cast<float*>(info_targets.ptr);
-        int n_samples = info_targets.shape[0];
+        int n_samples = static_cast<int>(info_targets.shape[0]);
         return self.fit_sl(obs_ptr, cat_obs_ptr, targets_ptr, iterations, n_samples, n_num_features, n_cat_features, shuffle, loss_type); 
     },  py::arg("obs"),
         py::arg("categorical_obs"),
@@ -164,7 +164,7 @@ PYBIND11_MODULE(gbrl_cpp, m) {
 
         py::buffer_info info = bias.request();
         float* bias_ptr = static_cast<float*>(info.ptr);
-        int output_dim = len(bias);
+        int output_dim = static_cast<int>(len(bias));
         
         self.set_bias(bias_ptr, output_dim); 
     }, "Set GBRL model bias");
@@ -199,8 +199,8 @@ PYBIND11_MODULE(gbrl_cpp, m) {
                 throw std::runtime_error("Arrays must be C-contiguous");
             py::buffer_info info_obs = obs_array.request();
             obs_ptr = static_cast<const float*>(info_obs.ptr);
-            n_num_features = info_obs.shape[1];
-            n_samples = info_obs.shape[0];
+            n_num_features = static_cast<int>(info_obs.shape[1]);
+            n_samples = static_cast<int>(info_obs.shape[0]);
         }
         int n_cat_features = 0;
         const char *cat_obs_ptr = nullptr;
@@ -211,8 +211,8 @@ PYBIND11_MODULE(gbrl_cpp, m) {
 
             py::buffer_info info_categorical_obs = py_array.request();
             cat_obs_ptr = static_cast<const char*>(info_categorical_obs.ptr);
-            n_cat_features = info_categorical_obs.shape[1];
-            n_samples = info_categorical_obs.shape[0];
+            n_cat_features = static_cast<int>(info_categorical_obs.shape[1]);
+            n_samples = static_cast<int>(info_categorical_obs.shape[0]);
         }
 
         py::gil_scoped_release release; 
@@ -235,7 +235,7 @@ PYBIND11_MODULE(gbrl_cpp, m) {
                 throw std::runtime_error("Arrays must be C-contiguous");
             py::buffer_info info_obs = obs_array.request();
             obs_ptr = static_cast<const float*>(info_obs.ptr);
-            n_num_features = info_obs.shape[1];
+            n_num_features = static_cast<int>(info_obs.shape[1]);
         }
         int n_cat_features = 0;
         const char *cat_obs_ptr = nullptr;
@@ -245,12 +245,12 @@ PYBIND11_MODULE(gbrl_cpp, m) {
                 throw std::runtime_error("Arrays must be C-contiguous");
             py::buffer_info info_categorical_obs = py_array.request();
             cat_obs_ptr = static_cast<const char*>(info_categorical_obs.ptr);
-            n_cat_features = info_categorical_obs.shape[1];
+            n_cat_features = static_cast<int>(info_categorical_obs.shape[1]);
         }
         py::gil_scoped_release release; 
         py::buffer_info info_preds = start_preds.request();
         float* preds_ptr = static_cast<float*>(info_preds.ptr);
-        int n_samples = info_preds.shape[0];
+        int n_samples = static_cast<int>(info_preds.shape[0]);
         self.predict(obs_ptr, cat_obs_ptr, preds_ptr, n_samples, n_num_features, n_cat_features, start_tree_idx, stop_tree_idx);  
     }, py::arg("obs"), py::arg("categorical_obs"), py::arg("start_preds"), py::arg("start_tree_idx")=0, py::arg("stop_tree_idx")=0, "Predict using the model");
         // saveToFile method

{gbrl-1.0.0.dev1 → gbrl-1.0.0.dev3}/gbrl/src/cpp/loss.cpp

@@ -6,7 +6,7 @@
 #include "loss.h"
 
 float MultiRMSE::get_loss_and_gradients(const float *raw_preds, const float *raw_targets, float *raw_grads, const int n_samples, const int output_dim){
-    float count_recip = 1.0 /  static_cast<float>(n_samples);
+    float count_recip = 1.0f /  static_cast<float>(n_samples);
     const int n_threads = static_cast<int>(omp_get_max_threads());
     int n_elements = n_samples*output_dim;
     int elements_per_thread = n_elements / n_threads;
@@ -34,7 +34,7 @@ float MultiRMSE::get_loss_and_gradients(const float *raw_preds, const float *raw
 }
 
 float MultiRMSE::get_loss(const float *raw_preds, const float *raw_targets, const int n_samples, const int output_dim){
-    float count_recip = 1.0 /  static_cast<float>(n_samples);
+    float count_recip = 1.0f /  static_cast<float>(n_samples);
     const int n_threads = static_cast<int>(omp_get_max_threads());
     int samples_per_thread = n_samples / n_threads;
     int row;

{gbrl-1.0.0.dev1 → gbrl-1.0.0.dev3}/gbrl/src/cpp/math_ops.cpp

@@ -73,14 +73,14 @@ void divide_mat_by_vec_inplace(float *mat, const float *vec, const int n_samples
             #pragma omp simd
             for (int i = start_idx; i < end_idx; ++i) {
                 int col = i % n_cols;
-                mat[i] /= (vec[col] + 1e-8); 
+                mat[i] /= (vec[col] + 1e-8f); 
             }
         }
     } else {
         #pragma omp simd
         for (int i = 0; i < n_elements; ++i) {
             int col = i % n_cols;
-            mat[i] /= (vec[col] + 1e-8);    
+            mat[i] /= (vec[col] + 1e-8f);    
         }
     }
 }
@@ -139,10 +139,10 @@ void multiply_mat_by_scalar(float *mat, float scalar, const int n_samples, const
 float* calculate_mean(const float *mat, const int n_samples, const int n_cols, const int par_th){
     int n_elements = n_samples * n_cols;
     float *mean = new float[n_cols];
-    float n_samples_recip = 1.0 / static_cast<float>(n_samples);
+    float n_samples_recip = 1.0f / static_cast<float>(n_samples);
     #pragma omp simd
     for (int d = 0; d < n_cols; ++d) 
-        mean[d] = 0;
+        mean[d] = 0.0f;
     int n_threads = calculate_num_threads(n_elements, par_th);
     if (n_threads > 1){
         omp_set_num_threads(n_threads);
@@ -150,7 +150,7 @@ float* calculate_mean(const float *mat, const int n_samples, const int n_cols, c
         float *thread_mean = new float[n_threads*n_cols];
         #pragma omp simd
         for (int d = 0; d < n_threads*n_cols; ++d) 
-            thread_mean[d] = 0;
+            thread_mean[d] = 0.0f;
         #pragma omp parallel
         {
             int thread_id = omp_get_thread_num();
@@ -244,9 +244,9 @@ float* calculate_row_covariance(const float *mat_l, const float *mat_r, const in
     float *cov = new float[n_cols];
     #pragma omp simd
     for (int d = 0; d < n_cols; ++d) 
-        cov[d] = 0;
+        cov[d] = 0.0f;
 
-    float n_samples_recip = 1.0 / (static_cast<float>(n_samples) - 1);
+    float n_samples_recip = 1.0f / (static_cast<float>(n_samples) - 1.0f);
 
     int n_threads = calculate_num_threads(n_elements, par_th);
     if (n_threads > 1){
@@ -255,7 +255,7 @@ float* calculate_row_covariance(const float *mat_l, const float *mat_r, const in
         float *thread_cov = new float[n_threads*n_cols];
         #pragma omp simd
         for (int d = 0; d < n_threads*n_cols; ++d) 
-            thread_cov[d] = 0;
+            thread_cov[d] = 0.0f;
         #pragma omp parallel
         {
             int thread_id = omp_get_thread_num();
@@ -291,7 +291,7 @@ float* calculate_row_covariance(const float *mat_l, const float *mat_r, const in
 float* calculate_var_and_center(float *mat, const float *mean, const int n_samples, const int n_cols, const int par_th){
     int n_elements = n_samples * n_cols;
     float *var = new float[n_cols];
-    float n_samples_recip = 1.0 / (static_cast<float>(n_samples) - 1);
+    float n_samples_recip = 1.0f / (static_cast<float>(n_samples) - 1.0f);
     float value;
 
     #pragma omp simd
@@ -305,7 +305,7 @@ float* calculate_var_and_center(float *mat, const float *mean, const int n_sampl
         float *thread_var = new float[n_threads*n_cols];
         #pragma omp simd
         for (int d = 0; d < n_threads*n_cols; ++d) 
-            thread_var[d] = 0;
+            thread_var[d] = 0.0f;
         #pragma omp parallel
         {
             int thread_id = omp_get_thread_num();
@@ -345,7 +345,7 @@ float* calculate_var_and_center(float *mat, const float *mean, const int n_sampl
 float* calculate_std_and_center(float *mat, const float *mean, const int n_samples, const int n_cols, const int par_th){
     int n_elements = n_samples * n_cols;
     float *var = new float[n_cols];
-    float n_samples_recip = 1.0 / (static_cast<float>(n_samples) - 1);
+    float n_samples_recip = 1.0f / (static_cast<float>(n_samples) - 1.0f);
     float value;
 
     #pragma omp simd
@@ -472,12 +472,12 @@ void set_zero_mat(float *mat, const int size, const int par_th){
             int end_idx = (thread_id == n_threads - 1) ? size : start_idx + elements_per_thread;
             #pragma omp simd
             for (int i = start_idx; i < end_idx; ++i)
-                mat[i] = 0;
+                mat[i] = 0.0f;
         }
      } else {
         #pragma omp simd
         for (int i = 0; i < size; ++i)
-            mat[i] = 0;
+            mat[i] = 0.0f;
     }
 }
 

{gbrl-1.0.0.dev1 → gbrl-1.0.0.dev3}/gbrl/src/cpp/node.cpp

@@ -163,7 +163,7 @@ float TreeNode::getSplitScore(dataSet *dataset, const float parent_score, scoreF
                 return this->splitScoreCosineCategorical(dataset->categorical_obs, dataset->build_grads, dataset->norm_grads, parent_score, split_candidate, min_data_in_leaf);
         }
         default: {
-            std::cerr << "Unknown scoreFunc!" << std::endl;
+            std::cerr << "Unknown scoreFunc." << std::endl;
             return -INFINITY;
         }
     }
@@ -225,7 +225,7 @@ float TreeNode::splitScoreCosine(const float *obs, const float *grads, const flo
 
 
     float left_count_f = static_cast<float>(left_count), right_count_f = static_cast<float>(right_count);
-    float left_count_recip = 1.0 / left_count_f, right_count_recip = 1.0 / right_count_f;
+    float left_count_recip = 1.0f / left_count_f, right_count_recip = 1.0f / right_count_f;
     #pragma omp simd
     for (int d = 0; d < n_cols; ++d){
         left_mean[d] *= left_count_recip;
@@ -299,7 +299,7 @@ float TreeNode::splitScoreCosineCategorical(const char *obs, const float *grads,
     
 
     float left_count_f = static_cast<float>(left_count), right_count_f = static_cast<float>(right_count);
-    float left_count_recip = 1.0 / left_count_f, right_count_recip = 1.0 / right_count_f;
+    float left_count_recip = 1.0f / left_count_f, right_count_recip = 1.0f / right_count_f;
     #pragma omp simd
     for (int d = 0; d < n_cols; ++d){
         left_mean[d] *= left_count_recip;
@@ -360,7 +360,7 @@ float TreeNode::splitScoreL2(const float *obs, const float *grads, const float p
     } 
 
     float left_count_f = static_cast<float>(left_count), right_count_f = static_cast<float>(right_count);
-    float left_count_recip = 1.0 / left_count, right_count_recip = 1.0 / right_count_f;
+    float left_count_recip = 1.0f / left_count, right_count_recip = 1.0f / right_count_f;
     #pragma omp simd
     for (int d = 0; d < n_cols; ++d){
         left_mean[d] *= left_count_recip;
@@ -415,7 +415,7 @@ float TreeNode::splitScoreL2Categorical(const char *obs, const float *grads, con
     } 
 
     float left_count_f = static_cast<float>(left_count), right_count_f = static_cast<float>(right_count);
-    float left_count_recip = 1.0 / left_count, right_count_recip = 1.0 / right_count_f;
+    float left_count_recip = 1.0f / left_count, right_count_recip = 1.0f / right_count_f;
     #pragma omp simd
     for (int d = 0; d < n_cols; ++d){
         left_mean[d] *= left_count_recip;