Add more install instructions of Boost to README

Add STree, Odte, SVC & RandomForest Classifiers
Remove using namespace ... in project

.vscode/launch.json

@@ -21,7 +21,7 @@
         {
             "type": "lldb",
             "request": "launch",
-            "name": "experiment",
+            "name": "experimentPy",
             "program": "${workspaceFolder}/build_debug/src/Platform/b_main",
             "args": [
                 "-m",
@@ -35,6 +35,23 @@
             ],
             "cwd": "/home/rmontanana/Code/discretizbench",
         },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "experimentBayes",
+            "program": "${workspaceFolder}/build_debug/src/Platform/b_main",
+            "args": [
+                "-m",
+                "TAN",
+                "--stratified",
+                "--discretize",
+                "-d",
+                "iris",
+                "--hyperparameters",
+                "{\"repeatSparent\": true, \"maxModels\": 12}"
+            ],
+            "cwd": "/home/rmontanana/Code/discretizbench",
+        },
         {
             "type": "lldb",
             "request": "launch",

README.md

@@ -18,12 +18,24 @@ The best option is install the packages that the Linux distribution have in its
 sudo dnf install boost-devel
 ```
 
-If this is not possible and the compressed packaged is installed, the following environment variable has to be set:
+If this is not possible and the compressed packaged is installed, the following environment variable has to be set pointing to the folder where it was unzipped to:
 
 ```bash
 export BOOST_ROOT=/path/to/library/
 ```
 
+In some cases, it is needed to build the library, to do so:
+
+```bash
+cd /path/to/library
+mkdir own
+./bootstrap.sh --prefix=/path/to/library/own
+./b2 install
+export BOOST_ROOT=/path/to/library/own/
+```
+
+Don't forget to add the export BOOST_ROOT statement to .bashrc or wherever it is meant to be.
+
 ### libxlswriter
 
 ```bash

grid_stree.json

@@ -0,0 +1,162 @@
+{
+    "balance-scale": {
+        "C": 10000.0,
+        "gamma": 0.1,
+        "kernel": "rbf",
+        "max_iter": 10000
+    },
+    "balloons": {
+        "C": 7,
+        "gamma": 0.1,
+        "kernel": "rbf",
+        "max_iter": 10000
+    },
+    "breast-cancer-wisc-diag": {
+        "C": 0.2,
+        "max_iter": 10000
+    },
+    "breast-cancer-wisc-prog": {
+        "C": 0.2,
+        "max_iter": 10000
+    },
+    "breast-cancer-wisc": {},
+    "breast-cancer": {},
+    "cardiotocography-10clases": {},
+    "cardiotocography-3clases": {},
+    "conn-bench-sonar-mines-rocks": {},
+    "cylinder-bands": {},
+    "dermatology": {
+        "C": 55,
+        "max_iter": 10000
+    },
+    "echocardiogram": {
+        "C": 7,
+        "gamma": 0.1,
+        "kernel": "poly",
+        "max_features": "auto",
+        "max_iter": 10000
+    },
+    "fertility": {
+        "C": 0.05,
+        "max_features": "auto",
+        "max_iter": 10000
+    },
+    "haberman-survival": {},
+    "heart-hungarian": {
+        "C": 0.05,
+        "max_iter": 10000
+    },
+    "hepatitis": {
+        "C": 7,
+        "gamma": 0.1,
+        "kernel": "rbf",
+        "max_iter": 10000
+    },
+    "ilpd-indian-liver": {},
+    "ionosphere": {
+        "C": 7,
+        "gamma": 0.1,
+        "kernel": "rbf",
+        "max_iter": 10000
+    },
+    "iris": {},
+    "led-display": {},
+    "libras": {
+        "C": 0.08,
+        "max_iter": 10000
+    },
+    "low-res-spect": {
+        "C": 0.05,
+        "max_iter": 10000
+    },
+    "lymphography": {
+        "C": 0.05,
+        "max_iter": 10000
+    },
+    "mammographic": {},
+    "molec-biol-promoter": {
+        "C": 0.05,
+        "gamma": 0.1,
+        "kernel": "poly",
+        "max_iter": 10000
+    },
+    "musk-1": {
+        "C": 0.05,
+        "gamma": 0.1,
+        "kernel": "poly",
+        "max_iter": 10000
+    },
+    "oocytes_merluccius_nucleus_4d": {
+        "C": 8.25,
+        "gamma": 0.1,
+        "kernel": "poly"
+    },
+    "oocytes_merluccius_states_2f": {},
+    "oocytes_trisopterus_nucleus_2f": {},
+    "oocytes_trisopterus_states_5b": {
+        "C": 0.11,
+        "max_iter": 10000
+    },
+    "parkinsons": {},
+    "pima": {},
+    "pittsburg-bridges-MATERIAL": {
+        "C": 7,
+        "gamma": 0.1,
+        "kernel": "rbf",
+        "max_iter": 10000
+    },
+    "pittsburg-bridges-REL-L": {},
+    "pittsburg-bridges-SPAN": {
+        "C": 0.05,
+        "max_iter": 10000
+    },
+    "pittsburg-bridges-T-OR-D": {},
+    "planning": {
+        "C": 7,
+        "gamma": 10.0,
+        "kernel": "rbf",
+        "max_iter": 10000
+    },
+    "post-operative": {
+        "C": 55,
+        "degree": 5,
+        "gamma": 0.1,
+        "kernel": "poly",
+        "max_iter": 10000
+    },
+    "seeds": {
+        "C": 10000.0,
+        "max_iter": 10000
+    },
+    "statlog-australian-credit": {
+        "C": 0.05,
+        "max_features": "auto",
+        "max_iter": 10000
+    },
+    "statlog-german-credit": {},
+    "statlog-heart": {},
+    "statlog-image": {
+        "C": 7,
+        "max_iter": 10000
+    },
+    "statlog-vehicle": {},
+    "synthetic-control": {
+        "C": 0.55,
+        "max_iter": 10000
+    },
+    "tic-tac-toe": {
+        "C": 0.2,
+        "gamma": 0.1,
+        "kernel": "poly",
+        "max_iter": 10000
+    },
+    "vertebral-column-2clases": {},
+    "wine": {
+        "C": 0.55,
+        "max_iter": 10000
+    },
+    "zoo": {
+        "C": 0.1,
+        "max_iter": 10000
+    }
+}

sample/sample.cc

@@ -4,7 +4,7 @@
 #include <map>
 #include <argparse/argparse.hpp>
 #include <nlohmann/json.hpp>
-#include "ArffFiles.h"v
+#include "ArffFiles.h"
 #include "BayesMetrics.h"
 #include "CPPFImdlp.h"
 #include "Folding.h"

src/BayesNet/BaseClassifier.h

@@ -6,8 +6,6 @@
 namespace bayesnet {
     enum status_t { NORMAL, WARNING, ERROR };
     class BaseClassifier {
-    protected:
-        virtual void trainModel(const torch::Tensor& weights) = 0;
     public:
         // X is nxm std::vector, y is nx1 std::vector
         virtual BaseClassifier& fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) = 0;
@@ -29,7 +27,11 @@ namespace bayesnet {
         virtual std::string getVersion() = 0;
         std::vector<std::string> virtual topological_order() = 0;
         void virtual dump_cpt()const = 0;
-        virtual void setHyperparameters(nlohmann::json& hyperparameters) = 0;
+        virtual void setHyperparameters(const nlohmann::json& hyperparameters) = 0;
+        std::vector<std::string>& getValidHyperparameters() { return validHyperparameters; }
+    protected:
+        virtual void trainModel(const torch::Tensor& weights) = 0;
+        std::vector<std::string> validHyperparameters;
     };
 }
 #endif

src/BayesNet/BoostAODE.cc

@@ -10,7 +10,11 @@
 #include "IWSS.h"
 
 namespace bayesnet {
-    BoostAODE::BoostAODE() : Ensemble() {}
+    BoostAODE::BoostAODE() : Ensemble()
+    {
+        validHyperparameters = { "repeatSparent", "maxModels", "ascending", "convergence", "threshold", "select_features" };
+
+    }
     void BoostAODE::buildModel(const torch::Tensor& weights)
     {
         // Models shall be built in trainModel
@@ -43,11 +47,8 @@ namespace bayesnet {
             y_train = y_;
         }
     }
-    void BoostAODE::setHyperparameters(nlohmann::json& hyperparameters)
+    void BoostAODE::setHyperparameters(const nlohmann::json& hyperparameters)
     {
-        // Check if hyperparameters are valid
-        const std::vector<std::string> validKeys = { "repeatSparent", "maxModels", "ascending", "convergence", "threshold", "select_features" };
-        checkHyperparameters(validKeys, hyperparameters);
         if (hyperparameters.contains("repeatSparent")) {
             repeatSparent = hyperparameters["repeatSparent"];
         }

src/BayesNet/BoostAODE.h

@@ -8,9 +8,9 @@ namespace bayesnet {
     class BoostAODE : public Ensemble {
     public:
         BoostAODE();
-        virtual ~BoostAODE() {};
+        virtual ~BoostAODE() = default;
         std::vector<std::string> graph(const std::string& title = "BoostAODE") const override;
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
+        void setHyperparameters(const nlohmann::json& hyperparameters) override;
     protected:
         void buildModel(const torch::Tensor& weights) override;
         void trainModel(const torch::Tensor& weights) override;

src/BayesNet/Classifier.cc

@@ -153,18 +153,8 @@ namespace bayesnet {
     {
         model.dump_cpt();
     }
-    void Classifier::checkHyperparameters(const std::vector<std::string>& validKeys, nlohmann::json& hyperparameters)
+    void Classifier::setHyperparameters(const nlohmann::json& hyperparameters)
     {
-        for (const auto& item : hyperparameters.items()) {
+        //For classifiers that don't have hyperparameters
-            if (find(validKeys.begin(), validKeys.end(), item.key()) == validKeys.end()) {
-                throw std::invalid_argument("Hyperparameter " + item.key() + " is not valid");
-            }
-        }
-    }
-    void Classifier::setHyperparameters(nlohmann::json& hyperparameters)
-    {
-        // Check if hyperparameters are valid, default is no hyperparameters
-        const std::vector<std::string> validKeys = { };
-        checkHyperparameters(validKeys, hyperparameters);
     }
 }

src/BayesNet/Classifier.h

@@ -22,7 +22,6 @@ namespace bayesnet {
         void checkFitParameters();
         virtual void buildModel(const torch::Tensor& weights) = 0;
         void trainModel(const torch::Tensor& weights) override;
-        void checkHyperparameters(const std::vector<std::string>& validKeys, nlohmann::json& hyperparameters);
         void buildDataset(torch::Tensor& y);
     public:
         Classifier(Network model);
@@ -44,7 +43,7 @@ namespace bayesnet {
         std::vector<std::string> show() const override;
         std::vector<std::string> topological_order()  override;
         void dump_cpt() const override;
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
+        void setHyperparameters(const nlohmann::json& hyperparameters) override; //For classifiers that don't have hyperparameters
     };
 }
 #endif

src/BayesNet/KDB.cc

@@ -1,12 +1,13 @@
 #include "KDB.h"
 
 namespace bayesnet {
-    KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta) {}
+    KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta)
-    void KDB::setHyperparameters(nlohmann::json& hyperparameters)
+    {
+        validHyperparameters = { "k", "theta" };
+
+    }
+    void KDB::setHyperparameters(const nlohmann::json& hyperparameters)
     {
-        // Check if hyperparameters are valid
-        const std::vector<std::string> validKeys = { "k", "theta" };
-        checkHyperparameters(validKeys, hyperparameters);
         if (hyperparameters.contains("k")) {
             k = hyperparameters["k"];
         }

src/BayesNet/KDB.h

@@ -13,8 +13,8 @@ namespace bayesnet {
         void buildModel(const torch::Tensor& weights) override;
     public:
         explicit KDB(int k, float theta = 0.03);
-        virtual ~KDB() {};
+        virtual ~KDB() = default;
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
+        void setHyperparameters(const nlohmann::json& hyperparameters) override;
         std::vector<std::string> graph(const std::string& name = "KDB") const override;
     };
 }

src/BayesNet/SPODE.h

@@ -10,7 +10,7 @@ namespace bayesnet {
         void buildModel(const torch::Tensor& weights) override;
     public:
         explicit SPODE(int root);
-        virtual ~SPODE() {};
+        virtual ~SPODE() = default;
         std::vector<std::string> graph(const std::string& name = "SPODE") const override;
     };
 }

src/BayesNet/TAN.h

@@ -8,7 +8,7 @@ namespace bayesnet {
         void buildModel(const torch::Tensor& weights) override;
     public:
         TAN();
-        virtual ~TAN() {};
+        virtual ~TAN() = default;
         std::vector<std::string> graph(const std::string& name = "TAN") const override;
     };
 }

src/Platform/CMakeLists.txt

@@ -8,7 +8,7 @@ include_directories(${BayesNet_SOURCE_DIR}/lib/json/include)
 include_directories(${BayesNet_SOURCE_DIR}/lib/libxlsxwriter/include)
 include_directories(${Python3_INCLUDE_DIRS})
 
-add_executable(b_main b_main.cc Folding.cc Experiment.cc Datasets.cc Dataset.cc Models.cc ReportConsole.cc ReportBase.cc)
+add_executable(b_main b_main.cc Folding.cc Experiment.cc Datasets.cc Dataset.cc Models.cc HyperParameters.cc ReportConsole.cc ReportBase.cc)
 add_executable(b_manage b_manage.cc Results.cc ManageResults.cc CommandParser.cc Result.cc ReportConsole.cc ReportExcel.cc ReportBase.cc Datasets.cc Dataset.cc ExcelFile.cc)
 add_executable(b_list b_list.cc Datasets.cc Dataset.cc)
 add_executable(b_best b_best.cc BestResults.cc Result.cc Statistics.cc BestResultsExcel.cc ReportExcel.cc ReportBase.cc Datasets.cc Dataset.cc ExcelFile.cc)

src/Platform/Experiment.cc

@@ -26,7 +26,6 @@ namespace platform {
         oss << std::put_time(timeinfo, "%H:%M:%S");
         return oss.str();
     }
-    Experiment::Experiment() : hyperparameters(json::parse("{}")) {}
     std::string Experiment::get_file_name()
     {
         std::string result = "results_" + score_name + "_" + model + "_" + platform + "_" + get_date() + "_" + get_time() + "_" + (stratified ? "1" : "0") + ".json";
@@ -148,7 +147,7 @@ namespace platform {
         auto result = Result();
         auto [values, counts] = at::_unique(y);
         result.setSamples(X.size(1)).setFeatures(X.size(0)).setClasses(values.size(0));
-        result.setHyperparameters(hyperparameters);
+        result.setHyperparameters(hyperparameters.get(fileName));
         // Initialize results std::vectors
         int nResults = nfolds * static_cast<int>(randomSeeds.size());
         auto accuracy_test = torch::zeros({ nResults }, torch::kFloat64);
@@ -171,9 +170,9 @@ namespace platform {
             for (int nfold = 0; nfold < nfolds; nfold++) {
                 auto clf = Models::instance()->create(model);
                 setModelVersion(clf->getVersion());
-                if (hyperparameters.size() != 0) {
+                auto valid = clf->getValidHyperparameters();
-                    clf->setHyperparameters(hyperparameters);
+                hyperparameters.check(valid, fileName);
-                }
+                clf->setHyperparameters(hyperparameters.get(fileName));
                 // Split train - test dataset
                 train_timer.start();
                 auto [train, test] = fold->getFold(nfold);

src/Platform/Experiment.h

@@ -6,6 +6,7 @@
 #include <chrono>
 #include "Folding.h"
 #include "BaseClassifier.h"
+#include "HyperParameters.h"
 #include "TAN.h"
 #include "KDB.h"
 #include "AODE.h"
@@ -80,17 +81,8 @@ namespace platform {
         const std::vector<double>& getTimesTest() const { return times_test; }
     };
     class Experiment {
-    private:
-        std::string title, model, platform, score_name, model_version, language_version, language;
-        bool discretized{ false }, stratified{ false };
-        std::vector<Result> results;
-        std::vector<int> randomSeeds;
-        json hyperparameters = "{}";
-        int nfolds{ 0 };
-        float duration{ 0 };
-        json build_json();
     public:
-        Experiment();
+        Experiment() = default;
         Experiment& setTitle(const std::string& title) { this->title = title; return *this; }
         Experiment& setModel(const std::string& model) { this->model = model; return *this; }
         Experiment& setPlatform(const std::string& platform) { this->platform = platform; return *this; }
@@ -104,13 +96,22 @@ namespace platform {
         Experiment& addResult(Result result) { results.push_back(result); return *this; }
         Experiment& addRandomSeed(int randomSeed) { randomSeeds.push_back(randomSeed); return *this; }
         Experiment& setDuration(float duration) { this->duration = duration; return *this; }
-        Experiment& setHyperparameters(const json& hyperparameters) { this->hyperparameters = hyperparameters; return *this; }
+        Experiment& setHyperparameters(const HyperParameters& hyperparameters_) { this->hyperparameters = hyperparameters_; return *this; }
         std::string get_file_name();
         void save(const std::string& path);
         void cross_validation(const std::string& fileName, bool quiet);
         void go(std::vector<std::string> filesToProcess, bool quiet);
         void show();
         void report();
+    private:
+        std::string title, model, platform, score_name, model_version, language_version, language;
+        bool discretized{ false }, stratified{ false };
+        std::vector<Result> results;
+        std::vector<int> randomSeeds;
+        HyperParameters hyperparameters;
+        int nfolds{ 0 };
+        float duration{ 0 };
+        json build_json();
     };
 }
 #endif

src/Platform/HyperParameters.cc

@@ -0,0 +1,55 @@
+#include "HyperParameters.h"
+#include <fstream>
+#include <sstream>
+#include <iostream>
+
+namespace platform {
+    HyperParameters::HyperParameters(const std::vector<std::string>& datasets, const json& hyperparameters_)
+    {
+        // Initialize all datasets with the given hyperparameters
+        for (const auto& item : datasets) {
+            hyperparameters[item] = hyperparameters_;
+        }
+    }
+    // https://www.techiedelight.com/implode-a-vector-of-strings-into-a-comma-separated-string-in-cpp/
+    std::string join(std::vector<std::string> const& strings, std::string delim)
+    {
+        std::stringstream ss;
+        std::copy(strings.begin(), strings.end(),
+            std::ostream_iterator<std::string>(ss, delim.c_str()));
+        return ss.str();
+    }
+    HyperParameters::HyperParameters(const std::vector<std::string>& datasets, const std::string& hyperparameters_file)
+    {
+        // Check if file exists
+        std::ifstream file(hyperparameters_file);
+        if (!file.is_open()) {
+            throw std::runtime_error("File " + hyperparameters_file + " not found");
+        }
+        // Check if file is a json
+        json input_hyperparameters = json::parse(file);
+        // Check if hyperparameters are valid
+        for (const auto& dataset : datasets) {
+            if (!input_hyperparameters.contains(dataset)) {
+                std::cerr << "*Warning: Dataset " << dataset << " not found in hyperparameters file" << " assuming default hyperparameters" << std::endl;
+                hyperparameters[dataset] = json({});
+                continue;
+            }
+            hyperparameters[dataset] = input_hyperparameters[dataset].get<json>();
+        }
+    }
+    void HyperParameters::check(const std::vector<std::string>& valid, const std::string& fileName)
+    {
+        json result = hyperparameters.at(fileName);
+        for (const auto& item : result.items()) {
+            if (find(valid.begin(), valid.end(), item.key()) == valid.end()) {
+                throw std::invalid_argument("Hyperparameter " + item.key() + " is not valid. Passed Hyperparameters are: "
+                    + result.dump(4) + "\n Valid hyperparameters are: {" + join(valid, ",") + "}");
+            }
+        }
+    }
+    json HyperParameters::get(const std::string& fileName)
+    {
+        return hyperparameters.at(fileName);
+    }
+} /* namespace platform */

src/Platform/HyperParameters.h

@@ -0,0 +1,23 @@
+#ifndef HYPERPARAMETERS_H
+#define HYPERPARAMETERS_H
+#include <string>
+#include <map>
+#include <vector>
+#include <nlohmann/json.hpp>
+
+namespace platform {
+    using json = nlohmann::json;
+    class HyperParameters {
+    public:
+        HyperParameters() = default;
+        explicit HyperParameters(const std::vector<std::string>& datasets, const json& hyperparameters_);
+        explicit HyperParameters(const std::vector<std::string>& datasets, const std::string& hyperparameters_file);
+        ~HyperParameters() = default;
+        bool notEmpty(const std::string& key) const { return !hyperparameters.at(key).empty(); }
+        void check(const std::vector<std::string>& valid, const std::string& fileName);
+        json get(const std::string& fileName);
+    private:
+        std::map<std::string, json> hyperparameters;
+    };
+} /* namespace platform */
+#endif /* HYPERPARAMETERS_H */

src/Platform/b_main.cc

@@ -16,7 +16,9 @@ argparse::ArgumentParser manageArguments()
     auto env = platform::DotEnv();
     argparse::ArgumentParser program("main");
     program.add_argument("-d", "--dataset").default_value("").help("Dataset file name");
-    program.add_argument("--hyperparameters").default_value("{}").help("Hyperparamters passed to the model in Experiment");
+    program.add_argument("--hyperparameters").default_value("{}").help("Hyperparameters passed to the model in Experiment");
+    program.add_argument("--hyper-file").default_value("").help("Hyperparameters file name." \
+        "Mutually exclusive with hyperparameters. This file should contain hyperparameters for each dataset in json format.");
     program.add_argument("-m", "--model")
         .help("Model to use " + platform::Models::instance()->tostring())
         .action([](const std::string& value) {
@@ -53,7 +55,7 @@ argparse::ArgumentParser manageArguments()
 
 int main(int argc, char** argv)
 {
-    std::string file_name, model_name, title;
+    std::string file_name, model_name, title, hyperparameters_file;
     json hyperparameters_json;
     bool discretize_dataset, stratified, saveResults, quiet;
     std::vector<int> seeds;
@@ -71,6 +73,10 @@ int main(int argc, char** argv)
         seeds = program.get<std::vector<int>>("seeds");
         auto hyperparameters = program.get<std::string>("hyperparameters");
         hyperparameters_json = json::parse(hyperparameters);
+        hyperparameters_file = program.get<std::string>("hyper-file");
+        if (hyperparameters_file != "" && hyperparameters != "{}") {
+            throw runtime_error("hyperparameters and hyper_file are mutually exclusive");
+        }
         title = program.get<std::string>("title");
         if (title == "" && file_name == "") {
             throw runtime_error("title is mandatory if dataset is not provided");
@@ -96,6 +102,13 @@ int main(int argc, char** argv)
         filesToTest = datasets.getNames();
         saveResults = true;
     }
+    platform::HyperParameters test_hyperparams;
+    if (hyperparameters_file != "") {
+        test_hyperparams = platform::HyperParameters(datasets.getNames(), hyperparameters_file);
+    } else {
+        test_hyperparams = platform::HyperParameters(datasets.getNames(), hyperparameters_json);
+    }
+
     /*
      * Begin Processing
      */
@@ -104,7 +117,7 @@ int main(int argc, char** argv)
     experiment.setTitle(title).setLanguage("cpp").setLanguageVersion("14.0.3");
     experiment.setDiscretized(discretize_dataset).setModel(model_name).setPlatform(env.get("platform"));
     experiment.setStratified(stratified).setNFolds(n_folds).setScoreName("accuracy");
-    experiment.setHyperparameters(hyperparameters_json);
+    experiment.setHyperparameters(test_hyperparams);
     for (auto seed : seeds) {
         experiment.addRandomSeed(seed);
     }

src/PyClassifiers/ODTE.cc

@@ -1,15 +1,12 @@
 #include "ODTE.h"
 
 namespace pywrap {
+    ODTE::ODTE() : PyClassifier("odte", "Odte")
+    {
+        validHyperparameters = { "n_jobs", "n_estimators", "random_state" };
+    }
     std::string ODTE::graph()
     {
         return callMethodString("graph");
     }
-    void ODTE::setHyperparameters(nlohmann::json& hyperparameters)
-    {
-        // Check if hyperparameters are valid
-        const std::vector<std::string> validKeys = { "n_jobs", "n_estimators", "random_state" };
-        checkHyperparameters(validKeys, hyperparameters);
-        this->hyperparameters = hyperparameters;
-    }
 } /* namespace pywrap */

src/PyClassifiers/ODTE.h

@@ -6,10 +6,9 @@
 namespace pywrap {
     class ODTE : public PyClassifier {
     public:
-        ODTE() : PyClassifier("odte", "Odte") {};
+        ODTE();
         ~ODTE() = default;
         std::string graph();
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
     };
 } /* namespace pywrap */
 #endif /* ODTE_H */

src/PyClassifiers/PyClassifier.cc

@@ -81,19 +81,8 @@ namespace pywrap {
         float result = pyWrap->score(id, Xp, yp);
         return result;
     }
-    void PyClassifier::setHyperparameters(nlohmann::json& hyperparameters)
+    void PyClassifier::setHyperparameters(const nlohmann::json& hyperparameters)
     {
-        // Check if hyperparameters are valid, default is no hyperparameters
-        const std::vector<std::string> validKeys = { };
-        checkHyperparameters(validKeys, hyperparameters);
         this->hyperparameters = hyperparameters;
     }
-    void PyClassifier::checkHyperparameters(const std::vector<std::string>& validKeys, const nlohmann::json& hyperparameters)
-    {
-        for (const auto& item : hyperparameters.items()) {
-            if (find(validKeys.begin(), validKeys.end(), item.key()) == validKeys.end()) {
-                throw std::invalid_argument("Hyperparameter " + item.key() + " is not valid");
-            }
-        }
-    }
 } /* namespace pywrap */

src/PyClassifiers/PyClassifier.h

@@ -27,10 +27,10 @@ namespace pywrap {
         std::vector<int> predict(std::vector<std::vector<int >>& X) override { return std::vector<int>(); };
         float score(std::vector<std::vector<int>>& X, std::vector<int>& y) override { return 0.0; };
         float score(torch::Tensor& X, torch::Tensor& y) override;
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
         std::string version();
         std::string callMethodString(const std::string& method);
         std::string getVersion() override { return this->version(); };
+        // TODO: Implement these 3 methods
         int getNumberOfNodes()const override { return 0; };
         int getNumberOfEdges()const override { return 0; };
         int getNumberOfStates() const override { return 0; };
@@ -39,8 +39,8 @@ namespace pywrap {
         bayesnet::status_t getStatus() const override { return bayesnet::NORMAL; };
         std::vector<std::string> topological_order() override { return std::vector<std::string>(); }
         void dump_cpt() const override {};
+        void setHyperparameters(const nlohmann::json& hyperparameters) override;
     protected:
-        void checkHyperparameters(const std::vector<std::string>& validKeys, const nlohmann::json& hyperparameters);
         nlohmann::json hyperparameters;
         void trainModel(const torch::Tensor& weights) override {};
     private:

src/PyClassifiers/RandomForest.cc

@@ -1,11 +1,8 @@
 #include "RandomForest.h"
 
 namespace pywrap {
-    void RandomForest::setHyperparameters(nlohmann::json& hyperparameters)
+    RandomForest::RandomForest() : PyClassifier("sklearn.ensemble", "RandomForestClassifier", true)
     {
-        // Check if hyperparameters are valid
+        validHyperparameters = { "n_estimators", "n_jobs", "random_state" };
-        const std::vector<std::string> validKeys = { "n_estimators", "n_jobs", "random_state" };
-        checkHyperparameters(validKeys, hyperparameters);
-        this->hyperparameters = hyperparameters;
     }
 } /* namespace pywrap */

src/PyClassifiers/RandomForest.h

@@ -5,9 +5,8 @@
 namespace pywrap {
     class RandomForest : public PyClassifier {
     public:
-        RandomForest() : PyClassifier("sklearn.ensemble", "RandomForestClassifier", true) {};
+        RandomForest();
         ~RandomForest() = default;
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
     };
 } /* namespace pywrap */
 #endif /* RANDOMFOREST_H */

src/PyClassifiers/STree.cc

@@ -1,15 +1,12 @@
 #include "STree.h"
 
 namespace pywrap {
+    STree::STree() : PyClassifier("stree", "Stree")
+    {
+        validHyperparameters = { "C", "kernel", "max_iter", "max_depth", "random_state", "multiclass_strategy", "gamma", "max_features", "degree" };
+    };
     std::string STree::graph()
     {
         return callMethodString("graph");
     }
-    void STree::setHyperparameters(nlohmann::json& hyperparameters)
-    {
-        // Check if hyperparameters are valid
-        const std::vector<std::string> validKeys = { "C", "kernel", "max_iter", "max_depth", "random_state", "multiclass_strategy" };
-        checkHyperparameters(validKeys, hyperparameters);
-        this->hyperparameters = hyperparameters;
-    }
 } /* namespace pywrap */

src/PyClassifiers/STree.h

@@ -6,10 +6,9 @@
 namespace pywrap {
     class STree : public PyClassifier {
     public:
-        STree() : PyClassifier("stree", "Stree") {};
+        STree();
         ~STree() = default;
         std::string graph();
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
     };
 } /* namespace pywrap */
 #endif /* STREE_H */

src/PyClassifiers/SVC.cc

@@ -1,11 +1,8 @@
 #include "SVC.h"
 
 namespace pywrap {
-    void SVC::setHyperparameters(nlohmann::json& hyperparameters)
+    SVC::SVC() : PyClassifier("sklearn.svm", "SVC", true)
     {
-        // Check if hyperparameters are valid
+        validHyperparameters = { "C", "gamma", "kernel", "random_state" };
-        const std::vector<std::string> validKeys = { "C", "gamma", "kernel", "random_state" };
-        checkHyperparameters(validKeys, hyperparameters);
-        this->hyperparameters = hyperparameters;
     }
 } /* namespace pywrap */

src/PyClassifiers/SVC.h

@@ -5,10 +5,9 @@
 namespace pywrap {
     class SVC : public PyClassifier {
     public:
-        SVC() : PyClassifier("sklearn.svm", "SVC", true) {};
+        SVC();
         ~SVC() = default;
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
     };
 
 } /* namespace pywrap */
-#endif /* STREE_H */
+#endif /* SVC_H */

stree_results.json

@@ -0,0 +1,835 @@
+[
+  {
+    "date": "2021-04-11",
+    "time": "18:46:29",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "balance-scale",
+    "accuracy": "0.97056",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 10000.0, \"gamma\": 0.1, \"kernel\": \"rbf\", \"max_iter\": 10000.0}",
+    "time_spent": "0.0135214",
+    "time_spent_std": "0.00111213",
+    "accuracy_std": "0.0150468",
+    "nodes": "7.0",
+    "leaves": "4.0",
+    "depth": "3.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:46:29",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "balloons",
+    "accuracy": "0.86",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 7, \"gamma\": 0.1, \"kernel\": \"rbf\", \"max_iter\": 10000.0}",
+    "time_spent": "0.000804768",
+    "time_spent_std": "7.74797e-05",
+    "accuracy_std": "0.285015",
+    "nodes": "3.0",
+    "leaves": "2.0",
+    "depth": "2.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:46:29",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "breast-cancer-wisc-diag",
+    "accuracy": "0.972764",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.2, \"max_iter\": 10000.0}",
+    "time_spent": "0.00380772",
+    "time_spent_std": "0.000638676",
+    "accuracy_std": "0.0173132",
+    "nodes": "3.24",
+    "leaves": "2.12",
+    "depth": "2.12"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:46:30",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "breast-cancer-wisc-prog",
+    "accuracy": "0.811128",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.2, \"max_iter\": 10000.0}",
+    "time_spent": "0.00767535",
+    "time_spent_std": "0.00148114",
+    "accuracy_std": "0.0584601",
+    "nodes": "5.84",
+    "leaves": "3.42",
+    "depth": "3.24"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:46:31",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "breast-cancer-wisc",
+    "accuracy": "0.966661",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.00652217",
+    "time_spent_std": "0.000726579",
+    "accuracy_std": "0.0139421",
+    "nodes": "8.88",
+    "leaves": "4.94",
+    "depth": "4.08"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:46:32",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "breast-cancer",
+    "accuracy": "0.734211",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.023475",
+    "time_spent_std": "0.00584447",
+    "accuracy_std": "0.0479774",
+    "nodes": "21.72",
+    "leaves": "11.36",
+    "depth": "5.86"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:49:08",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "cardiotocography-10clases",
+    "accuracy": "0.791487",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "3.10582",
+    "time_spent_std": "0.339218",
+    "accuracy_std": "0.0192082",
+    "nodes": "160.76",
+    "leaves": "80.88",
+    "depth": "22.86"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:01",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "cardiotocography-3clases",
+    "accuracy": "0.900613",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "1.05228",
+    "time_spent_std": "0.138768",
+    "accuracy_std": "0.0154004",
+    "nodes": "47.68",
+    "leaves": "24.34",
+    "depth": "8.84"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:01",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "conn-bench-sonar-mines-rocks",
+    "accuracy": "0.755528",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.011577",
+    "time_spent_std": "0.00341148",
+    "accuracy_std": "0.0678424",
+    "nodes": "6.08",
+    "leaves": "3.54",
+    "depth": "2.86"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:17",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "cylinder-bands",
+    "accuracy": "0.715049",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.301143",
+    "time_spent_std": "0.109773",
+    "accuracy_std": "0.0367646",
+    "nodes": "26.2",
+    "leaves": "13.6",
+    "depth": "6.82"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:19",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "dermatology",
+    "accuracy": "0.971833",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 55, \"max_iter\": 10000.0}",
+    "time_spent": "0.0377538",
+    "time_spent_std": "0.010726",
+    "accuracy_std": "0.0206883",
+    "nodes": "11.0",
+    "leaves": "6.0",
+    "depth": "6.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:19",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "echocardiogram",
+    "accuracy": "0.814758",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 7, \"gamma\": 0.1, \"kernel\": \"poly\", \"max_features\": \"auto\", \"max_iter\": 10000.0}",
+    "time_spent": "0.00333449",
+    "time_spent_std": "0.000964686",
+    "accuracy_std": "0.0998078",
+    "nodes": "7.0",
+    "leaves": "4.0",
+    "depth": "3.54"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:20",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "fertility",
+    "accuracy": "0.88",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.05, \"max_features\": \"auto\", \"max_iter\": 10000.0}",
+    "time_spent": "0.00090271",
+    "time_spent_std": "8.96446e-05",
+    "accuracy_std": "0.0547723",
+    "nodes": "1.0",
+    "leaves": "1.0",
+    "depth": "1.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:21",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "haberman-survival",
+    "accuracy": "0.735637",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.0171611",
+    "time_spent_std": "0.00334945",
+    "accuracy_std": "0.0434614",
+    "nodes": "23.4",
+    "leaves": "12.2",
+    "depth": "5.98"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:21",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "heart-hungarian",
+    "accuracy": "0.827522",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.05, \"max_iter\": 10000.0}",
+    "time_spent": "0.00493946",
+    "time_spent_std": "0.000738198",
+    "accuracy_std": "0.0505283",
+    "nodes": "10.16",
+    "leaves": "5.58",
+    "depth": "4.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:21",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "hepatitis",
+    "accuracy": "0.824516",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 7, \"gamma\": 0.1, \"kernel\": \"rbf\", \"max_iter\": 10000.0}",
+    "time_spent": "0.0021534",
+    "time_spent_std": "0.000133715",
+    "accuracy_std": "0.0738872",
+    "nodes": "3.0",
+    "leaves": "2.0",
+    "depth": "2.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:23",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "ilpd-indian-liver",
+    "accuracy": "0.723498",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.0345243",
+    "time_spent_std": "0.015789",
+    "accuracy_std": "0.0384886",
+    "nodes": "16.04",
+    "leaves": "8.52",
+    "depth": "5.28"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:24",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "ionosphere",
+    "accuracy": "0.953276",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 7, \"gamma\": 0.1, \"kernel\": \"rbf\", \"max_iter\": 10000.0}",
+    "time_spent": "0.00881722",
+    "time_spent_std": "0.000843108",
+    "accuracy_std": "0.0238537",
+    "nodes": "3.16",
+    "leaves": "2.08",
+    "depth": "2.08"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:24",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "iris",
+    "accuracy": "0.965333",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.00357342",
+    "time_spent_std": "0.000400509",
+    "accuracy_std": "0.0319444",
+    "nodes": "5.0",
+    "leaves": "3.0",
+    "depth": "3.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:50:36",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "led-display",
+    "accuracy": "0.703",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.222106",
+    "time_spent_std": "0.0116922",
+    "accuracy_std": "0.0291204",
+    "nodes": "47.16",
+    "leaves": "24.08",
+    "depth": "17.76"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:51:18",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "libras",
+    "accuracy": "0.788611",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.08, \"max_iter\": 10000.0}",
+    "time_spent": "0.841714",
+    "time_spent_std": "0.0830966",
+    "accuracy_std": "0.0516913",
+    "nodes": "82.28",
+    "leaves": "41.64",
+    "depth": "28.84"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:51:41",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "low-res-spect",
+    "accuracy": "0.883782",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.05, \"max_iter\": 10000.0}",
+    "time_spent": "0.446301",
+    "time_spent_std": "0.0411822",
+    "accuracy_std": "0.0324593",
+    "nodes": "27.4",
+    "leaves": "14.2",
+    "depth": "10.74"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:51:41",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "lymphography",
+    "accuracy": "0.835034",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.05, \"max_iter\": 10000.0}",
+    "time_spent": "0.00539465",
+    "time_spent_std": "0.000754365",
+    "accuracy_std": "0.0590649",
+    "nodes": "9.04",
+    "leaves": "5.02",
+    "depth": "4.48"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:51:43",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "mammographic",
+    "accuracy": "0.81915",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.0227931",
+    "time_spent_std": "0.00328533",
+    "accuracy_std": "0.0222517",
+    "nodes": "7.4",
+    "leaves": "4.2",
+    "depth": "4.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:51:43",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "molec-biol-promoter",
+    "accuracy": "0.767056",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.05, \"gamma\": 0.1, \"kernel\": \"poly\", \"max_iter\": 10000.0}",
+    "time_spent": "0.00130273",
+    "time_spent_std": "0.000105772",
+    "accuracy_std": "0.0910923",
+    "nodes": "3.0",
+    "leaves": "2.0",
+    "depth": "2.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:51:44",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "musk-1",
+    "accuracy": "0.916388",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.05, \"gamma\": 0.1, \"kernel\": \"poly\", \"max_iter\": 10000.0}",
+    "time_spent": "0.0116367",
+    "time_spent_std": "0.000331845",
+    "accuracy_std": "0.0275208",
+    "nodes": "3.0",
+    "leaves": "2.0",
+    "depth": "2.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:51:55",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "oocytes_merluccius_nucleus_4d",
+    "accuracy": "0.835125",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 8.25, \"gamma\": 0.1, \"kernel\": \"poly\"}",
+    "time_spent": "0.208895",
+    "time_spent_std": "0.0270573",
+    "accuracy_std": "0.0220961",
+    "nodes": "10.52",
+    "leaves": "5.76",
+    "depth": "4.42"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:04",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "oocytes_merluccius_states_2f",
+    "accuracy": "0.915365",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.182198",
+    "time_spent_std": "0.0294267",
+    "accuracy_std": "0.020396",
+    "nodes": "18.04",
+    "leaves": "9.52",
+    "depth": "5.3"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:41",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "oocytes_trisopterus_nucleus_2f",
+    "accuracy": "0.800986",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.717113",
+    "time_spent_std": "0.209608",
+    "accuracy_std": "0.0218449",
+    "nodes": "29.88",
+    "leaves": "15.44",
+    "depth": "7.38"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:44",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "oocytes_trisopterus_states_5b",
+    "accuracy": "0.922249",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.11, \"max_iter\": 10000.0}",
+    "time_spent": "0.0545047",
+    "time_spent_std": "0.00853014",
+    "accuracy_std": "0.0179203",
+    "nodes": "7.44",
+    "leaves": "4.22",
+    "depth": "3.6"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:44",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "parkinsons",
+    "accuracy": "0.882051",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.00795048",
+    "time_spent_std": "0.00176761",
+    "accuracy_std": "0.0478327",
+    "nodes": "8.48",
+    "leaves": "4.74",
+    "depth": "3.76"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:48",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "pima",
+    "accuracy": "0.766651",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.0750048",
+    "time_spent_std": "0.0213995",
+    "accuracy_std": "0.0297203",
+    "nodes": "17.4",
+    "leaves": "9.2",
+    "depth": "5.66"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:48",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "pittsburg-bridges-MATERIAL",
+    "accuracy": "0.867749",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 7, \"gamma\": 0.1, \"kernel\": \"rbf\", \"max_iter\": 10000.0}",
+    "time_spent": "0.00293318",
+    "time_spent_std": "0.000331469",
+    "accuracy_std": "0.0712226",
+    "nodes": "5.16",
+    "leaves": "3.08",
+    "depth": "3.02"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:49",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "pittsburg-bridges-REL-L",
+    "accuracy": "0.632238",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.0136311",
+    "time_spent_std": "0.00322964",
+    "accuracy_std": "0.101211",
+    "nodes": "16.32",
+    "leaves": "8.66",
+    "depth": "5.96"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:50",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "pittsburg-bridges-SPAN",
+    "accuracy": "0.659766",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.05, \"max_iter\": 10000.0}",
+    "time_spent": "0.00524256",
+    "time_spent_std": "0.00158822",
+    "accuracy_std": "0.1165",
+    "nodes": "9.84",
+    "leaves": "5.42",
+    "depth": "4.58"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:50",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "pittsburg-bridges-T-OR-D",
+    "accuracy": "0.861619",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.00295627",
+    "time_spent_std": "0.000578594",
+    "accuracy_std": "0.0693747",
+    "nodes": "4.56",
+    "leaves": "2.78",
+    "depth": "2.68"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:50",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "planning",
+    "accuracy": "0.73527",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 7, \"gamma\": 10.0, \"kernel\": \"rbf\", \"max_iter\": 10000.0}",
+    "time_spent": "0.0030475",
+    "time_spent_std": "0.000172266",
+    "accuracy_std": "0.0669776",
+    "nodes": "3.0",
+    "leaves": "2.0",
+    "depth": "2.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:51",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "post-operative",
+    "accuracy": "0.711111",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 55, \"degree\": 5, \"gamma\": 0.1, \"kernel\": \"poly\", \"max_iter\": 10000.0}",
+    "time_spent": "0.0018727",
+    "time_spent_std": "0.000481977",
+    "accuracy_std": "0.0753592",
+    "nodes": "2.64",
+    "leaves": "1.82",
+    "depth": "1.82"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:52",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "seeds",
+    "accuracy": "0.952857",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 10000.0, \"max_iter\": 10000.0}",
+    "time_spent": "0.0203492",
+    "time_spent_std": "0.00518065",
+    "accuracy_std": "0.0279658",
+    "nodes": "9.88",
+    "leaves": "5.44",
+    "depth": "4.44"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:52:52",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "statlog-australian-credit",
+    "accuracy": "0.678261",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.05, \"max_features\": \"auto\", \"max_iter\": 10000.0}",
+    "time_spent": "0.00205337",
+    "time_spent_std": "0.00083162",
+    "accuracy_std": "0.0390498",
+    "nodes": "1.32",
+    "leaves": "1.16",
+    "depth": "1.16"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:53:07",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "statlog-german-credit",
+    "accuracy": "0.7625",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.290754",
+    "time_spent_std": "0.0653152",
+    "accuracy_std": "0.0271892",
+    "nodes": "21.24",
+    "leaves": "11.12",
+    "depth": "6.18"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:53:09",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "statlog-heart",
+    "accuracy": "0.822963",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.0138923",
+    "time_spent_std": "0.00323664",
+    "accuracy_std": "0.044004",
+    "nodes": "14.56",
+    "leaves": "7.78",
+    "depth": "5.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:56:43",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "statlog-image",
+    "accuracy": "0.955931",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 7, \"max_iter\": 10000.0}",
+    "time_spent": "4.27584",
+    "time_spent_std": "0.200362",
+    "accuracy_std": "0.00956073",
+    "nodes": "36.92",
+    "leaves": "18.96",
+    "depth": "10.8"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:56:57",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "statlog-vehicle",
+    "accuracy": "0.793028",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.278833",
+    "time_spent_std": "0.0392173",
+    "accuracy_std": "0.030104",
+    "nodes": "23.88",
+    "leaves": "12.44",
+    "depth": "7.06"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:57:07",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "synthetic-control",
+    "accuracy": "0.95",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.55, \"max_iter\": 10000.0}",
+    "time_spent": "0.205184",
+    "time_spent_std": "0.040793",
+    "accuracy_std": "0.0253859",
+    "nodes": "12.48",
+    "leaves": "6.74",
+    "depth": "6.5"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:57:08",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "tic-tac-toe",
+    "accuracy": "0.984444",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.2, \"gamma\": 0.1, \"kernel\": \"poly\", \"max_iter\": 10000.0}",
+    "time_spent": "0.0123015",
+    "time_spent_std": "0.000423728",
+    "accuracy_std": "0.00838747",
+    "nodes": "3.0",
+    "leaves": "2.0",
+    "depth": "2.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:57:09",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "vertebral-column-2clases",
+    "accuracy": "0.852903",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{}",
+    "time_spent": "0.00576833",
+    "time_spent_std": "0.000910332",
+    "accuracy_std": "0.0408851",
+    "nodes": "6.04",
+    "leaves": "3.52",
+    "depth": "3.34"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:57:09",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "wine",
+    "accuracy": "0.979159",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.55, \"max_iter\": 10000.0}",
+    "time_spent": "0.0019741",
+    "time_spent_std": "0.000137745",
+    "accuracy_std": "0.022427",
+    "nodes": "5.0",
+    "leaves": "3.0",
+    "depth": "3.0"
+  },
+  {
+    "date": "2021-04-11",
+    "time": "18:57:10",
+    "type": "crossval",
+    "classifier": "stree",
+    "dataset": "zoo",
+    "accuracy": "0.957524",
+    "norm": 1,
+    "stand": 0,
+    "parameters": "{\"C\": 0.1, \"max_iter\": 10000.0}",
+    "time_spent": "0.00556221",
+    "time_spent_std": "0.000230106",
+    "accuracy_std": "0.0454615",
+    "nodes": "13.04",
+    "leaves": "7.02",
+    "depth": "7.02"
+  }
+]