gbrl 1.0.0.dev6__tar.gz → 1.0.0.dev7__tar.gz

{gbrl-1.0.0.dev6/gbrl.egg-info → gbrl-1.0.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gbrl
-Version: 1.0.0.dev6
+Version: 1.0.0.dev7
 Summary: Gradient Boosted Trees for RL
 Author-email: Benjamin Fuhrer <bfuhrer@nvidia.com>, Chen Tessler <ctessler@nvidia.com>, Gal Dalal <galal@nvidia.com>
 Classifier: Development Status :: 4 - Beta
@@ -33,10 +33,11 @@ GBRL is a Python-based GBT library designed and optimized for reinforcement lear
 ## Getting started
 
 ### Dependencies 
+#### MAC OS 
+```
 llvm
 openmp
-
-#### MAC OS 
+```
 
 Make sure to run:
 ```

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7}/README.md

@@ -11,10 +11,11 @@ GBRL is a Python-based GBT library designed and optimized for reinforcement lear
 ## Getting started
 
 ### Dependencies 
+#### MAC OS 
+```
 llvm
 openmp
-
-#### MAC OS 
+```
 
 Make sure to run:
 ```

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7}/gbrl/gbrl_wrapper.py

@@ -126,6 +126,16 @@ class GBTWrapper:
         status = self.model.save(filename)
         assert status == 0, "Failed to save model"
 
+    def export(self, filename: str, modelname: str = None) -> None:
+        # exports model to C
+        filename = filename.rstrip('.')
+        filename += '.h'
+        assert self.model is not None, "Can't export non-existent model!"
+        if modelname is None:
+            modelname = ""
+        status = self.model.export(filename, modelname)
+        assert status == 0, "Failed to export model"
+
     @classmethod
     def load(cls, filename: str) -> "GBTWrapper":
         filename = filename.rstrip('.')
@@ -313,6 +323,10 @@ class SeparateActorCriticWrapper:
         self.policy_model.save(filename + '_policy')
         self.value_model.save(filename + '_value')
 
+    def export(self, filename: str) -> None:
+        self.policy_model.export(filename + '_policy')
+        self.value_model.export(filename + '_value')
+
     @classmethod
     def load(cls, filename: str) -> "SeparateActorCriticWrapper":
         instance = cls.__new__(cls)

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7}/gbrl/gbt.py

@@ -172,9 +172,24 @@ class GradientBoostingTrees:
         return self._model.get_num_trees()
         
 
-    def save_model(self, save_path: str=None) -> None:
+    def save_model(self, save_path: str) -> None:
+        """
+        Saves model to file
+
+        Args:
+            filename (str): Absolute path and name of save filename.
+        """
         self._model.save(save_path) 
 
+    def export_model(self, filename: str, modelname: str = None) -> None:
+        """
+        Exports model as a C-header file
+
+        Args:
+            filename (str): Absolute path and name of exported filename.
+        """
+        self._model.export(filename, modelname) 
+
     @classmethod
     def load_model(cls, load_name: str):
         instance = cls.__new__(cls)

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7}/gbrl/src/cpp/gbrl.cpp

@@ -682,6 +682,28 @@ float GBRL::fit(float *obs, char *categorical_obs, float *targets, int iteration
     return full_loss;   
 }
 
+int GBRL::exportModel(const std::string& filename, const std::string& modelname){
+    std::ofstream header_file(filename, std::ios::binary);
+    if (!header_file.is_open() || header_file.fail()) {
+        std::cerr << "Error opening file: " << filename << std::endl;
+        throw std::runtime_error("File opening error");
+        return -1;
+    }
+    if (this->metadata->grow_policy != OBLIVIOUS) {
+        std::cerr << "Export is supported only for Oblivious trees." << std::endl;
+        header_file.close();
+        return -1;
+    }
+    export_ensemble_data(header_file, modelname, this->edata, this->metadata, this->device, this->opts);
+    if (!header_file.good()) {
+        std::cerr << "Error occurred at writing time." << std::endl;
+        throw std::runtime_error("Writing to file error");
+        return -1;
+    }
+
+    header_file.close();
+    return 0;
+}
 
 int GBRL::saveToFile(const std::string& filename){
     std::ofstream file(filename, std::ios::binary);

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7}/gbrl/src/cpp/gbrl.h

@@ -30,6 +30,7 @@ class GBRL {
         void to_device(deviceType device);
         std::string get_device();
         int saveToFile(const std::string& filename);
+        int exportModel(const std::string& filename, const std::string& modelname);
         int loadFromFile(const std::string& filename);
 
         void step(const float *obs, const char *categorical_obs, float *grads, const int n_samples, const int n_num_features, const int n_cat_features);

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7}/gbrl/src/cpp/gbrl_binding.cpp

@@ -258,6 +258,10 @@ PYBIND11_MODULE(gbrl_cpp, m) {
         py::gil_scoped_release release; 
         return self.saveToFile(filename); 
     }, "Save the model to a file");
+    gbrl.def("export", [](GBRL &self, const std::string& filename, const std::string& modelname) -> int {
+        py::gil_scoped_release release; 
+        return self.exportModel(filename, modelname); 
+    }, py::arg("filename"), py::arg("modelname") = "", "Export model as a C-header file");
     gbrl.def("get_scheduler_lrs", [](GBRL &self) ->  std::tuple<float, float> {
         py::gil_scoped_release release; 
         return self.get_scheduler_lrs(); 

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7}/gbrl/src/cpp/types.cpp

@@ -6,6 +6,7 @@
 #include <stdexcept>
 
 #include "types.h"
+#include "optimizer.h"
 #ifdef USE_CUDA
 #include "cuda_types.h"
 #endif
@@ -282,6 +283,161 @@ void ensemble_data_dealloc(ensembleData *edata){
     delete edata;
 }
 
+void export_ensemble_data(std::ofstream& header_file, const std::string& model_name, ensembleData *edata, ensembleMetaData *metadata, deviceType device, std::vector<Optimizer*> opts)
+{
+    if (!header_file.is_open() || header_file.fail()) {
+        std::cerr << "Error file is not open for writing: " << std::endl;
+        throw std::runtime_error("Error opening header_file");
+    }
+    ensembleData *edata_cpu = nullptr;
+#ifdef USE_CUDA
+    if (device == gpu){
+        edata_cpu = ensemble_data_copy_gpu_cpu(metadata, edata);
+    }
+#endif 
+    if (device == cpu)
+        edata_cpu = edata;
+    
+    int binary_splits = 0;
+    for (int i  = 0; i < metadata->n_trees; ++i){
+        binary_splits += edata_cpu->depths[i];
+    }
+
+    for (size_t opt_idx = 0; opt_idx < opts.size(); ++opt_idx){
+        optimizerAlgo algo = opts[opt_idx]->getAlgo();
+        if (algo != SGD){
+            std::cerr << "Error. Can only export SGD optimizers" << std::endl;
+            return;
+        }
+    }
+
+    header_file << "#ifndef GBRL_MODEL_H\n";
+    header_file << "#define GBRL_MODEL_H\n\n";
+
+    
+    header_file << "/*\n";
+
+    if (!model_name.empty()) {
+           header_file << "###########################\n";
+        header_file << "model_name: " << model_name << "\n";
+    }
+    header_file << "###########################\n";
+    header_file << "n_leaves: " << metadata->n_leaves << ", ";
+    header_file << "n_trees: " << metadata->n_trees << ", ";
+    header_file << "max_trees: " << metadata->max_trees << ", ";
+    header_file << "max_leaves: " << metadata->max_leaves << ", ";
+    header_file << "max_trees_batch: " << metadata->max_trees_batch << ", ";
+    header_file << "max_leaves_batch: " << metadata->max_leaves_batch << ", ";
+    header_file << "output_dim: " << metadata->output_dim << ", ";
+    header_file << "policy_dim: " << metadata->policy_dim;
+    header_file << "\nmax_depth: " << metadata->max_depth << ", ";
+    header_file << "min_data_in_leaf: " << metadata->min_data_in_leaf << ", ";
+    header_file << "n_bins: " << metadata->n_bins << ", ";
+    header_file << "par_th: " << metadata->par_th << ", ";
+    header_file << "cv_beta: " << metadata->cv_beta << ", ";
+    header_file << "verbose: " << metadata->verbose << ", ";
+    header_file << "batch_size: " << metadata->batch_size << ", ";
+    header_file << "use_cv: " << metadata->use_cv;
+    header_file << "\nsplit_score_func: " << scoreFuncToString(metadata->split_score_func) << ", ";
+    header_file << "generator_type: " << generatorTypeToString(metadata->generator_type) << ", ";
+    header_file << "grow_policy: " << growPolicyToString(metadata->grow_policy) << ", ";
+    header_file << "n_num_features: " << metadata->n_num_features << ", ";
+    header_file << "n_cat_features: " << metadata->n_cat_features << ", ";
+    header_file << "iteration: " << metadata->iteration;
+    header_file << "\n*/\n";
+
+    header_file << "#define N_TREES " << metadata->n_trees << "\n";
+    header_file << "#define N_LEAVES " << metadata->n_leaves << "\n";
+    header_file << "#define BINARY_FEATURES " << binary_splits << "\n";
+    header_file << "#define N_OUTPUTS " << metadata->output_dim << "\n";
+    header_file << "#define N_FEATURES " << metadata->n_num_features  << "\n\n";
+
+    header_file << "static inline void gbrl_predict(float *results, const float *features){\n\n";
+    header_file << "\tunsigned int j, tree_idx, depth, current_depth, idx, leaf_ptr, cond_ptr;\n";
+    header_file << "\t/* Model data */\n";
+    header_file << "\tconst unsigned int depths[N_TREES] = {";
+    for (int i  = 0; i < metadata->n_trees; ++i){
+        header_file << edata_cpu->depths[i];
+        if (i < metadata->n_trees - 1)
+            header_file << ", ";
+    }
+    header_file << "};\n";
+    header_file << "\tconst float bias[N_OUTPUTS] = {";
+    for (int i  = 0; i < metadata->output_dim; ++i){
+        header_file << edata_cpu->bias[i];
+        if (i < metadata->output_dim - 1)
+            header_file << ", ";
+    }
+    header_file << "};\n";
+    header_file << "\tconst unsigned int feature_indices[BINARY_FEATURES] = {";
+    for (int i  = 0; i < binary_splits; ++i){
+        header_file << edata_cpu->feature_indices[i];
+        if (i < binary_splits - 1)
+            header_file << ", ";
+    }
+    header_file << "};\n";
+    header_file << "\tconst float feature_values[BINARY_FEATURES] = {";
+    for (int i  = 0; i < binary_splits; ++i){
+        header_file << edata_cpu->feature_values[i];
+        if (i < binary_splits - 1)
+            header_file << ", ";
+    }
+    header_file << "};\n";
+    header_file << "\tconst float leaf_values[N_LEAVES*N_OUTPUTS] = {";
+    int tree_idx = 0;
+    int limit_leaf_idx = edata_cpu->tree_indices[tree_idx];
+    float value;
+    for (int i  = 0; i < metadata->n_leaves; ++i){
+        if (i > limit_leaf_idx){
+            tree_idx += 1;
+            limit_leaf_idx = edata_cpu->tree_indices[tree_idx];
+        }
+        int value_idx = i*metadata->output_dim;
+        for (size_t opt_idx = 0; opt_idx < opts.size(); ++opt_idx){
+            for (int j=opts[opt_idx]->start_idx; j < opts[opt_idx]->end_idx; ++j){
+                value = -edata_cpu->values[value_idx + j] * opts[opt_idx]->scheduler->get_lr(tree_idx);
+                header_file << value;
+                if ((i < metadata->n_leaves - 1) || (j < metadata->output_dim - 1  && i == metadata->n_leaves - 1))
+                    header_file << ", ";
+            }
+        }
+    }
+    header_file << "};\n";
+    // header_file << "\tconst unsigned int tree_indices[N_TREES] = {";
+    // for (int i  = 0; i < metadata->n_trees; ++i){
+    //     header_file << edata_cpu->tree_indices[i];
+    //     if (i < metadata->n_trees - 1)
+    //         header_file << ", ";
+    // }
+    // header_file << "};\n";
+    header_file << "\tleaf_ptr = 0;\n";
+    header_file << "\tcond_ptr = 0;\n";
+    header_file << "\tunsigned char pass;\n";
+    header_file << "\tfor (tree_idx = 0; tree_idx < N_TREES; ++tree_idx)\n";
+    header_file << "\t{\n";
+    header_file << "\t\tcurrent_depth = depths[tree_idx];\n";
+    header_file << "\t\tidx = 0;\n";
+    header_file << "\t\tfor (depth = 0; depth < current_depth; ++depth){\n";
+    header_file << "\t\t\tpass = (unsigned char)(features[feature_indices[cond_ptr + depth]] > feature_values[cond_ptr + depth]);\n";
+    header_file << "\t\t\tidx |= (pass <<  (current_depth - 1 - depth));\n";
+    header_file << "\t\t}\n";
+    header_file << "\t\tfor (j = 0 ; j < N_OUTPUTS; j++)\n";
+    header_file << "\t\t\tresults[j] += leaf_values[(leaf_ptr + idx)*N_OUTPUTS + j];\n";
+    header_file << "\t\tleaf_ptr += (1 << current_depth);\n";
+    header_file << "\t\tcond_ptr += current_depth;\n";
+    header_file << "\t}\n";
+    header_file << "\tfor (j = 0 ; j < N_OUTPUTS; j++)\n";
+    header_file << "\t\tresults[j] += bias[j];\n";
+    header_file << "}\n";
+    header_file << "#endif\n";
+
+#ifdef USE_CUDA
+    if (device == gpu){
+        ensemble_data_dealloc(edata_cpu);
+    }
+#endif 
+}
+
 void save_ensemble_data(std::ofstream& file, ensembleData *edata, ensembleMetaData *metadata, deviceType device){
     if (!file.is_open() || file.fail()) {
         std::cerr << "Error file is not open for writing: " << std::endl;
@@ -338,6 +494,12 @@ void save_ensemble_data(std::ofstream& file, ensembleData *edata, ensembleMetaDa
     file.write(reinterpret_cast<char*>(&check), sizeof(NULL_CHECK));
     if (edata_cpu->categorical_values != nullptr)
         file.write(reinterpret_cast<char*>(edata_cpu->categorical_values), metadata->max_depth * sizes * sizeof(char) * MAX_CHAR_SIZE);
+
+#ifdef USE_CUDA
+    if (device == gpu){
+        ensemble_data_dealloc(edata_cpu);
+    }
+#endif 
 }
 
 ensembleData* load_ensemble_data(std::ifstream& file, ensembleMetaData *metadata){

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7}/gbrl/src/cpp/types.h

@@ -10,6 +10,7 @@
 #define TREES_BATCH  25000 // 100 K
 #define MAX_CHAR_SIZE 128
 
+class Optimizer;
 struct splitCondition {
     int feature_idx;
     float feature_value;
@@ -165,6 +166,7 @@ ensembleData* ensemble_copy_data_alloc(ensembleMetaData *metadata);
 ensembleData* copy_ensemble_data(ensembleData *other_edata, ensembleMetaData *metadata);
 void ensemble_data_dealloc(ensembleData *edata);
 void save_ensemble_data(std::ofstream& file, ensembleData *edata, ensembleMetaData *metadata, deviceType device);
+void export_ensemble_data(std::ofstream& header_file, const std::string& model_name, ensembleData *edata, ensembleMetaData *metadata, deviceType device, std::vector<Optimizer*> opts);
 ensembleData* load_ensemble_data(std::ifstream& file, ensembleMetaData *metadata);
 void allocate_ensemble_memory(ensembleMetaData *metadata, ensembleData *edata);
 #endif 

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7/gbrl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gbrl
-Version: 1.0.0.dev6
+Version: 1.0.0.dev7
 Summary: Gradient Boosted Trees for RL
 Author-email: Benjamin Fuhrer <bfuhrer@nvidia.com>, Chen Tessler <ctessler@nvidia.com>, Gal Dalal <galal@nvidia.com>
 Classifier: Development Status :: 4 - Beta
@@ -33,10 +33,11 @@ GBRL is a Python-based GBT library designed and optimized for reinforcement lear
 ## Getting started
 
 ### Dependencies 
+#### MAC OS 
+```
 llvm
 openmp
-
-#### MAC OS 
+```
 
 Make sure to run:
 ```

{gbrl-1.0.0.dev6 → gbrl-1.0.0.dev7}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gbrl"
-version = "1.0.0.dev6"
+version = "1.0.0.dev7"
 description = "Gradient Boosted Trees for RL"
 readme = { file = "README.md", content-type = "text/markdown" }
 authors = [