Upgrade models version and Add class diagram

Reviewed-on: https://gitea.rmontanana.es:11000/rmontanana/BayesNet/pulls/6

.clang-uml

@@ -0,0 +1,31 @@
+compilation_database_dir: build
+output_directory: puml
+diagrams:
+  BayesNet:
+    type: class
+    glob:
+      - src/BayesNet/*.cc
+      - src/Platform/*.cc
+    using_namespace: bayesnet
+    include:
+      namespaces:
+        - bayesnet
+        - platform
+    plantuml:
+      after:
+        - "note left of {{ alias(\"MyProjectMain\") }}: Main class of myproject library."
+  sequence:
+    type: sequence
+    glob:
+      - src/Platform/main.cc
+    combine_free_functions_into_file_participants: true
+    using_namespace:
+      - std
+      - bayesnet
+      - platform
+    include:
+      paths:
+        - src/BayesNet
+        - src/Platform
+    start_from:
+      - function: main(int,const char **)

.gitignore

@@ -35,3 +35,4 @@ build/
 *.dSYM/**
 cmake-build*/**
 .idea
+puml/**

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "lib/json"]
 	path = lib/json
 	url = https://github.com/nlohmann/json.git
+[submodule "lib/openXLSX"]
+	path = lib/openXLSX
+	url = https://github.com/troldal/OpenXLSX.git

.vscode/launch.json

@@ -10,7 +10,7 @@
                 "-d",
                 "iris",
                 "-m",
-                "KDB",
+                "TANLd",
                 "-s",
                 "271",
                 "-p",
@@ -25,15 +25,17 @@
             "program": "${workspaceFolder}/build/src/Platform/main",
             "args": [
                 "-m",
-                "BoostAODE",
+                "AODE",
                 "-p",
-                "/Users/rmontanana/Code/discretizbench/datasets",
+                "/home/rmontanana/Code/discretizbench/datasets",
-                "--discretize",
                 "--stratified",
                 "-d",
-                "iris"
+                "mfeat-morphological",
+                "--discretize"
+                // "--hyperparameters",
+                // "{\"repeatSparent\": true, \"maxModels\": 12}"
             ],
-            "cwd": "/Users/rmontanana/Code/discretizbench",
+            "cwd": "/home/rmontanana/Code/discretizbench",
         },
         {
             "type": "lldb",

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(BayesNet
-  VERSION 0.1.0
+  VERSION 0.2.0
   DESCRIPTION "Bayesian Network and basic classifiers Library."
   HOMEPAGE_URL "https://github.com/rmontanana/bayesnet"
   LANGUAGES CXX
@@ -30,7 +30,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")
 option(ENABLE_CLANG_TIDY "Enable to add clang tidy."              OFF)
 option(ENABLE_TESTING "Unit testing build"                        OFF)
 option(CODE_COVERAGE "Collect coverage from test library"         OFF)
-
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
 # CMakes modules
 # --------------
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
@@ -40,8 +40,7 @@ if (CODE_COVERAGE)
     enable_testing()
     include(CodeCoverage)
     MESSAGE("Code coverage enabled")
-    set(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
+    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -O0")
-    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
     SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
 endif (CODE_COVERAGE)
 
@@ -55,6 +54,7 @@ endif (ENABLE_CLANG_TIDY)
 add_git_submodule("lib/mdlp")
 add_git_submodule("lib/argparse")
 add_git_submodule("lib/json")
+add_git_submodule("lib/openXLSX")
 
 # Subdirectories
 # --------------

Makefile

@@ -11,6 +11,16 @@ setup: ## Install dependencies for tests and coverage
 		pip install gcovr; \
 	fi
 
+dest ?= ../discretizbench
+copy: ## Copy binary files to selected folder
+	@echo "Destination folder: $(dest)"
+	make build
+	@echo ">>> Copying files to $(dest)"
+	@cp build/src/Platform/main $(dest)
+	@cp build/src/Platform/list $(dest)
+	@cp build/src/Platform/manage $(dest)
+	@echo ">>> Done"
+
 dependency: ## Create a dependency graph diagram of the project (build/dependency.png)
 	cd build && cmake .. --graphviz=dependency.dot && dot -Tpng dependency.dot -o dependency.png
 
@@ -22,6 +32,9 @@ clean: ## Clean the debug info
 	find . -name "*.gcda" -print0 | xargs -0 rm
 	@echo ">>> Done";
 
+clang-uml: ## Create uml class and sequence diagrams
+	clang-uml -p --add-compile-flag -I /usr/lib/gcc/x86_64-redhat-linux/8/include/
+
 debug: ## Build a debug version of the project
 	@echo ">>> Building Debug BayesNet ...";
 	@if [ -d ./build ]; then rm -rf ./build; fi

TAN_iris.dot

@@ -1,12 +0,0 @@
-digraph BayesNet {
-label=<BayesNet >
-fontsize=30
-fontcolor=blue
-labelloc=t
-layout=circo
- class [shape=circle, fontcolor=red, fillcolor=lightblue, style=filled ] 
- class -> sepallength class -> sepalwidth class -> petallength class -> petalwidth petallength [shape=circle] 
- petallength -> sepallength petalwidth [shape=circle] 
- sepallength [shape=circle] 
- sepallength -> sepalwidth sepalwidth [shape=circle] 
- sepalwidth -> petalwidth }

data/_TAN_cpp_accuracy__.json

@@ -1 +0,0 @@
-null

sample/CMakeLists.txt

@@ -3,5 +3,6 @@ include_directories(${BayesNet_SOURCE_DIR}/src/BayesNet)
 include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
 include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
 include_directories(${BayesNet_SOURCE_DIR}/lib/argparse/include)
+include_directories(${BayesNet_SOURCE_DIR}/lib/json/include)
 add_executable(BayesNetSample sample.cc ${BayesNet_SOURCE_DIR}/src/Platform/Folding.cc ${BayesNet_SOURCE_DIR}/src/Platform/Models.cc) 
 target_link_libraries(BayesNetSample BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}")

sample/sample.cc

@@ -3,13 +3,14 @@
 #include <string>
 #include <map>
 #include <argparse/argparse.hpp>
+#include <nlohmann/json.hpp>
 #include "ArffFiles.h"
 #include "BayesMetrics.h"
 #include "CPPFImdlp.h"
 #include "Folding.h"
 #include "Models.h"
 #include "modelRegister.h"
-
+#include <fstream>
 
 using namespace std;
 
@@ -141,111 +142,96 @@ int main(int argc, char** argv)
     /*
     * Begin Processing
     */
-    auto ypred = torch::tensor({ 1,2,3,2,2,3,4,5,2,1 });
+    auto handler = ArffFiles();
-    auto y = torch::tensor({ 0,0,0,0,2,3,4,0,0,0 });
+    handler.load(complete_file_name, class_last);
-    auto weights = torch::ones({ 10 }, kDouble);
+    // Get Dataset X, y
-    auto mask = ypred == y;
+    vector<mdlp::samples_t>& X = handler.getX();
-    cout << "ypred:" << ypred << endl;
+    mdlp::labels_t& y = handler.getY();
-    cout << "y:" << y << endl;
+    // Get className & Features
-    cout << "weights:" << weights << endl;
+    auto className = handler.getClassName();
-    cout << "mask:" << mask << endl;
+    vector<string> features;
-    double value_to_add = 0.5;
+    auto attributes = handler.getAttributes();
-    weights += mask.to(torch::kDouble) * value_to_add;
+    transform(attributes.begin(), attributes.end(), back_inserter(features),
-    cout << "New weights:" << weights << endl;
+        [](const pair<string, string>& item) { return item.first; });
-    auto masked_weights = weights * mask.to(weights.dtype());
+    // Discretize Dataset
-    double sum_of_weights = masked_weights.sum().item<double>();
+    auto [Xd, maxes] = discretize(X, y, features);
-    cout << "Sum of weights: " << sum_of_weights << endl;
+    maxes[className] = *max_element(y.begin(), y.end()) + 1;
-    //weights.index_put_({ mask }, weights + 10);
+    map<string, vector<int>> states;
-    // auto handler = ArffFiles();
+    for (auto feature : features) {
-    // handler.load(complete_file_name, class_last);
+        states[feature] = vector<int>(maxes[feature]);
-    // // Get Dataset X, y
+    }
-    // vector<mdlp::samples_t>& X = handler.getX();
+    states[className] = vector<int>(maxes[className]);
-    // mdlp::labels_t& y = handler.getY();
+    auto clf = platform::Models::instance()->create(model_name);
-    // // Get className & Features
+    clf->fit(Xd, y, features, className, states);
-    // auto className = handler.getClassName();
+    if (dump_cpt) {
-    // vector<string> features;
+        cout << "--- CPT Tables ---" << endl;
-    // auto attributes = handler.getAttributes();
+        clf->dump_cpt();
-    // transform(attributes.begin(), attributes.end(), back_inserter(features),
+    }
-    //     [](const pair<string, string>& item) { return item.first; });
+    auto lines = clf->show();
-    // // Discretize Dataset
+    for (auto line : lines) {
-    // auto [Xd, maxes] = discretize(X, y, features);
+        cout << line << endl;
-    // maxes[className] = *max_element(y.begin(), y.end()) + 1;
+    }
-    // map<string, vector<int>> states;
+    cout << "--- Topological Order ---" << endl;
-    // for (auto feature : features) {
+    auto order = clf->topological_order();
-    //     states[feature] = vector<int>(maxes[feature]);
+    for (auto name : order) {
-    // }
+        cout << name << ", ";
-    // states[className] = vector<int>(maxes[className]);
+    }
-    // auto clf = platform::Models::instance()->create(model_name);
+    cout << "end." << endl;
-    // clf->fit(Xd, y, features, className, states);
+    auto score = clf->score(Xd, y);
-    // if (dump_cpt) {
+    cout << "Score: " << score << endl;
-    //     cout << "--- CPT Tables ---" << endl;
+    auto graph = clf->graph();
-    //     clf->dump_cpt();
+    auto dot_file = model_name + "_" + file_name;
-    // }
+    ofstream file(dot_file + ".dot");
-    // auto lines = clf->show();
+    file << graph;
-    // for (auto line : lines) {
+    file.close();
-    //     cout << line << endl;
+    cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << endl;
-    // }
+    cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << endl;
-    // cout << "--- Topological Order ---" << endl;
+    string stratified_string = stratified ? " Stratified" : "";
-    // auto order = clf->topological_order();
+    cout << nFolds << " Folds" << stratified_string << " Cross validation" << endl;
-    // for (auto name : order) {
+    cout << "==========================================" << endl;
-    //     cout << name << ", ";
+    torch::Tensor Xt = torch::zeros({ static_cast<int>(Xd.size()), static_cast<int>(Xd[0].size()) }, torch::kInt32);
-    // }
+    torch::Tensor yt = torch::tensor(y, torch::kInt32);
-    // cout << "end." << endl;
+    for (int i = 0; i < features.size(); ++i) {
-    // auto score = clf->score(Xd, y);
+        Xt.index_put_({ i, "..." }, torch::tensor(Xd[i], torch::kInt32));
-    // cout << "Score: " << score << endl;
+    }
-    // auto graph = clf->graph();
+    float total_score = 0, total_score_train = 0, score_train, score_test;
-    // auto dot_file = model_name + "_" + file_name;
+    platform::Fold* fold;
-    // ofstream file(dot_file + ".dot");
+    if (stratified)
-    // file << graph;
+        fold = new platform::StratifiedKFold(nFolds, y, seed);
-    // file.close();
+    else
-    // cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << endl;
+        fold = new platform::KFold(nFolds, y.size(), seed);
-    // cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << endl;
+    for (auto i = 0; i < nFolds; ++i) {
-    // string stratified_string = stratified ? " Stratified" : "";
+        auto [train, test] = fold->getFold(i);
-    // cout << nFolds << " Folds" << stratified_string << " Cross validation" << endl;
+        cout << "Fold: " << i + 1 << endl;
-    // cout << "==========================================" << endl;
+        if (tensors) {
-    // torch::Tensor Xt = torch::zeros({ static_cast<int>(Xd.size()), static_cast<int>(Xd[0].size()) }, torch::kInt32);
+            auto ttrain = torch::tensor(train, torch::kInt64);
-    // torch::Tensor yt = torch::tensor(y, torch::kInt32);
+            auto ttest = torch::tensor(test, torch::kInt64);
-    // for (int i = 0; i < features.size(); ++i) {
+            torch::Tensor Xtraint = torch::index_select(Xt, 1, ttrain);
-    //     Xt.index_put_({ i, "..." }, torch::tensor(Xd[i], torch::kInt32));
+            torch::Tensor ytraint = yt.index({ ttrain });
-    // }
+            torch::Tensor Xtestt = torch::index_select(Xt, 1, ttest);
-    // float total_score = 0, total_score_train = 0, score_train, score_test;
+            torch::Tensor ytestt = yt.index({ ttest });
-    // Fold* fold;
+            clf->fit(Xtraint, ytraint, features, className, states);
-    // if (stratified)
+            auto temp = clf->predict(Xtraint);
-    //     fold = new StratifiedKFold(nFolds, y, seed);
+            score_train = clf->score(Xtraint, ytraint);
-    // else
+            score_test = clf->score(Xtestt, ytestt);
-    //     fold = new KFold(nFolds, y.size(), seed);
+        } else {
-    // for (auto i = 0; i < nFolds; ++i) {
+            auto [Xtrain, ytrain] = extract_indices(train, Xd, y);
-    //     auto [train, test] = fold->getFold(i);
+            auto [Xtest, ytest] = extract_indices(test, Xd, y);
-    //     cout << "Fold: " << i + 1 << endl;
+            clf->fit(Xtrain, ytrain, features, className, states);
-    //     if (tensors) {
+            score_train = clf->score(Xtrain, ytrain);
-    //         auto ttrain = torch::tensor(train, torch::kInt64);
+            score_test = clf->score(Xtest, ytest);
-    //         auto ttest = torch::tensor(test, torch::kInt64);
+        }
-    //         torch::Tensor Xtraint = torch::index_select(Xt, 1, ttrain);
+        if (dump_cpt) {
-    //         torch::Tensor ytraint = yt.index({ ttrain });
+            cout << "--- CPT Tables ---" << endl;
-    //         torch::Tensor Xtestt = torch::index_select(Xt, 1, ttest);
+            clf->dump_cpt();
-    //         torch::Tensor ytestt = yt.index({ ttest });
+        }
-    //         clf->fit(Xtraint, ytraint, features, className, states);
+        total_score_train += score_train;
-    //         auto temp = clf->predict(Xtraint);
+        total_score += score_test;
-    //         score_train = clf->score(Xtraint, ytraint);
+        cout << "Score Train: " << score_train << endl;
-    //         score_test = clf->score(Xtestt, ytestt);
+        cout << "Score Test : " << score_test << endl;
-    //     } else {
+        cout << "-------------------------------------------------------------------------------" << endl;
-    //         auto [Xtrain, ytrain] = extract_indices(train, Xd, y);
+    }
-    //         auto [Xtest, ytest] = extract_indices(test, Xd, y);
+    cout << "**********************************************************************************" << endl;
-    //         clf->fit(Xtrain, ytrain, features, className, states);
+    cout << "Average Score Train: " << total_score_train / nFolds << endl;
-    //         score_train = clf->score(Xtrain, ytrain);
+    cout << "Average Score Test : " << total_score / nFolds << endl;return 0;
-    //         score_test = clf->score(Xtest, ytest);
-    //     }
-    //     if (dump_cpt) {
-    //         cout << "--- CPT Tables ---" << endl;
-    //         clf->dump_cpt();
-    //     }
-    //     total_score_train += score_train;
-    //     total_score += score_test;
-    //     cout << "Score Train: " << score_train << endl;
-    //     cout << "Score Test : " << score_test << endl;
-    //     cout << "-------------------------------------------------------------------------------" << endl;
-    // }
-    // cout << "**********************************************************************************" << endl;
-    // cout << "Average Score Train: " << total_score_train / nFolds << endl;
-    // cout << "Average Score Test : " << total_score / nFolds << endl;return 0;
 }

src/BayesNet/AODELd.cc

@@ -4,9 +4,9 @@
 namespace bayesnet {
     using namespace std;
     AODELd::AODELd() : Ensemble(), Proposal(dataset, features, className) {}
-    AODELd& AODELd::fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    AODELd& AODELd::fit(torch::Tensor& X_, torch::Tensor& y_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
     {
-        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
+        checkInput(X_, y_);
         features = features_;
         className = className_;
         Xf = X_;
@@ -26,6 +26,7 @@ namespace bayesnet {
             models.push_back(std::make_unique<SPODELd>(i));
         }
         n_models = models.size();
+        significanceModels = vector<double>(n_models, 1.0);
     }
     void AODELd::trainModel(const torch::Tensor& weights)
     {

src/BayesNet/AODELd.h

@@ -12,9 +12,9 @@ namespace bayesnet {
         void buildModel(const torch::Tensor& weights) override;
     public:
         AODELd();
-        AODELd& fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_) override;
+        AODELd& fit(torch::Tensor& X_, torch::Tensor& y_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_) override;
         virtual ~AODELd() = default;
-        vector<string> graph(const string& name = "AODE") const override;
+        vector<string> graph(const string& name = "AODELd") const override;
         static inline string version() { return "0.0.1"; };
     };
 }

src/BayesNet/BaseClassifier.h

@@ -1,6 +1,7 @@
 #ifndef BASE_H
 #define BASE_H
 #include <torch/torch.h>
+#include <nlohmann/json.hpp>
 #include <vector>
 namespace bayesnet {
     using namespace std;
@@ -9,11 +10,11 @@ namespace bayesnet {
         virtual void trainModel(const torch::Tensor& weights) = 0;
     public:
         // X is nxm vector, y is nx1 vector
-        virtual BaseClassifier& fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states) = 0;
+        virtual BaseClassifier& fit(vector<vector<int>>& X, vector<int>& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) = 0;
         // X is nxm tensor, y is nx1 tensor
-        virtual BaseClassifier& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) = 0;
+        virtual BaseClassifier& fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) = 0;
-        virtual BaseClassifier& fit(torch::Tensor& dataset, vector<string>& features, string className, map<string, vector<int>>& states) = 0;
+        virtual BaseClassifier& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states) = 0;
-        virtual BaseClassifier& fit(torch::Tensor& dataset, vector<string>& features, string className, map<string, vector<int>>& states, const torch::Tensor& weights) = 0;
+        virtual BaseClassifier& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights) = 0;
         virtual ~BaseClassifier() = default;
         torch::Tensor virtual predict(torch::Tensor& X) = 0;
         vector<int> virtual predict(vector<vector<int>>& X) = 0;
@@ -24,9 +25,10 @@ namespace bayesnet {
         int virtual getNumberOfStates() const = 0;
         vector<string> virtual show() const = 0;
         vector<string> virtual graph(const string& title = "") const = 0;
-        const string inline getVersion() const { return "0.1.0"; };
+        const string inline getVersion() const { return "0.2.0"; };
         vector<string> virtual topological_order() = 0;
         void virtual dump_cpt()const = 0;
+        virtual void setHyperparameters(nlohmann::json& hyperparameters) = 0;
     };
 }
 #endif

src/BayesNet/BayesMetrics.cc

@@ -21,25 +21,39 @@ namespace bayesnet {
         }
         samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
     }
-    vector<int> Metrics::SelectKBestWeighted(const torch::Tensor& weights, unsigned k)
+    vector<int> Metrics::SelectKBestWeighted(const torch::Tensor& weights, bool ascending, unsigned k)
     {
+        // Return the K Best features 
         auto n = samples.size(0) - 1;
         if (k == 0) {
             k = n;
         }
         // compute scores
-        scoresKBest.reserve(n);
+        scoresKBest.clear();
+        featuresKBest.clear();
         auto label = samples.index({ -1, "..." });
         for (int i = 0; i < n; ++i) {
             scoresKBest.push_back(mutualInformation(label, samples.index({ i, "..." }), weights));
             featuresKBest.push_back(i);
         }
         // sort & reduce scores and features
-        sort(featuresKBest.begin(), featuresKBest.end(), [&](int i, int j)
+        if (ascending) {
-            { return scoresKBest[i] > scoresKBest[j]; });
+            sort(featuresKBest.begin(), featuresKBest.end(), [&](int i, int j)
-        sort(scoresKBest.begin(), scoresKBest.end(), std::greater<double>());
+                { return scoresKBest[i] < scoresKBest[j]; });
-        featuresKBest.resize(k);
+            sort(scoresKBest.begin(), scoresKBest.end(), std::less<double>());
-        scoresKBest.resize(k);
+            if (k < n) {
+                for (int i = 0; i < n - k; ++i) {
+                    featuresKBest.erase(featuresKBest.begin());
+                    scoresKBest.erase(scoresKBest.begin());
+                }
+            }
+        } else {
+            sort(featuresKBest.begin(), featuresKBest.end(), [&](int i, int j)
+                { return scoresKBest[i] > scoresKBest[j]; });
+            sort(scoresKBest.begin(), scoresKBest.end(), std::greater<double>());
+            featuresKBest.resize(k);
+            scoresKBest.resize(k);
+        }
         return featuresKBest;
     }
     vector<double> Metrics::getScoresKBest() const
@@ -63,7 +77,6 @@ namespace bayesnet {
         auto source = vector<string>(features);
         source.push_back(className);
         auto combinations = doCombinations(source);
-        double totalWeight = weights.sum().item<double>();
         // Compute class prior
         auto margin = torch::zeros({ classNumStates }, torch::kFloat);
         for (int value = 0; value < classNumStates; ++value) {

src/BayesNet/BayesMetrics.h

@@ -21,7 +21,7 @@ namespace bayesnet {
         Metrics() = default;
         Metrics(const torch::Tensor& samples, const vector<string>& features, const string& className, const int classNumStates);
         Metrics(const vector<vector<int>>& vsamples, const vector<int>& labels, const vector<string>& features, const string& className, const int classNumStates);
-        vector<int> SelectKBestWeighted(const torch::Tensor& weights, unsigned k = 0);
+        vector<int> SelectKBestWeighted(const torch::Tensor& weights, bool ascending=false, unsigned k = 0);
         vector<double> getScoresKBest() const;
         double mutualInformation(const Tensor& firstFeature, const Tensor& secondFeature, const Tensor& weights);
         vector<float> conditionalEdgeWeights(vector<float>& weights); // To use in Python

src/BayesNet/BoostAODE.cc

@@ -1,4 +1,5 @@
 #include "BoostAODE.h"
+#include <set>
 #include "BayesMetrics.h"
 
 namespace bayesnet {
@@ -7,40 +8,48 @@ namespace bayesnet {
     {
         // Models shall be built in trainModel
     }
+    void BoostAODE::setHyperparameters(nlohmann::json& hyperparameters)
+    {
+        // Check if hyperparameters are valid
+        const vector<string> validKeys = { "repeatSparent", "maxModels", "ascending" };
+        checkHyperparameters(validKeys, hyperparameters);
+        if (hyperparameters.contains("repeatSparent")) {
+            repeatSparent = hyperparameters["repeatSparent"];
+        }
+        if (hyperparameters.contains("maxModels")) {
+            maxModels = hyperparameters["maxModels"];
+        }
+        if (hyperparameters.contains("ascending")) {
+            ascending = hyperparameters["ascending"];
+        }
+    }
     void BoostAODE::trainModel(const torch::Tensor& weights)
     {
         models.clear();
         n_models = 0;
-        int max_models = .1 * n > 10 ? .1 * n : n;
+        if (maxModels == 0)
+            maxModels = .1 * n > 10 ? .1 * n : n;
         Tensor weights_ = torch::full({ m }, 1.0 / m, torch::kFloat64);
         auto X_ = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), "..." });
         auto y_ = dataset.index({ -1, "..." });
         bool exitCondition = false;
-        bool repeatSparent = false;
+        unordered_set<int> featuresUsed;
-        vector<int> featuresUsed;
         // Step 0: Set the finish condition
         // if not repeatSparent a finish condition is run out of features
-        // n_models == max_models
+        // n_models == maxModels
-        int numClasses = states[className].size();
         while (!exitCondition) {
             // Step 1: Build ranking with mutual information
-            auto featureSelection = metrics.SelectKBestWeighted(weights_, n); // Get all the features sorted
+            auto featureSelection = metrics.SelectKBestWeighted(weights_, ascending, n); // Get all the features sorted
-            auto feature = featureSelection[0];
             unique_ptr<Classifier> model;
-            if (!repeatSparent) {
+            auto feature = featureSelection[0];
-                if (n_models == 0) {
+            if (!repeatSparent || featuresUsed.size() < featureSelection.size()) {
-                    models.resize(n); // Resize for n==nfeatures SPODEs
-                    significanceModels.resize(n);
-                }
                 bool found = false;
-                for (int i = 0; i < featureSelection.size(); ++i) {
+                for (auto feat : featureSelection) {
-                    if (find(featuresUsed.begin(), featuresUsed.end(), i) != featuresUsed.end()) {
+                    if (find(featuresUsed.begin(), featuresUsed.end(), feat) != featuresUsed.end()) {
                         continue;
                     }
                     found = true;
-                    feature = i;
+                    feature = feat;
-                    featuresUsed.push_back(feature);
-                    n_models++;
                     break;
                 }
                 if (!found) {
@@ -48,7 +57,9 @@ namespace bayesnet {
                     continue;
                 }
             }
+            featuresUsed.insert(feature);
             model = std::make_unique<SPODE>(feature);
+            n_models++;
             model->fit(dataset, features, className, states, weights_);
             auto ypred = model->predict(X_);
             // Step 3.1: Compute the classifier amout of say
@@ -63,15 +74,12 @@ namespace bayesnet {
             double totalWeights = torch::sum(weights_).item<double>();
             weights_ = weights_ / totalWeights;
             // Step 3.4: Store classifier and its accuracy to weigh its future vote
-            if (!repeatSparent) {
+            models.push_back(std::move(model));
-                models[feature] = std::move(model);
+            significanceModels.push_back(significance);
-                significanceModels[feature] = significance;
+            exitCondition = n_models == maxModels && repeatSparent;
-            } else {
+        }
-                models.push_back(std::move(model));
+        if (featuresUsed.size() != features.size()) {
-                significanceModels.push_back(significance);
+            cout << "Warning: BoostAODE did not use all the features" << endl;
-                n_models++;
-            }
-            exitCondition = n_models == max_models;
         }
         weights.copy_(weights_);
     }

src/BayesNet/BoostAODE.h

@@ -4,13 +4,18 @@
 #include "SPODE.h"
 namespace bayesnet {
     class BoostAODE : public Ensemble {
-    protected:
-        void buildModel(const torch::Tensor& weights) override;
-        void trainModel(const torch::Tensor& weights) override;
     public:
         BoostAODE();
         virtual ~BoostAODE() {};
         vector<string> graph(const string& title = "BoostAODE") const override;
+        void setHyperparameters(nlohmann::json& hyperparameters) override;
+    protected:
+        void buildModel(const torch::Tensor& weights) override;
+        void trainModel(const torch::Tensor& weights) override;
+    private:
+        bool repeatSparent=false;
+        int maxModels=0;
+        bool ascending=false; //Process KBest features ascending or descending order
     };
 }
 #endif

src/BayesNet/CMakeLists.txt

@@ -1,5 +1,6 @@
 include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
 include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
+include_directories(${BayesNet_SOURCE_DIR}/lib/json/include)
 include_directories(${BayesNet_SOURCE_DIR}/src/BayesNet)
 include_directories(${BayesNet_SOURCE_DIR}/src/Platform)
 add_library(BayesNet bayesnetUtils.cc Network.cc Node.cc BayesMetrics.cc Classifier.cc 

src/BayesNet/Classifier.cc

@@ -5,7 +5,7 @@ namespace bayesnet {
     using namespace torch;
 
     Classifier::Classifier(Network model) : model(model), m(0), n(0), metrics(Metrics()), fitted(false) {}
-    Classifier& Classifier::build(vector<string>& features, string className, map<string, vector<int>>& states, const torch::Tensor& weights)
+    Classifier& Classifier::build(const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights)
     {
         this->features = features;
         this->className = className;
@@ -13,7 +13,7 @@ namespace bayesnet {
         m = dataset.size(1);
         n = dataset.size(0) - 1;
         checkFitParameters();
-        auto n_classes = states[className].size();
+        auto n_classes = states.at(className).size();
         metrics = Metrics(dataset, features, className, n_classes);
         model.initialize();
         buildModel(weights);
@@ -39,7 +39,7 @@ namespace bayesnet {
         model.fit(dataset, weights, features, className, states);
     }
     // X is nxm where n is the number of features and m the number of samples
-    Classifier& Classifier::fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states)
+    Classifier& Classifier::fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& features, const string& className, map<string, vector<int>>& states)
     {
         dataset = X;
         buildDataset(y);
@@ -47,7 +47,7 @@ namespace bayesnet {
         return build(features, className, states, weights);
     }
     // X is nxm where n is the number of features and m the number of samples
-    Classifier& Classifier::fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states)
+    Classifier& Classifier::fit(vector<vector<int>>& X, vector<int>& y, const vector<string>& features, const string& className, map<string, vector<int>>& states)
     {
         dataset = torch::zeros({ static_cast<int>(X.size()), static_cast<int>(X[0].size()) }, kInt32);
         for (int i = 0; i < X.size(); ++i) {
@@ -58,19 +58,22 @@ namespace bayesnet {
         const torch::Tensor weights = torch::full({ dataset.size(1) }, 1.0 / dataset.size(1), torch::kDouble);
         return build(features, className, states, weights);
     }
-    Classifier& Classifier::fit(torch::Tensor& dataset, vector<string>& features, string className, map<string, vector<int>>& states)
+    Classifier& Classifier::fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states)
     {
         this->dataset = dataset;
         const torch::Tensor weights = torch::full({ dataset.size(1) }, 1.0 / dataset.size(1), torch::kDouble);
         return build(features, className, states, weights);
     }
-    Classifier& Classifier::fit(torch::Tensor& dataset, vector<string>& features, string className, map<string, vector<int>>& states, const torch::Tensor& weights)
+    Classifier& Classifier::fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights)
     {
         this->dataset = dataset;
         return build(features, className, states, weights);
     }
     void Classifier::checkFitParameters()
     {
+        if (torch::is_floating_point(dataset)) {
+            throw invalid_argument("dataset (X, y) must be of type Integer");
+        }
         if (n != features.size()) {
             throw invalid_argument("X " + to_string(n) + " and features " + to_string(features.size()) + " must have the same number of features");
         }
@@ -152,4 +155,18 @@ namespace bayesnet {
     {
         model.dump_cpt();
     }
+    void Classifier::checkHyperparameters(const vector<string>& validKeys, nlohmann::json& hyperparameters)
+    {
+        for (const auto& item : hyperparameters.items()) {
+            if (find(validKeys.begin(), validKeys.end(), item.key()) == validKeys.end()) {
+                throw invalid_argument("Hyperparameter " + item.key() + " is not valid");
+            }
+        }
+    }
+    void Classifier::setHyperparameters(nlohmann::json& hyperparameters)
+    {
+        // Check if hyperparameters are valid, default is no hyperparameters
+        const vector<string> validKeys = { };
+        checkHyperparameters(validKeys, hyperparameters);
+    }
 }

src/BayesNet/Classifier.h

@@ -11,7 +11,7 @@ namespace bayesnet {
     class Classifier : public BaseClassifier {
     private:
         void buildDataset(torch::Tensor& y);
-        Classifier& build(vector<string>& features, string className, map<string, vector<int>>& states, const torch::Tensor& weights);
+        Classifier& build(const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights);
     protected:
         bool fitted;
         int m, n; // m: number of samples, n: number of features
@@ -24,13 +24,14 @@ namespace bayesnet {
         void checkFitParameters();
         virtual void buildModel(const torch::Tensor& weights) = 0;
         void trainModel(const torch::Tensor& weights) override;
+        void checkHyperparameters(const vector<string>& validKeys, nlohmann::json& hyperparameters);
     public:
         Classifier(Network model);
         virtual ~Classifier() = default;
-        Classifier& fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        Classifier& fit(vector<vector<int>>& X, vector<int>& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        Classifier& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        Classifier& fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        Classifier& fit(torch::Tensor& dataset, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        Classifier& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        Classifier& fit(torch::Tensor& dataset, vector<string>& features, string className, map<string, vector<int>>& states, const torch::Tensor& weights) override;
+        Classifier& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights) override;
         void addNodes();
         int getNumberOfNodes() const override;
         int getNumberOfEdges() const override;
@@ -42,6 +43,7 @@ namespace bayesnet {
         vector<string> show() const override;
         vector<string> topological_order()  override;
         void dump_cpt() const override;
+        void setHyperparameters(nlohmann::json& hyperparameters) override;
     };
 }
 #endif

src/BayesNet/Ensemble.cc

@@ -3,7 +3,7 @@
 namespace bayesnet {
     using namespace torch;
 
-    Ensemble::Ensemble() : Classifier(Network()) {}
+    Ensemble::Ensemble() : Classifier(Network()), n_models(0) {}
 
     void Ensemble::trainModel(const torch::Tensor& weights)
     {
@@ -17,9 +17,13 @@ namespace bayesnet {
     {
         auto y_pred_ = y_pred.accessor<int, 2>();
         vector<int> y_pred_final;
+        int numClasses = states.at(className).size();
+        // y_pred is m x n_models with the prediction of every model for each sample
         for (int i = 0; i < y_pred.size(0); ++i) {
-            vector<double> votes(y_pred.size(1), 0);
+            // votes store in each index (value of class) the significance added by each model
-            for (int j = 0; j < y_pred.size(1); ++j) {
+            // i.e. votes[0] contains how much value has the value 0 of class. That value is generated by the models predictions
+            vector<double> votes(numClasses, 0.0);
+            for (int j = 0; j < n_models; ++j) {
                 votes[y_pred_[i][j]] += significanceModels[j];
             }
             // argsort in descending order
@@ -34,7 +38,6 @@ namespace bayesnet {
             throw logic_error("Ensemble has not been fitted");
         }
         Tensor y_pred = torch::zeros({ X.size(1), n_models }, kInt32);
-        //Create a threadpool
         auto threads{ vector<thread>() };
         mutex mtx;
         for (auto i = 0; i < n_models; ++i) {

src/BayesNet/KDB.cc

@@ -4,6 +4,18 @@ namespace bayesnet {
     using namespace torch;
 
     KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta) {}
+    void KDB::setHyperparameters(nlohmann::json& hyperparameters)
+    {
+        // Check if hyperparameters are valid
+        const vector<string> validKeys = { "k", "theta" };
+        checkHyperparameters(validKeys, hyperparameters);
+        if (hyperparameters.contains("k")) {
+            k = hyperparameters["k"];
+        }
+        if (hyperparameters.contains("theta")) {
+            theta = hyperparameters["theta"];
+        }
+    }
     void KDB::buildModel(const torch::Tensor& weights)
     {
         /*

src/BayesNet/KDB.h

@@ -16,6 +16,7 @@ namespace bayesnet {
     public:
         explicit KDB(int k, float theta = 0.03);
         virtual ~KDB() {};
+        void setHyperparameters(nlohmann::json& hyperparameters) override;
         vector<string> graph(const string& name = "KDB") const override;
     };
 }

src/BayesNet/KDBLd.cc

@@ -3,9 +3,9 @@
 namespace bayesnet {
     using namespace std;
     KDBLd::KDBLd(int k) : KDB(k), Proposal(dataset, features, className) {}
-    KDBLd& KDBLd::fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    KDBLd& KDBLd::fit(torch::Tensor& X_, torch::Tensor& y_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
     {
-        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
+        checkInput(X_, y_);
         features = features_;
         className = className_;
         Xf = X_;

src/BayesNet/KDBLd.h

@@ -10,7 +10,7 @@ namespace bayesnet {
     public:
         explicit KDBLd(int k);
         virtual ~KDBLd() = default;
-        KDBLd& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        KDBLd& fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
         vector<string> graph(const string& name = "KDB") const override;
         Tensor predict(Tensor& X) override;
         static inline string version() { return "0.0.1"; };

src/BayesNet/Network.cc

@@ -3,8 +3,8 @@
 #include "Network.h"
 #include "bayesnetUtils.h"
 namespace bayesnet {
-    Network::Network() : features(vector<string>()), className(""), classNumStates(0), fitted(false) {}
+    Network::Network() : features(vector<string>()), className(""), classNumStates(0), fitted(false), laplaceSmoothing(0) {}
-    Network::Network(float maxT) : features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
+    Network::Network(float maxT) : features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false), laplaceSmoothing(0) {}
     Network::Network(Network& other) : laplaceSmoothing(other.laplaceSmoothing), features(other.features), className(other.className), classNumStates(other.getClassNumStates()), maxThreads(other.
         getmaxThreads()), fitted(other.fitted)
     {
@@ -174,42 +174,10 @@ namespace bayesnet {
     {
         setStates(states);
         laplaceSmoothing = 1.0 / samples.size(1); // To use in CPT computation
-        int maxThreadsRunning = static_cast<int>(std::thread::hardware_concurrency() * maxThreads);
+        for (auto& node : nodes) {
-        if (maxThreadsRunning < 1) {
+            node.second->computeCPT(samples, features, laplaceSmoothing, weights);
-            maxThreadsRunning = 1;
+            fitted = true;
         }
-        vector<thread> threads;
-        mutex mtx;
-        condition_variable cv;
-        int activeThreads = 0;
-        int nextNodeIndex = 0;
-        while (nextNodeIndex < nodes.size()) {
-            unique_lock<mutex> lock(mtx);
-            cv.wait(lock, [&activeThreads, &maxThreadsRunning]() { return activeThreads < maxThreadsRunning; });
-            threads.emplace_back([this, &nextNodeIndex, &mtx, &cv, &activeThreads, &weights]() {
-                while (true) {
-                    unique_lock<mutex> lock(mtx);
-                    if (nextNodeIndex >= nodes.size()) {
-                        break;  // No more work remaining
-                    }
-                    auto& pair = *std::next(nodes.begin(), nextNodeIndex);
-                    ++nextNodeIndex;
-                    lock.unlock();
-                    pair.second->computeCPT(samples, features, laplaceSmoothing, weights);
-                    lock.lock();
-                    nodes[pair.first] = std::move(pair.second);
-                    lock.unlock();
-                }
-                lock_guard<mutex> lock(mtx);
-                --activeThreads;
-                cv.notify_one();
-                });
-            ++activeThreads;
-        }
-        for (auto& thread : threads) {
-            thread.join();
-        }
-        fitted = true;
     }
     torch::Tensor Network::predict_tensor(const torch::Tensor& samples, const bool proba)
     {
@@ -399,7 +367,6 @@ namespace bayesnet {
         auto result = features;
         result.erase(remove(result.begin(), result.end(), className), result.end());
         bool ending{ false };
-        int idx = 0;
         while (!ending) {
             ending = true;
             for (auto feature : features) {

src/BayesNet/Network.h

@@ -27,6 +27,7 @@ namespace bayesnet {
         Network();
         explicit Network(float);
         explicit Network(Network&);
+        ~Network() = default;
         torch::Tensor& getSamples();
         float getmaxThreads();
         void addNode(const string&);
@@ -52,7 +53,7 @@ namespace bayesnet {
         vector<string> graph(const string& title) const; // Returns a vector of strings representing the graph in graphviz format
         void initialize();
         void dump_cpt() const;
-        inline string version() { return "0.1.0"; }
+        inline string version() { return "0.2.0"; }
     };
 }
 #endif

src/BayesNet/Node.cc

@@ -100,7 +100,7 @@ namespace bayesnet {
         }
         int name_index = pos - features.begin();
         for (int n_sample = 0; n_sample < dataset.size(1); ++n_sample) {
-            torch::List<c10::optional<torch::Tensor>> coordinates;
+            c10::List<c10::optional<at::Tensor>> coordinates;
             coordinates.push_back(dataset.index({ name_index, n_sample }));
             for (auto parent : parents) {
                 pos = find(features.begin(), features.end(), parent->getName());
@@ -118,10 +118,10 @@ namespace bayesnet {
     }
     float Node::getFactorValue(map<string, int>& evidence)
     {
-        torch::List<c10::optional<torch::Tensor>> coordinates;
+        c10::List<c10::optional<at::Tensor>> coordinates;
         // following predetermined order of indices in the cpTable (see Node.h)
-        coordinates.push_back(torch::tensor(evidence[name]));
+        coordinates.push_back(at::tensor(evidence[name]));
-        transform(parents.begin(), parents.end(), back_inserter(coordinates), [&evidence](const auto& parent) { return torch::tensor(evidence[parent->getName()]); });
+        transform(parents.begin(), parents.end(), back_inserter(coordinates), [&evidence](const auto& parent) { return at::tensor(evidence[parent->getName()]); });
         return cpTable.index({ coordinates }).item<float>();
     }
     vector<string> Node::graph(const string& className)

src/BayesNet/Proposal.cc

@@ -9,6 +9,15 @@ namespace bayesnet {
             delete value;
         }
     }
+    void Proposal::checkInput(const torch::Tensor& X, const torch::Tensor& y)
+    {
+        if (!torch::is_floating_point(X)) {
+            throw std::invalid_argument("X must be a floating point tensor");
+        }
+        if (torch::is_floating_point(y)) {
+            throw std::invalid_argument("y must be an integer tensor");
+        }
+    }
     map<string, vector<int>> Proposal::localDiscretizationProposal(const map<string, vector<int>>& oldStates, Network& model)
     {
         // order of local discretization is important. no good 0, 1, 2...
@@ -44,15 +53,6 @@ namespace bayesnet {
             auto xvf_ptr = Xf.index({ index }).data_ptr<float>();
             auto xvf = vector<mdlp::precision_t>(xvf_ptr, xvf_ptr + Xf.size(1));
             discretizers[feature]->fit(xvf, yxv);
-            //
-            //
-            //
-            // auto tmp = discretizers[feature]->transform(xvf);
-            // Xv[index] = tmp;
-            // auto xStates = vector<int>(discretizers[pFeatures[index]]->getCutPoints().size() + 1);
-            // iota(xStates.begin(), xStates.end(), 0);
-            // //Update new states of the feature/node
-            // states[feature] = xStates;
         }
         if (upgrade) {
             // Discretize again X (only the affected indices) with the new fitted discretizers

src/BayesNet/Proposal.h

@@ -13,6 +13,7 @@ namespace bayesnet {
         Proposal(torch::Tensor& pDataset, vector<string>& features_, string& className_);
         virtual ~Proposal();
     protected:
+        void checkInput(const torch::Tensor& X, const torch::Tensor& y);
         torch::Tensor prepareX(torch::Tensor& X);
         map<string, vector<int>> localDiscretizationProposal(const map<string, vector<int>>& states, Network& model);
         map<string, vector<int>> fit_local_discretization(const torch::Tensor& y);

src/BayesNet/SPODELd.cc

@@ -3,9 +3,9 @@
 namespace bayesnet {
     using namespace std;
     SPODELd::SPODELd(int root) : SPODE(root), Proposal(dataset, features, className) {}
-    SPODELd& SPODELd::fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    SPODELd& SPODELd::fit(torch::Tensor& X_, torch::Tensor& y_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
     {
-        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
+        checkInput(X_, y_);
         features = features_;
         className = className_;
         Xf = X_;
@@ -18,11 +18,13 @@ namespace bayesnet {
         states = localDiscretizationProposal(states, model);
         return *this;
     }
-    SPODELd& SPODELd::fit(torch::Tensor& dataset, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    SPODELd& SPODELd::fit(torch::Tensor& dataset, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
     {
+        if (!torch::is_floating_point(dataset)) {
+            throw std::runtime_error("Dataset must be a floating point tensor");
+        }
         Xf = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), "..." }).clone();
         y = dataset.index({ -1, "..." }).clone();
-        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
         features = features_;
         className = className_;
         // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y

src/BayesNet/SPODELd.h

@@ -9,8 +9,8 @@ namespace bayesnet {
     public:
         explicit SPODELd(int root);
         virtual ~SPODELd() = default;
-        SPODELd& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        SPODELd& fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        SPODELd& fit(torch::Tensor& dataset, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        SPODELd& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
         vector<string> graph(const string& name = "SPODE") const override;
         Tensor predict(Tensor& X) override;
         static inline string version() { return "0.0.1"; };

src/BayesNet/TAN.h

@@ -3,7 +3,6 @@
 #include "Classifier.h"
 namespace bayesnet {
     using namespace std;
-    using namespace torch;
     class TAN : public Classifier {
     private:
     protected:

src/BayesNet/TANLd.cc

@@ -3,9 +3,9 @@
 namespace bayesnet {
     using namespace std;
     TANLd::TANLd() : TAN(), Proposal(dataset, features, className) {}
-    TANLd& TANLd::fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    TANLd& TANLd::fit(torch::Tensor& X_, torch::Tensor& y_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
     {
-        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
+        checkInput(X_, y_);
         features = features_;
         className = className_;
         Xf = X_;

src/BayesNet/TANLd.h

@@ -10,7 +10,7 @@ namespace bayesnet {
     public:
         TANLd();
         virtual ~TANLd() = default;
-        TANLd& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        TANLd& fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
         vector<string> graph(const string& name = "TAN") const override;
         Tensor predict(Tensor& X) override;
         static inline string version() { return "0.0.1"; };

src/Platform/CMakeLists.txt

@@ -4,9 +4,9 @@ include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
 include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
 include_directories(${BayesNet_SOURCE_DIR}/lib/argparse/include)
 include_directories(${BayesNet_SOURCE_DIR}/lib/json/include)
-add_executable(main main.cc Folding.cc platformUtils.cc Experiment.cc Datasets.cc Models.cc Report.cc)
+add_executable(main main.cc Folding.cc platformUtils.cc Experiment.cc Datasets.cc Models.cc ReportConsole.cc ReportBase.cc)
-add_executable(manage manage.cc Results.cc Report.cc)
+add_executable(manage manage.cc Results.cc ReportConsole.cc ReportExcel.cc ReportBase.cc)
 add_executable(list list.cc platformUtils Datasets.cc)
 target_link_libraries(main BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}")
-target_link_libraries(manage "${TORCH_LIBRARIES}")
+target_link_libraries(manage "${TORCH_LIBRARIES}" OpenXLSX::OpenXLSX)
 target_link_libraries(list ArffFiles mdlp "${TORCH_LIBRARIES}")

src/Platform/Datasets.cc

@@ -1,6 +1,7 @@
 #include "Datasets.h"
 #include "platformUtils.h"
 #include "ArffFiles.h"
+#include <fstream>
 namespace platform {
     void Datasets::load()
     {
@@ -212,10 +213,11 @@ namespace platform {
     {
         for (int i = 0; i < features.size(); ++i) {
             states[features[i]] = vector<int>(*max_element(Xd[i].begin(), Xd[i].end()) + 1);
-            iota(begin(states[features[i]]), end(states[features[i]]), 0);
+            auto item = states.at(features[i]);
+            iota(begin(item), end(item), 0);
         }
         states[className] = vector<int>(*max_element(yv.begin(), yv.end()) + 1);
-        iota(begin(states[className]), end(states[className]), 0);
+        iota(begin(states.at(className)), end(states.at(className)), 0);
     }
     void Dataset::load_arff()
     {

src/Platform/Experiment.cc

@@ -1,8 +1,8 @@
 #include "Experiment.h"
 #include "Datasets.h"
 #include "Models.h"
-#include "Report.h"
+#include "ReportConsole.h"
-
+#include <fstream>
 namespace platform {
     using json = nlohmann::json;
     string get_date()
@@ -25,6 +25,7 @@ namespace platform {
         oss << std::put_time(timeinfo, "%H:%M:%S");
         return oss.str();
     }
+    Experiment::Experiment() : hyperparameters(json::parse("{}")) {}
     string Experiment::get_file_name()
     {
         string result = "results_" + score_name + "_" + model + "_" + platform + "_" + get_date() + "_" + get_time() + "_" + (stratified ? "1" : "0") + ".json";
@@ -90,7 +91,7 @@ namespace platform {
     void Experiment::report()
     {
         json data = build_json();
-        Report report(data);
+        ReportConsole report(data);
         report.show();
     }
 
@@ -124,6 +125,8 @@ 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);
+        // Initialize results vectors
         int nResults = nfolds * static_cast<int>(randomSeeds.size());
         auto accuracy_test = torch::zeros({ nResults }, torch::kFloat64);
         auto accuracy_train = torch::zeros({ nResults }, torch::kFloat64);
@@ -144,6 +147,10 @@ namespace platform {
             for (int nfold = 0; nfold < nfolds; nfold++) {
                 auto clf = Models::instance()->create(model);
                 setModelVersion(clf->getVersion());
+                if (hyperparameters.size() != 0) {
+                    clf->setHyperparameters(hyperparameters);
+                }
+                // Split train - test dataset
                 train_timer.start();
                 auto [train, test] = fold->getFold(nfold);
                 auto train_t = torch::tensor(train);
@@ -153,12 +160,14 @@ namespace platform {
                 auto X_test = X.index({ "...", test_t });
                 auto y_test = y.index({ test_t });
                 cout << nfold + 1 << ", " << flush;
+                // Train model
                 clf->fit(X_train, y_train, features, className, states);
                 nodes[item] = clf->getNumberOfNodes();
                 edges[item] = clf->getNumberOfEdges();
                 num_states[item] = clf->getNumberOfStates();
                 train_time[item] = train_timer.getDuration();
                 auto accuracy_train_value = clf->score(X_train, y_train);
+                // Test model
                 test_timer.start();
                 auto accuracy_test_value = clf->score(X_test, y_test);
                 test_time[item] = test_timer.getDuration();
@@ -170,6 +179,7 @@ namespace platform {
                 result.addTimeTrain(train_time[item].item<double>());
                 result.addTimeTest(test_time[item].item<double>());
                 item++;
+                clf.reset();
             }
             cout << "end. " << flush;
             delete fold;
@@ -177,6 +187,7 @@ namespace platform {
         result.setScoreTest(torch::mean(accuracy_test).item<double>()).setScoreTrain(torch::mean(accuracy_train).item<double>());
         result.setScoreTestStd(torch::std(accuracy_test).item<double>()).setScoreTrainStd(torch::std(accuracy_train).item<double>());
         result.setTrainTime(torch::mean(train_time).item<double>()).setTestTime(torch::mean(test_time).item<double>());
+        result.setTestTimeStd(torch::std(test_time).item<double>()).setTrainTimeStd(torch::std(train_time).item<double>());
         result.setNodes(torch::mean(nodes).item<double>()).setLeaves(torch::mean(edges).item<double>()).setDepth(torch::mean(num_states).item<double>());
         result.setDataset(fileName);
         addResult(result);

src/Platform/Experiment.h

@@ -29,7 +29,8 @@ namespace platform {
     };
     class Result {
     private:
-        string dataset, hyperparameters, model_version;
+        string dataset, model_version;
+        json hyperparameters;
         int samples{ 0 }, features{ 0 }, classes{ 0 };
         double score_train{ 0 }, score_test{ 0 }, score_train_std{ 0 }, score_test_std{ 0 }, train_time{ 0 }, train_time_std{ 0 }, test_time{ 0 }, test_time_std{ 0 };
         float nodes{ 0 }, leaves{ 0 }, depth{ 0 };
@@ -37,7 +38,7 @@ namespace platform {
     public:
         Result() = default;
         Result& setDataset(const string& dataset) { this->dataset = dataset; return *this; }
-        Result& setHyperparameters(const string& hyperparameters) { this->hyperparameters = hyperparameters; return *this; }
+        Result& setHyperparameters(const json& hyperparameters) { this->hyperparameters = hyperparameters; return *this; }
         Result& setSamples(int samples) { this->samples = samples; return *this; }
         Result& setFeatures(int features) { this->features = features; return *this; }
         Result& setClasses(int classes) { this->classes = classes; return *this; }
@@ -59,7 +60,7 @@ namespace platform {
         const float get_score_train() const { return score_train; }
         float get_score_test() { return score_test; }
         const string& getDataset() const { return dataset; }
-        const string& getHyperparameters() const { return hyperparameters; }
+        const json& getHyperparameters() const { return hyperparameters; }
         const int getSamples() const { return samples; }
         const int getFeatures() const { return features; }
         const int getClasses() const { return classes; }
@@ -85,11 +86,12 @@ namespace platform {
         bool discretized{ false }, stratified{ false };
         vector<Result> results;
         vector<int> randomSeeds;
+        json hyperparameters = "{}";
         int nfolds{ 0 };
         float duration{ 0 };
         json build_json();
     public:
-        Experiment() = default;
+        Experiment();
         Experiment& setTitle(const string& title) { this->title = title; return *this; }
         Experiment& setModel(const string& model) { this->model = model; return *this; }
         Experiment& setPlatform(const string& platform) { this->platform = platform; return *this; }
@@ -103,6 +105,7 @@ 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; }
         string get_file_name();
         void save(const string& path);
         void cross_validation(const string& path, const string& fileName);

src/Platform/Folding.cc

@@ -1,95 +1,97 @@
 #include "Folding.h"
 #include <algorithm>
 #include <map>
-Fold::Fold(int k, int n, int seed) : k(k), n(n), seed(seed)
+namespace platform {
-{
+    Fold::Fold(int k, int n, int seed) : k(k), n(n), seed(seed)
-    random_device rd;
+    {
-    random_seed = default_random_engine(seed == -1 ? rd() : seed);
+        random_device rd;
-    srand(seed == -1 ? time(0) : seed);
+        random_seed = default_random_engine(seed == -1 ? rd() : seed);
-}
+        srand(seed == -1 ? time(0) : seed);
-KFold::KFold(int k, int n, int seed) : Fold(k, n, seed), indices(vector<int>(n))
-{
-    iota(begin(indices), end(indices), 0); // fill with 0, 1, ..., n - 1
-    shuffle(indices.begin(), indices.end(), random_seed);
-}
-pair<vector<int>, vector<int>> KFold::getFold(int nFold)
-{
-    if (nFold >= k || nFold < 0) {
-        throw out_of_range("nFold (" + to_string(nFold) + ") must be less than k (" + to_string(k) + ")");
     }
-    int nTest = n / k;
+    KFold::KFold(int k, int n, int seed) : Fold(k, n, seed), indices(vector<int>(n))
-    auto train = vector<int>();
+    {
-    auto test = vector<int>();
+        iota(begin(indices), end(indices), 0); // fill with 0, 1, ..., n - 1
-    for (int i = 0; i < n; i++) {
-        if (i >= nTest * nFold && i < nTest * (nFold + 1)) {
-            test.push_back(indices[i]);
-        } else {
-            train.push_back(indices[i]);
-        }
-    }
-    return { train, test };
-}
-StratifiedKFold::StratifiedKFold(int k, torch::Tensor& y, int seed) : Fold(k, y.numel(), seed)
-{
-    n = y.numel();
-    this->y = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + n);
-    build();
-}
-StratifiedKFold::StratifiedKFold(int k, const vector<int>& y, int seed)
-    : Fold(k, y.size(), seed)
-{
-    this->y = y;
-    n = y.size();
-    build();
-}
-void StratifiedKFold::build()
-{
-    stratified_indices = vector<vector<int>>(k);
-    int fold_size = n / k;
-    // Compute class counts and indices
-    auto class_indices = map<int, vector<int>>();
-    vector<int> class_counts(*max_element(y.begin(), y.end()) + 1, 0);
-    for (auto i = 0; i < n; ++i) {
-        class_counts[y[i]]++;
-        class_indices[y[i]].push_back(i);
-    }
-    // Shuffle class indices
-    for (auto& [cls, indices] : class_indices) {
         shuffle(indices.begin(), indices.end(), random_seed);
     }
-    // Assign indices to folds
+    pair<vector<int>, vector<int>> KFold::getFold(int nFold)
-    for (auto label = 0; label < class_counts.size(); ++label) {
+    {
-        auto num_samples_to_take = class_counts[label] / k;
+        if (nFold >= k || nFold < 0) {
-        if (num_samples_to_take == 0)
+            throw out_of_range("nFold (" + to_string(nFold) + ") must be less than k (" + to_string(k) + ")");
-            continue;
-        auto remainder_samples_to_take = class_counts[label] % k;
-        for (auto fold = 0; fold < k; ++fold) {
-            auto it = next(class_indices[label].begin(), num_samples_to_take);
-            move(class_indices[label].begin(), it, back_inserter(stratified_indices[fold]));  // ##
-            class_indices[label].erase(class_indices[label].begin(), it);
         }
-        while (remainder_samples_to_take > 0) {
+        int nTest = n / k;
-            int fold = (rand() % static_cast<int>(k));
+        auto train = vector<int>();
-            if (stratified_indices[fold].size() == fold_size + 1) {
+        auto test = vector<int>();
-                continue;
+        for (int i = 0; i < n; i++) {
+            if (i >= nTest * nFold && i < nTest * (nFold + 1)) {
+                test.push_back(indices[i]);
+            } else {
+                train.push_back(indices[i]);
+            }
+        }
+        return { train, test };
+    }
+    StratifiedKFold::StratifiedKFold(int k, torch::Tensor& y, int seed) : Fold(k, y.numel(), seed)
+    {
+        n = y.numel();
+        this->y = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + n);
+        build();
+    }
+    StratifiedKFold::StratifiedKFold(int k, const vector<int>& y, int seed)
+        : Fold(k, y.size(), seed)
+    {
+        this->y = y;
+        n = y.size();
+        build();
+    }
+    void StratifiedKFold::build()
+    {
+        stratified_indices = vector<vector<int>>(k);
+        int fold_size = n / k;
+        // Compute class counts and indices
+        auto class_indices = map<int, vector<int>>();
+        vector<int> class_counts(*max_element(y.begin(), y.end()) + 1, 0);
+        for (auto i = 0; i < n; ++i) {
+            class_counts[y[i]]++;
+            class_indices[y[i]].push_back(i);
+        }
+        // Shuffle class indices
+        for (auto& [cls, indices] : class_indices) {
+            shuffle(indices.begin(), indices.end(), random_seed);
+        }
+        // Assign indices to folds
+        for (auto label = 0; label < class_counts.size(); ++label) {
+            auto num_samples_to_take = class_counts[label] / k;
+            if (num_samples_to_take == 0)
+                continue;
+            auto remainder_samples_to_take = class_counts[label] % k;
+            for (auto fold = 0; fold < k; ++fold) {
+                auto it = next(class_indices[label].begin(), num_samples_to_take);
+                move(class_indices[label].begin(), it, back_inserter(stratified_indices[fold]));  // ##
+                class_indices[label].erase(class_indices[label].begin(), it);
+            }
+            while (remainder_samples_to_take > 0) {
+                int fold = (rand() % static_cast<int>(k));
+                if (stratified_indices[fold].size() == fold_size + 1) {
+                    continue;
+                }
+                auto it = next(class_indices[label].begin(), 1);
+                stratified_indices[fold].push_back(*class_indices[label].begin());
+                class_indices[label].erase(class_indices[label].begin(), it);
+                remainder_samples_to_take--;
             }
-            auto it = next(class_indices[label].begin(), 1);
-            stratified_indices[fold].push_back(*class_indices[label].begin());
-            class_indices[label].erase(class_indices[label].begin(), it);
-            remainder_samples_to_take--;
         }
     }
-}
+    pair<vector<int>, vector<int>> StratifiedKFold::getFold(int nFold)
-pair<vector<int>, vector<int>> StratifiedKFold::getFold(int nFold)
+    {
-{
+        if (nFold >= k || nFold < 0) {
-    if (nFold >= k || nFold < 0) {
+            throw out_of_range("nFold (" + to_string(nFold) + ") must be less than k (" + to_string(k) + ")");
-        throw out_of_range("nFold (" + to_string(nFold) + ") must be less than k (" + to_string(k) + ")");
+        }
+        vector<int> test_indices = stratified_indices[nFold];
+        vector<int> train_indices;
+        for (int i = 0; i < k; ++i) {
+            if (i == nFold) continue;
+            train_indices.insert(train_indices.end(), stratified_indices[i].begin(), stratified_indices[i].end());
+        }
+        return { train_indices, test_indices };
     }
-    vector<int> test_indices = stratified_indices[nFold];
-    vector<int> train_indices;
-    for (int i = 0; i < k; ++i) {
-        if (i == nFold) continue;
-        train_indices.insert(train_indices.end(), stratified_indices[i].begin(), stratified_indices[i].end());
-    }
-    return { train_indices, test_indices };
 }

src/Platform/Folding.h

@@ -4,34 +4,35 @@
 #include <vector>
 #include <random> 
 using namespace std;
-
+namespace platform {
-class Fold {
+    class Fold {
-protected:
+    protected:
-    int k;
+        int k;
-    int n;
+        int n;
-    int seed;
+        int seed;
-    default_random_engine random_seed;
+        default_random_engine random_seed;
-public:
+    public:
-    Fold(int k, int n, int seed = -1);
+        Fold(int k, int n, int seed = -1);
-    virtual pair<vector<int>, vector<int>> getFold(int nFold) = 0;
+        virtual pair<vector<int>, vector<int>> getFold(int nFold) = 0;
-    virtual ~Fold() = default;
+        virtual ~Fold() = default;
-    int getNumberOfFolds() { return k; }
+        int getNumberOfFolds() { return k; }
-};
+    };
-class KFold : public Fold {
+    class KFold : public Fold {
-private:
+    private:
-    vector<int> indices;
+        vector<int> indices;
-public:
+    public:
-    KFold(int k, int n, int seed = -1);
+        KFold(int k, int n, int seed = -1);
-    pair<vector<int>, vector<int>> getFold(int nFold) override;
+        pair<vector<int>, vector<int>> getFold(int nFold) override;
-};
+    };
-class StratifiedKFold : public Fold {
+    class StratifiedKFold : public Fold {
-private:
+    private:
-    vector<int> y;
+        vector<int> y;
-    vector<vector<int>> stratified_indices;
+        vector<vector<int>> stratified_indices;
-    void build();
+        void build();
-public:
+    public:
-    StratifiedKFold(int k, const vector<int>& y, int seed = -1);
+        StratifiedKFold(int k, const vector<int>& y, int seed = -1);
-    StratifiedKFold(int k, torch::Tensor& y, int seed = -1);
+        StratifiedKFold(int k, torch::Tensor& y, int seed = -1);
-    pair<vector<int>, vector<int>> getFold(int nFold) override;
+        pair<vector<int>, vector<int>> getFold(int nFold) override;
-};
+    };
+}
 #endif

src/Platform/Models.cc

@@ -26,7 +26,7 @@ namespace platform {
             instance = it->second();
         // wrap instance in a shared ptr and return
         if (instance != nullptr)
-            return shared_ptr<bayesnet::BaseClassifier>(instance);
+            return unique_ptr<bayesnet::BaseClassifier>(instance);
         else
             return nullptr;
     }

src/Platform/Paths.h

@@ -6,6 +6,7 @@ namespace platform {
     public:
         static std::string datasets() { return "datasets/"; }
         static std::string results() { return "results/"; }
+        static std::string excel() { return "excel/"; }
     };
 }
 #endif

src/Platform/Report.h

@@ -1,26 +0,0 @@
-#ifndef REPORT_H
-#define REPORT_H
-#include <string>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include "Colors.h"
-
-using json = nlohmann::json;
-const int MAXL = 128;
-namespace platform {
-    using namespace std;
-    class Report {
-    public:
-        explicit Report(json data_) { data = data_; };
-        virtual ~Report() = default;
-        void show();
-    private:
-        void header();
-        void body();
-        void footer();
-        string fromVector(const string& key);
-        json data;
-        double totalScore; // Total score of all results in a report
-    };
-};
-#endif

src/Platform/ReportBase.cc

@@ -0,0 +1,37 @@
+#include <sstream>
+#include <locale>
+#include "ReportBase.h"
+#include "BestResult.h"
+
+
+namespace platform {
+    string ReportBase::fromVector(const string& key)
+    {
+        stringstream oss;
+        string sep = "";
+        oss << "[";
+        for (auto& item : data[key]) {
+            oss << sep << item.get<double>();
+            sep = ", ";
+        }
+        oss << "]";
+        return oss.str();
+    }
+    string ReportBase::fVector(const string& title, const json& data, const int width, const int precision)
+    {
+        stringstream oss;
+        string sep = "";
+        oss << title << "[";
+        for (const auto& item : data) {
+            oss << sep << fixed << setw(width) << setprecision(precision) << item.get<double>();
+            sep = ", ";
+        }
+        oss << "]";
+        return oss.str();
+    }
+    void ReportBase::show()
+    {
+        header();
+        body();
+    }
+}

src/Platform/ReportBase.h

@@ -0,0 +1,23 @@
+#ifndef REPORTBASE_H
+#define REPORTBASE_H
+#include <string>
+#include <iostream>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+namespace platform {
+    using namespace std;
+    class ReportBase {
+    public:
+        explicit ReportBase(json data_) { data = data_; };
+        virtual ~ReportBase() = default;
+        void show();
+    protected:
+        json data;
+        string fromVector(const string& key);
+        string fVector(const string& title, const json& data, const int width, const int precision);
+        virtual void header() = 0;
+        virtual void body() = 0;
+    };
+};
+#endif

src/Platform/ReportConsole.cc

@@ -1,52 +1,24 @@
 #include <sstream>
 #include <locale>
-#include "Report.h"
+#include "ReportConsole.h"
 #include "BestResult.h"
 
 
 namespace platform {
-    string headerLine(const string& text)
-    {
-        int n = MAXL - text.length() - 3;
-        n = n < 0 ? 0 : n;
-        return "* " + text + string(n, ' ') + "*\n";
-    }
-    string Report::fromVector(const string& key)
-    {
-        stringstream oss;
-        string sep = "";
-        oss << "[";
-        for (auto& item : data[key]) {
-            oss << sep << item.get<double>();
-            sep = ", ";
-        }
-        oss << "]";
-        return oss.str();
-    }
-    string fVector(const string& title, const json& data, const int width, const int precision)
-    {
-        stringstream oss;
-        string sep = "";
-        oss << title << "[";
-        for (const auto& item : data) {
-            oss << sep << fixed << setw(width) << setprecision(precision) << item.get<double>();
-            sep = ", ";
-        }
-        oss << "]";
-        return oss.str();
-    }
-    void Report::show()
-    {
-        header();
-        body();
-        footer();
-    }
     struct separated : numpunct<char> {
         char do_decimal_point() const { return ','; }
         char do_thousands_sep() const { return '.'; }
         string do_grouping() const { return "\03"; }
     };
-    void Report::header()
+    
+    string ReportConsole::headerLine(const string& text)
+    {
+        int n = MAXL - text.length() - 3;
+        n = n < 0 ? 0 : n;
+        return "* " + text + string(n, ' ') + "*\n";
+    }
+    
+    void ReportConsole::header()
     {
         locale mylocale(cout.getloc(), new separated);
         locale::global(mylocale);
@@ -62,12 +34,12 @@ namespace platform {
         cout << string(MAXL, '*') << endl;
         cout << endl;
     }
-    void Report::body()
+    void ReportConsole::body()
     {
         cout << Colors::GREEN() << "Dataset                        Sampl. Feat. Cls Nodes     Edges     States    Score           Time               Hyperparameters" << endl;
         cout << "============================== ====== ===== === ========= ========= ========= =============== ================== ===============" << endl;
         json lastResult;
-        totalScore = 0;
+        double totalScore = 0.0;
         bool odd = true;
         for (const auto& r : data["results"]) {
             auto color = odd ? Colors::CYAN() : Colors::BLUE();
@@ -98,9 +70,11 @@ namespace platform {
             cout << headerLine(fVector("Train  times: ", lastResult["times_train"], 10, 3));
             cout << headerLine(fVector("Test   times: ", lastResult["times_test"], 10, 3));
             cout << string(MAXL, '*') << endl;
+        } else {
+            footer(totalScore);
         }
     }
-    void Report::footer()
+    void ReportConsole::footer(double totalScore)
     {
         cout << Colors::MAGENTA() << string(MAXL, '*') << endl;
         auto score = data["score_name"].get<string>();
@@ -110,6 +84,5 @@ namespace platform {
             cout << headerLine(oss.str());
         }
         cout << string(MAXL, '*') << endl << Colors::RESET();
-
     }
 }

src/Platform/ReportConsole.h

@@ -0,0 +1,22 @@
+#ifndef REPORTCONSOLE_H
+#define REPORTCONSOLE_H
+#include <string>
+#include <iostream>
+#include "ReportBase.h"
+#include "Colors.h"
+
+namespace platform {
+    using namespace std;
+    const int MAXL = 128;
+    class ReportConsole : public ReportBase{
+    public:
+        explicit ReportConsole(json data_) : ReportBase(data_) {};
+        virtual ~ReportConsole() = default;
+    private:
+        string headerLine(const string& text);
+        void header() override;
+        void body() override;
+        void footer(double totalScore);
+    };
+};
+#endif

src/Platform/ReportExcel.cc

@@ -0,0 +1,109 @@
+#include <sstream>
+#include <locale>
+#include "ReportExcel.h"
+#include "BestResult.h"
+
+
+namespace platform {
+    struct separated : numpunct<char> {
+        char do_decimal_point() const { return ','; }
+
+        char do_thousands_sep() const { return '.'; }
+
+        string do_grouping() const { return "\03"; }
+    };
+
+    void ReportExcel::createFile()
+    {
+        doc.create(Paths::excel() + "some_results.xlsx");
+        wks = doc.workbook().worksheet("Sheet1");
+        wks.setName(data["model"].get<string>());
+    }
+
+    void ReportExcel::closeFile()
+    {
+        doc.save();
+        doc.close();
+    }
+
+    void ReportExcel::header()
+    {
+        locale mylocale(cout.getloc(), new separated);
+        locale::global(mylocale);
+        cout.imbue(mylocale);
+        stringstream oss;
+        wks.cell("A1").value().set(
+            "Report " + data["model"].get<string>() + " ver. " + data["version"].get<string>() + " with " +
+            to_string(data["folds"].get<int>()) + " Folds cross validation and " + to_string(data["seeds"].size()) +
+            " random seeds. " + data["date"].get<string>() + " " + data["time"].get<string>());
+        wks.cell("A2").value() = data["title"].get<string>();
+        wks.cell("A3").value() = "Random seeds: " + fromVector("seeds") + " Stratified: " +
+            (data["stratified"].get<bool>() ? "True" : "False");
+        oss << "Execution took  " << setprecision(2) << fixed << data["duration"].get<float>() << " seconds,   "
+            << data["duration"].get<float>() / 3600 << " hours, on " << data["platform"].get<string>();
+        wks.cell("A4").value() = oss.str();
+        wks.cell("A5").value() = "Score is " + data["score_name"].get<string>();
+    }
+
+    void ReportExcel::body()
+    {
+        auto head = vector<string>(
+            { "Dataset", "Samples", "Features", "Classes", "Nodes", "Edges", "States", "Score", "Score Std.", "Time",
+             "Time Std.", "Hyperparameters" });
+        int col = 1;
+        for (const auto& item : head) {
+            wks.cell(8, col++).value() = item;
+        }
+        int row = 9;
+        col = 1;
+        json lastResult;
+        double totalScore = 0.0;
+        string hyperparameters;
+        for (const auto& r : data["results"]) {
+            wks.cell(row, col).value() = r["dataset"].get<string>();
+            wks.cell(row, col + 1).value() = r["samples"].get<int>();
+            wks.cell(row, col + 2).value() = r["features"].get<int>();
+            wks.cell(row, col + 3).value() = r["classes"].get<int>();
+            wks.cell(row, col + 4).value() = r["nodes"].get<float>();
+            wks.cell(row, col + 5).value() = r["leaves"].get<float>();
+            wks.cell(row, col + 6).value() = r["depth"].get<float>();
+            wks.cell(row, col + 7).value() = r["score"].get<double>();
+            wks.cell(row, col + 8).value() = r["score_std"].get<double>();
+            wks.cell(row, col + 9).value() = r["time"].get<double>();
+            wks.cell(row, col + 10).value() = r["time_std"].get<double>();
+            try {
+                hyperparameters = r["hyperparameters"].get<string>();
+            }
+            catch (const exception& err) {
+                stringstream oss;
+                oss << r["hyperparameters"];
+                hyperparameters = oss.str();
+            }
+            wks.cell(row, col + 11).value() = hyperparameters;
+            lastResult = r;
+            totalScore += r["score"].get<double>();
+            row++;
+        }
+        if (data["results"].size() == 1) {
+            for (const string& group : { "scores_train", "scores_test", "times_train", "times_test" }) {
+                row++;
+                col = 1;
+                wks.cell(row, col).value() = group;
+                for (double item : lastResult[group]) {
+                    wks.cell(row, ++col).value() = item;
+                }
+            }
+        } else {
+            footer(totalScore, row);
+        }
+    }
+
+    void ReportExcel::footer(double totalScore, int row)
+    {
+        auto score = data["score_name"].get<string>();
+        if (score == BestResult::scoreName()) {
+            wks.cell(row + 2, 1).value() = score + " compared to " + BestResult::title() + " .:  ";
+            wks.cell(row + 2, 5).value() = totalScore / BestResult::score();
+        }
+    }
+}

src/Platform/ReportExcel.h

@@ -0,0 +1,25 @@
+#ifndef REPORTEXCEL_H
+#define REPORTEXCEL_H
+#include <OpenXLSX.hpp>
+#include "ReportBase.h"
+#include "Paths.h"
+#include "Colors.h"
+namespace platform {
+    using namespace std;
+    using namespace OpenXLSX;
+    const int MAXLL = 128;
+    class ReportExcel : public ReportBase{
+    public:
+        explicit ReportExcel(json data_) : ReportBase(data_) {createFile();};
+        virtual ~ReportExcel() {closeFile();};
+    private:
+        void createFile();
+        void closeFile();
+        XLDocument doc;
+        XLWorksheet wks;
+        void header() override;
+        void body() override;
+        void footer(double totalScore, int row);
+    };
+};
+#endif // !REPORTEXCEL_H

src/Platform/Results.cc

@@ -1,7 +1,8 @@
 #include <filesystem>
 #include "platformUtils.h"
 #include "Results.h"
-#include "Report.h"
+#include "ReportConsole.h"
+#include "ReportExcel.h"
 #include "BestResult.h"
 #include "Colors.h"
 namespace platform {
@@ -94,21 +95,26 @@ namespace platform {
         cout << "Invalid index" << endl;
         return -1;
     }
-    void Results::report(const int index) const
+    void Results::report(const int index, const bool excelReport) const
     {
         cout << Colors::YELLOW() << "Reporting " << files.at(index).getFilename() << endl;
         auto data = files.at(index).load();
-        Report report(data);
+        if (excelReport) {
-        report.show();
+            ReportExcel reporter(data);
+            reporter.show();
+        } else {
+            ReportConsole reporter(data);
+            reporter.show();
+        }
     }
     void Results::menu()
     {
         char option;
         int index;
         bool finished = false;
-        string filename, line, options = "qldhsr";
+        string filename, line, options = "qldhsre";
         while (!finished) {
-            cout << Colors::RESET() << "Choose option (quit='q', list='l', delete='d', hide='h', sort='s', report='r'): ";
+            cout << Colors::RESET() << "Choose option (quit='q', list='l', delete='d', hide='h', sort='s', report='r', excel='e'): ";
             getline(cin, line);
             if (line.size() == 0)
                 continue;
@@ -119,12 +125,14 @@ namespace platform {
                 }
                 option = line[0];
             } else {
-                index = stoi(line);
+                if (all_of(line.begin(), line.end(), ::isdigit)) {
-                if (index >= 0 && index < files.size()) {
+                    index = stoi(line);
-                    report(index);
+                    if (index >= 0 && index < files.size()) {
-                } else {
+                        report(index, false);
-                    cout << "Invalid option" << endl;
+                        continue;
+                    }
                 }
+                cout << "Invalid option" << endl;
                 continue;
             }
             switch (option) {
@@ -164,7 +172,13 @@ namespace platform {
                     index = getIndex("report");
                     if (index == -1)
                         break;
-                    report(index);
+                    report(index, false);
+                    break;
+                case 'e':
+                    index = getIndex("excel");
+                    if (index == -1)
+                        break;
+                    report(index, true);
                     break;
                 default:
                     cout << "Invalid option" << endl;
@@ -231,6 +245,7 @@ namespace platform {
             cout << "No results found!" << endl;
             exit(0);
         }
+        sortDate();
         show();
         menu();
         cout << "Done!" << endl;

src/Platform/Results.h

@@ -42,7 +42,7 @@ namespace platform {
         vector<Result> files;
         void load(); // Loads the list of results
         void show() const;
-        void report(const int index) const;
+        void report(const int index, const bool excelReport) const;
         int getIndex(const string& intent) const;
         void menu();
         void sortList();

src/Platform/main.cc

@@ -1,5 +1,6 @@
 #include <iostream>
 #include <argparse/argparse.hpp>
+#include <nlohmann/json.hpp>
 #include "platformUtils.h"
 #include "Experiment.h"
 #include "Datasets.h"
@@ -10,12 +11,14 @@
 
 
 using namespace std;
+using json = nlohmann::json;
 
 argparse::ArgumentParser manageArguments(int argc, char** argv)
 {
     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("-p", "--path")
         .help("folder where the data files are located, default")
         .default_value(string{ platform::Paths::datasets() });
@@ -31,6 +34,7 @@ argparse::ArgumentParser manageArguments(int argc, char** argv)
     );
     program.add_argument("--title").default_value("").help("Experiment title");
     program.add_argument("--discretize").help("Discretize input dataset").default_value((bool)stoi(env.get("discretize"))).implicit_value(true);
+    program.add_argument("--save").help("Save result (always save if no dataset is supplied)").default_value(false).implicit_value(true);
     program.add_argument("--stratified").help("If Stratified KFold is to be done").default_value((bool)stoi(env.get("stratified"))).implicit_value(true);
     program.add_argument("-f", "--folds").help("Number of folds").default_value(stoi(env.get("n_folds"))).scan<'i', int>().action([](const string& value) {
         try {
@@ -59,6 +63,8 @@ argparse::ArgumentParser manageArguments(int argc, char** argv)
         auto seeds = program.get<vector<int>>("seeds");
         auto complete_file_name = path + file_name + ".arff";
         auto title = program.get<string>("title");
+        auto hyperparameters = program.get<string>("hyperparameters");
+        auto saveResults = program.get<bool>("save");
         if (title == "" && file_name == "") {
             throw runtime_error("title is mandatory if dataset is not provided");
         }
@@ -74,7 +80,6 @@ argparse::ArgumentParser manageArguments(int argc, char** argv)
 int main(int argc, char** argv)
 {
     auto program = manageArguments(argc, argv);
-    bool saveResults = false;
     auto file_name = program.get<string>("dataset");
     auto path = program.get<string>("path");
     auto model_name = program.get<string>("model");
@@ -82,9 +87,11 @@ int main(int argc, char** argv)
     auto stratified = program.get<bool>("stratified");
     auto n_folds = program.get<int>("folds");
     auto seeds = program.get<vector<int>>("seeds");
+    auto hyperparameters =program.get<string>("hyperparameters");
     vector<string> filesToTest;
     auto datasets = platform::Datasets(path, true, platform::ARFF);
     auto title = program.get<string>("title");
+    auto saveResults = program.get<bool>("save");
     if (file_name != "") {
         if (!datasets.isDataset(file_name)) {
             cerr << "Dataset " << file_name << " not found" << endl;
@@ -106,6 +113,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(json::parse(hyperparameters));
     for (auto seed : seeds) {
         experiment.addRandomSeed(seed);
     }
@@ -113,10 +121,10 @@ int main(int argc, char** argv)
     timer.start();
     experiment.go(filesToTest, path);
     experiment.setDuration(timer.getDuration());
-    if (saveResults)
+    if (saveResults) {
         experiment.save(platform::Paths::results());
-    else
+    }
-        experiment.report();
+    experiment.report();
     cout << "Done!" << endl;
     return 0;
 }

src/Platform/platformUtils.cc

@@ -69,11 +69,12 @@ tuple<Tensor, Tensor, vector<string>, string, map<string, vector<int>>> loadData
         Xd = torch::zeros({ static_cast<int>(Xr[0].size()), static_cast<int>(Xr.size()) }, torch::kInt32);
         for (int i = 0; i < features.size(); ++i) {
             states[features[i]] = vector<int>(*max_element(Xr[i].begin(), Xr[i].end()) + 1);
-            iota(begin(states[features[i]]), end(states[features[i]]), 0);
+            auto item = states.at(features[i]);
+            iota(begin(item), end(item), 0);
             Xd.index_put_({ "...", i }, torch::tensor(Xr[i], torch::kInt32));
         }
         states[className] = vector<int>(*max_element(y.begin(), y.end()) + 1);
-        iota(begin(states[className]), end(states[className]), 0);
+        iota(begin(states.at(className)), end(states.at(className)), 0);
     } else {
         Xd = torch::zeros({ static_cast<int>(X[0].size()), static_cast<int>(X.size()) }, torch::kFloat32);
         for (int i = 0; i < features.size(); ++i) {