Move check valid hyperparameters to Classifier

Fix maxModels mistake in BoostAODE if !repeatSp
Throw exception if wrong hyperparmeter is supplied
2023-08-22 22:12:20 +02:00 · 2023-08-22 21:55:17 +02:00 · 2023-08-22 12:30:27 +02:00 · 2023-08-22 11:55:15 +02:00 · 2023-08-21 17:51:49 +02:00 · 2023-08-21 17:16:29 +02:00
58 changed files with 849 additions and 285 deletions
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -25,12 +25,15 @@
            "program": "${workspaceFolder}/build/src/Platform/main",
            "args": [
                "-m",
-                "SPODELd",
+                "BoostAODE",
                "-p",
                "/Users/rmontanana/Code/discretizbench/datasets",
+                "--discretize",
                "--stratified",
                "-d",
-                "iris"
+                "glass",
+                "--hyperparameters",
+                "{\"repeatSparent\": true, \"maxModels\": 12}"
            ],
            "cwd": "/Users/rmontanana/Code/discretizbench",
        },
@@ -45,6 +48,14 @@
            ],
            "cwd": "/Users/rmontanana/Code/discretizbench",
        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "list",
+            "program": "${workspaceFolder}/build/src/Platform/list",
+            "args": [],
+            "cwd": "/Users/rmontanana/Code/discretizbench",
+        },
        {
            "name": "Build & debug active file",
            "type": "cppdbg",
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -32,6 +32,29 @@
            ],
            "group": "build",
            "detail": "Task generated by Debugger."
+        },
+        {
+            "type": "cppbuild",
+            "label": "C/C++: g++ build active file",
+            "command": "/usr/bin/g++",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}/${fileBasenameNoExtension}"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "Task generated by Debugger."
        }
    ]
 }
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -55,6 +55,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
 # --------------
--- a/14
+++ b/14
@@ -11,11 +11,21 @@ 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

 build: ## Build the main and BayesNetSample
-	cmake --build build -t main -t BayesNetSample -j 32
+	cmake --build build -t main -t BayesNetSample -t manage -t list -j 32

 clean: ## Clean the debug info
 	@echo ">>> Cleaning Debug BayesNet ...";
@@ -35,7 +45,7 @@ release: ## Build a Release version of the project
 	@if [ -d ./build ]; then rm -rf ./build; fi
 	@mkdir build; 
 	cmake -S . -B build -D CMAKE_BUILD_TYPE=Release; \
-	cmake --build build -t main -t BayesNetSample -j 32;
+	cmake --build build -t main -t BayesNetSample -t manage -t list -j 32;
 	@echo ">>> Done";	

 test: ## Run tests
--- a/lib/Files/CMakeLists.txt
+++ b/lib/Files/CMakeLists.txt
@@ -1,2 +1 @@
-add_library(ArffFiles ArffFiles.cc)
-#target_link_libraries(BayesNet "${TORCH_LIBRARIES}")
+add_library(ArffFiles ArffFiles.cc)
--- a/lib/openXLSX
+++ b/lib/openXLSX
--- a/sample/CMakeLists.txt
+++ b/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}")
--- a/sample/sample.cc
+++ b/sample/sample.cc
@@ -3,6 +3,7 @@
 #include <string>
 #include <map>
 #include <argparse/argparse.hpp>
+#include <nlohmann/json.hpp>
 #include "ArffFiles.h"
 #include "BayesMetrics.h"
 #include "CPPFImdlp.h"
@@ -178,59 +179,59 @@ int main(int argc, char** argv)
    cout << "end." << endl;
    auto score = clf->score(Xd, y);
    cout << "Score: " << score << endl;
-    // auto graph = clf->graph();
-    // auto dot_file = model_name + "_" + file_name;
-    // ofstream file(dot_file + ".dot");
-    // file << graph;
-    // file.close();
-    // cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << endl;
-    // cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << endl;
-    // string stratified_string = stratified ? " Stratified" : "";
-    // cout << nFolds << " Folds" << stratified_string << " Cross validation" << endl;
-    // cout << "==========================================" << endl;
-    // 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);
-    // for (int i = 0; i < features.size(); ++i) {
-    //     Xt.index_put_({ i, "..." }, torch::tensor(Xd[i], torch::kInt32));
-    // }
-    // float total_score = 0, total_score_train = 0, score_train, score_test;
-    // Fold* fold;
-    // if (stratified)
-    //     fold = new StratifiedKFold(nFolds, y, seed);
-    // else
-    //     fold = new KFold(nFolds, y.size(), seed);
-    // for (auto i = 0; i < nFolds; ++i) {
-    //     auto [train, test] = fold->getFold(i);
-    //     cout << "Fold: " << i + 1 << endl;
-    //     if (tensors) {
-    //         auto ttrain = torch::tensor(train, torch::kInt64);
-    //         auto ttest = torch::tensor(test, torch::kInt64);
-    //         torch::Tensor Xtraint = torch::index_select(Xt, 1, ttrain);
-    //         torch::Tensor ytraint = yt.index({ ttrain });
-    //         torch::Tensor Xtestt = torch::index_select(Xt, 1, ttest);
-    //         torch::Tensor ytestt = yt.index({ ttest });
-    //         clf->fit(Xtraint, ytraint, features, className, states);
-    //         auto temp = clf->predict(Xtraint);
-    //         score_train = clf->score(Xtraint, ytraint);
-    //         score_test = clf->score(Xtestt, ytestt);
-    //     } else {
-    //         auto [Xtrain, ytrain] = extract_indices(train, Xd, y);
-    //         auto [Xtest, ytest] = extract_indices(test, Xd, y);
-    //         clf->fit(Xtrain, ytrain, features, className, states);
-    //         score_train = clf->score(Xtrain, ytrain);
-    //         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;
+    auto graph = clf->graph();
+    auto dot_file = model_name + "_" + file_name;
+    ofstream file(dot_file + ".dot");
+    file << graph;
+    file.close();
+    cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << endl;
+    cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << endl;
+    string stratified_string = stratified ? " Stratified" : "";
+    cout << nFolds << " Folds" << stratified_string << " Cross validation" << endl;
+    cout << "==========================================" << endl;
+    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);
+    for (int i = 0; i < features.size(); ++i) {
+        Xt.index_put_({ i, "..." }, torch::tensor(Xd[i], torch::kInt32));
+    }
+    float total_score = 0, total_score_train = 0, score_train, score_test;
+    Fold* fold;
+    if (stratified)
+        fold = new StratifiedKFold(nFolds, y, seed);
+    else
+        fold = new KFold(nFolds, y.size(), seed);
+    for (auto i = 0; i < nFolds; ++i) {
+        auto [train, test] = fold->getFold(i);
+        cout << "Fold: " << i + 1 << endl;
+        if (tensors) {
+            auto ttrain = torch::tensor(train, torch::kInt64);
+            auto ttest = torch::tensor(test, torch::kInt64);
+            torch::Tensor Xtraint = torch::index_select(Xt, 1, ttrain);
+            torch::Tensor ytraint = yt.index({ ttrain });
+            torch::Tensor Xtestt = torch::index_select(Xt, 1, ttest);
+            torch::Tensor ytestt = yt.index({ ttest });
+            clf->fit(Xtraint, ytraint, features, className, states);
+            auto temp = clf->predict(Xtraint);
+            score_train = clf->score(Xtraint, ytraint);
+            score_test = clf->score(Xtestt, ytestt);
+        } else {
+            auto [Xtrain, ytrain] = extract_indices(train, Xd, y);
+            auto [Xtest, ytest] = extract_indices(test, Xd, y);
+            clf->fit(Xtrain, ytrain, features, className, states);
+            score_train = clf->score(Xtrain, ytrain);
+            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;
 }
--- a/src/BayesNet/AODE.cc
+++ b/src/BayesNet/AODE.cc
@@ -2,12 +2,14 @@

 namespace bayesnet {
    AODE::AODE() : Ensemble() {}
-    void AODE::buildModel()
+    void AODE::buildModel(const torch::Tensor& weights)
    {
        models.clear();
        for (int i = 0; i < features.size(); ++i) {
            models.push_back(std::make_unique<SPODE>(i));
        }
+        n_models = models.size();
+        significanceModels = vector<double>(n_models, 1.0);
    }
    vector<string> AODE::graph(const string& title) const
    {
--- a/src/BayesNet/AODE.h
+++ b/src/BayesNet/AODE.h
@@ -5,11 +5,12 @@
 namespace bayesnet {
    class AODE : public Ensemble {
    protected:
-        void buildModel() override;
+        void buildModel(const torch::Tensor& weights) override;
    public:
        AODE();
        virtual ~AODE() {};
        vector<string> graph(const string& title = "AODE") const override;
+        void setHyperparameters(nlohmann::json& hyperparameters) override {};
    };
 }
 #endif
--- a/src/BayesNet/AODELd.cc
+++ b/src/BayesNet/AODELd.cc
@@ -19,7 +19,7 @@ namespace bayesnet {
        return *this;

    }
-    void AODELd::buildModel()
+    void AODELd::buildModel(const torch::Tensor& weights)
    {
        models.clear();
        for (int i = 0; i < features.size(); ++i) {
@@ -27,7 +27,7 @@ namespace bayesnet {
        }
        n_models = models.size();
    }
-    void AODELd::trainModel()
+    void AODELd::trainModel(const torch::Tensor& weights)
    {
        for (const auto& model : models) {
            model->fit(Xf, y, features, className, states);
--- a/src/BayesNet/AODELd.h
+++ b/src/BayesNet/AODELd.h
@@ -8,14 +8,15 @@ namespace bayesnet {
    using namespace std;
    class AODELd : public Ensemble, public Proposal {
    protected:
-        void trainModel() override;
-        void buildModel() override;
+        void trainModel(const torch::Tensor& weights) override;
+        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;
        virtual ~AODELd() = default;
        vector<string> graph(const string& name = "AODE") const override;
        static inline string version() { return "0.0.1"; };
+        void setHyperparameters(nlohmann::json& hyperparameters) override {};
    };
 }
 #endif // !AODELD_H
--- a/src/BayesNet/BaseClassifier.h
+++ b/src/BayesNet/BaseClassifier.h
@@ -1,18 +1,20 @@
 #ifndef BASE_H
 #define BASE_H
 #include <torch/torch.h>
+#include <nlohmann/json.hpp>
 #include <vector>
 namespace bayesnet {
    using namespace std;
    class BaseClassifier {
    protected:
-        virtual void trainModel() = 0;
+        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;
        // 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& dataset, vector<string>& features, 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() = default;
        torch::Tensor virtual predict(torch::Tensor& X) = 0;
        vector<int> virtual predict(vector<vector<int>>& X) = 0;
@@ -26,6 +28,7 @@ namespace bayesnet {
        const string inline getVersion() const { return "0.1.0"; };
        vector<string> virtual topological_order() = 0;
        void virtual dump_cpt()const = 0;
+        virtual void setHyperparameters(nlohmann::json& hyperparameters) = 0;
    };
 }
 #endif
--- a/src/BayesNet/BayesMetrics.cc
+++ b/src/BayesNet/BayesMetrics.cc
@@ -21,6 +21,45 @@ namespace bayesnet {
        }
        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
    }
+    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.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
+        if (ascending) {
+            sort(featuresKBest.begin(), featuresKBest.end(), [&](int i, int j)
+                { return scoresKBest[i] < scoresKBest[j]; });
+            sort(scoresKBest.begin(), scoresKBest.end(), std::less<double>());
+            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
+    {
+        return scoresKBest;
+    }
    vector<pair<string, string>> Metrics::doCombinations(const vector<string>& source)
    {
        vector<pair<string, string>> result;
@@ -32,17 +71,18 @@ namespace bayesnet {
        }
        return result;
    }
-    torch::Tensor Metrics::conditionalEdge()
+    torch::Tensor Metrics::conditionalEdge(const torch::Tensor& weights)
    {
        auto result = vector<double>();
        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 });
+        auto margin = torch::zeros({ classNumStates }, torch::kFloat);
        for (int value = 0; value < classNumStates; ++value) {
            auto mask = samples.index({ -1,  "..." }) == value;
-            margin[value] = mask.sum().item<float>() / samples.size(1);
+            margin[value] = mask.sum().item<double>() / samples.size(1);
        }
        for (auto [first, second] : combinations) {
            int index_first = find(features.begin(), features.end(), first) - features.begin();
@@ -52,8 +92,9 @@ namespace bayesnet {
                auto mask = samples.index({ -1, "..." }) == value;
                auto first_dataset = samples.index({ index_first, mask });
                auto second_dataset = samples.index({ index_second, mask });
-                auto mi = mutualInformation(first_dataset, second_dataset);
-                auto pb = margin[value].item<float>();
+                auto weights_dataset = weights.index({ mask });
+                auto mi = mutualInformation(first_dataset, second_dataset, weights_dataset);
+                auto pb = margin[value].item<double>();
                accumulated += pb * mi;
            }
            result.push_back(accumulated);
@@ -70,31 +111,32 @@ namespace bayesnet {
        return matrix;
    }
    // To use in Python
-    vector<float> Metrics::conditionalEdgeWeights()
+    vector<float> Metrics::conditionalEdgeWeights(vector<float>& weights_)
    {
-        auto matrix = conditionalEdge();
+        const torch::Tensor weights = torch::tensor(weights_);
+        auto matrix = conditionalEdge(weights);
        std::vector<float> v(matrix.data_ptr<float>(), matrix.data_ptr<float>() + matrix.numel());
        return v;
    }
-    double Metrics::entropy(const torch::Tensor& feature)
+    double Metrics::entropy(const torch::Tensor& feature, const torch::Tensor& weights)
    {
-        torch::Tensor counts = feature.bincount();
-        int totalWeight = counts.sum().item<int>();
+        torch::Tensor counts = feature.bincount(weights);
+        double totalWeight = counts.sum().item<double>();
        torch::Tensor probs = counts.to(torch::kFloat) / totalWeight;
        torch::Tensor logProbs = torch::log(probs);
        torch::Tensor entropy = -probs * logProbs;
        return entropy.nansum().item<double>();
    }
    // H(Y|X) = sum_{x in X} p(x) H(Y|X=x)
-    double Metrics::conditionalEntropy(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature)
+    double Metrics::conditionalEntropy(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature, const torch::Tensor& weights)
    {
        int numSamples = firstFeature.sizes()[0];
-        torch::Tensor featureCounts = secondFeature.bincount();
+        torch::Tensor featureCounts = secondFeature.bincount(weights);
        unordered_map<int, unordered_map<int, double>> jointCounts;
        double totalWeight = 0;
        for (auto i = 0; i < numSamples; i++) {
-            jointCounts[secondFeature[i].item<int>()][firstFeature[i].item<int>()] += 1;
-            totalWeight += 1;
+            jointCounts[secondFeature[i].item<int>()][firstFeature[i].item<int>()] += weights[i].item<double>();
+            totalWeight += weights[i].item<float>();
        }
        if (totalWeight == 0)
            return 0;
@@ -115,9 +157,9 @@ namespace bayesnet {
        return entropyValue;
    }
    // I(X;Y) = H(Y) - H(Y|X)
-    double Metrics::mutualInformation(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature)
+    double Metrics::mutualInformation(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature, const torch::Tensor& weights)
    {
-        return entropy(firstFeature) - conditionalEntropy(firstFeature, secondFeature);
+        return entropy(firstFeature, weights) - conditionalEntropy(firstFeature, secondFeature, weights);
    }
    /*
    Compute the maximum spanning tree considering the weights as distances
--- a/src/BayesNet/BayesMetrics.h
+++ b/src/BayesNet/BayesMetrics.h
@@ -12,16 +12,20 @@ namespace bayesnet {
        vector<string> features;
        string className;
        int classNumStates = 0;
+        vector<double> scoresKBest;
+        vector<int> featuresKBest; // sorted indices of the features
+        double entropy(const Tensor& feature, const Tensor& weights);
+        double conditionalEntropy(const Tensor& firstFeature, const Tensor& secondFeature, const Tensor& weights);
+        vector<pair<string, string>> doCombinations(const vector<string>&);
    public:
        Metrics() = default;
-        Metrics(const Tensor&, const vector<string>&, const string&, const int);
-        Metrics(const vector<vector<int>>&, const vector<int>&, const vector<string>&, const string&, const int);
-        double entropy(const Tensor&);
-        double conditionalEntropy(const Tensor&, const Tensor&);
-        double mutualInformation(const Tensor&, const Tensor&);
-        vector<float> conditionalEdgeWeights(); // To use in Python
-        Tensor conditionalEdge();
-        vector<pair<string, string>> doCombinations(const vector<string>&);
+        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, 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
+        Tensor conditionalEdge(const torch::Tensor& weights);
        vector<pair<int, int>> maximumSpanningTree(const vector<string>& features, const Tensor& weights, const int root);
    };
 }
--- a/src/BayesNet/BoostAODE.cc
+++ b/src/BayesNet/BoostAODE.cc
@@ -0,0 +1,91 @@
+#include "BoostAODE.h"
+#include <set>
+#include "BayesMetrics.h"
+
+namespace bayesnet {
+    BoostAODE::BoostAODE() : Ensemble() {}
+    void BoostAODE::buildModel(const torch::Tensor& weights)
+    {
+        // 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;
+        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;
+        unordered_set<int> featuresUsed;
+        // Step 0: Set the finish condition
+        // if not repeatSparent a finish condition is run out of features
+        // n_models == maxModels
+        int numClasses = states[className].size();
+        while (!exitCondition) {
+            // Step 1: Build ranking with mutual information
+            auto featureSelection = metrics.SelectKBestWeighted(weights_, ascending, n); // Get all the features sorted
+            unique_ptr<Classifier> model;
+            auto feature = featureSelection[0];
+            if (!repeatSparent || featuresUsed.size() < featureSelection.size()) {
+                bool found = false;
+                for (auto feat : featureSelection) {
+                    if (find(featuresUsed.begin(), featuresUsed.end(), feat) != featuresUsed.end()) {
+                        continue;
+                    }
+                    found = true;
+                    feature = feat;
+                    break;
+                }
+                if (!found) {
+                    exitCondition = true;
+                    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
+            auto mask_wrong = ypred != y_;
+            auto masked_weights = weights_ * mask_wrong.to(weights_.dtype());
+            double wrongWeights = masked_weights.sum().item<double>();
+            double significance = wrongWeights == 0 ? 1 : 0.5 * log((1 - wrongWeights) / wrongWeights);
+            // Step 3.2: Update weights for next classifier
+            // Step 3.2.1: Update weights of wrong samples
+            weights_ += mask_wrong.to(weights_.dtype()) * exp(significance) * weights_;
+            // Step 3.3: Normalise the weights
+            double totalWeights = torch::sum(weights_).item<double>();
+            weights_ = weights_ / totalWeights;
+            // Step 3.4: Store classifier and its accuracy to weigh its future vote
+            models.push_back(std::move(model));
+            significanceModels.push_back(significance);
+            exitCondition = n_models == maxModels && repeatSparent;
+        }
+        if (featuresUsed.size() != features.size()) {
+            cout << "Warning: BoostAODE did not use all the features" << endl;
+        }
+        weights.copy_(weights_);
+    }
+    vector<string> BoostAODE::graph(const string& title) const
+    {
+        return Ensemble::graph(title);
+    }
+}
--- a/src/BayesNet/BoostAODE.h
+++ b/src/BayesNet/BoostAODE.h
@@ -0,0 +1,21 @@
+#ifndef BOOSTAODE_H
+#define BOOSTAODE_H
+#include "Ensemble.h"
+#include "SPODE.h"
+namespace bayesnet {
+    class BoostAODE : public Ensemble {
+    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
--- a/src/BayesNet/CMakeLists.txt
+++ b/src/BayesNet/CMakeLists.txt
@@ -1,7 +1,9 @@
 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 
-    KDB.cc TAN.cc SPODE.cc Ensemble.cc AODE.cc TANLd.cc KDBLd.cc SPODELd.cc AODELd.cc Mst.cc Proposal.cc ${BayesNet_SOURCE_DIR}/src/Platform/Models.cc)
-target_link_libraries(BayesNet mdlp ArffFiles "${TORCH_LIBRARIES}")
+    KDB.cc TAN.cc SPODE.cc Ensemble.cc AODE.cc TANLd.cc KDBLd.cc SPODELd.cc AODELd.cc BoostAODE.cc 
+    Mst.cc Proposal.cc ${BayesNet_SOURCE_DIR}/src/Platform/Models.cc)
+target_link_libraries(BayesNet mdlp "${TORCH_LIBRARIES}")
--- a/src/BayesNet/Classifier.cc
+++ b/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)
+    Classifier& Classifier::build(vector<string>& features, string className, map<string, vector<int>>& states, const torch::Tensor& weights)
    {
        this->features = features;
        this->className = className;
@@ -16,12 +16,11 @@ namespace bayesnet {
        auto n_classes = states[className].size();
        metrics = Metrics(dataset, features, className, n_classes);
        model.initialize();
-        buildModel();
-        trainModel();
+        buildModel(weights);
+        trainModel(weights);
        fitted = true;
        return *this;
    }
-
    void Classifier::buildDataset(Tensor& ytmp)
    {
        try {
@@ -35,16 +34,17 @@ namespace bayesnet {
            exit(1);
        }
    }
-    void Classifier::trainModel()
+    void Classifier::trainModel(const torch::Tensor& weights)
    {
-        model.fit(dataset, features, className, states);
+        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)
    {
        dataset = X;
        buildDataset(y);
-        return build(features, className, states);
+        const torch::Tensor weights = torch::full({ dataset.size(1) }, 1.0 / dataset.size(1), torch::kDouble);
+        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)
@@ -55,12 +55,19 @@ namespace bayesnet {
        }
        auto ytmp = torch::tensor(y, kInt32);
        buildDataset(ytmp);
-        return build(features, className, states);
+        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)
    {
        this->dataset = dataset;
-        return build(features, className, states);
+        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)
+    {
+        this->dataset = dataset;
+        return build(features, className, states, weights);
    }
    void Classifier::checkFitParameters()
    {
@@ -145,4 +152,12 @@ 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");
+            }
+        }
+    }
 }
--- a/src/BayesNet/Classifier.h
+++ b/src/BayesNet/Classifier.h
@@ -11,25 +11,27 @@ namespace bayesnet {
    class Classifier : public BaseClassifier {
    private:
        void buildDataset(torch::Tensor& y);
-        Classifier& build(vector<string>& features, string className, map<string, vector<int>>& states);
+        Classifier& build(vector<string>& features, string className, map<string, vector<int>>& states, const torch::Tensor& weights);
    protected:
        bool fitted;
-        Network model;
        int m, n; // m: number of samples, n: number of features
-        Tensor dataset; // (n+1)xm tensor
+        Network model;
        Metrics metrics;
        vector<string> features;
        string className;
        map<string, vector<int>> states;
+        Tensor dataset; // (n+1)xm tensor
        void checkFitParameters();
-        virtual void buildModel() = 0;
-        void trainModel() override;
+        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(torch::Tensor& X, torch::Tensor& y, vector<string>& features, 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, vector<string>& features, string className, map<string, vector<int>>& states, const torch::Tensor& weights) override;
        void addNodes();
        int getNumberOfNodes() const override;
        int getNumberOfEdges() const override;
--- a/src/BayesNet/Ensemble.cc
+++ b/src/BayesNet/Ensemble.cc
@@ -5,7 +5,7 @@ namespace bayesnet {

    Ensemble::Ensemble() : Classifier(Network()) {}

-    void Ensemble::trainModel()
+    void Ensemble::trainModel(const torch::Tensor& weights)
    {
        n_models = models.size();
        for (auto i = 0; i < n_models; ++i) {
@@ -18,9 +18,9 @@ namespace bayesnet {
        auto y_pred_ = y_pred.accessor<int, 2>();
        vector<int> y_pred_final;
        for (int i = 0; i < y_pred.size(0); ++i) {
-            vector<float> votes(y_pred.size(1), 0);
+            vector<double> votes(y_pred.size(1), 0);
            for (int j = 0; j < y_pred.size(1); ++j) {
-                votes[y_pred_[i][j]] += 1;
+                votes[y_pred_[i][j]] += significanceModels[j];
            }
            // argsort in descending order
            auto indices = argsort(votes);
--- a/src/BayesNet/Ensemble.h
+++ b/src/BayesNet/Ensemble.h
@@ -14,7 +14,8 @@ namespace bayesnet {
    protected:
        unsigned n_models;
        vector<unique_ptr<Classifier>> models;
-        void trainModel() override;
+        vector<double> significanceModels;
+        void trainModel(const torch::Tensor& weights) override;
        vector<int> voting(Tensor& y_pred);
    public:
        Ensemble();
--- a/src/BayesNet/KDB.cc
+++ b/src/BayesNet/KDB.cc
@@ -4,7 +4,7 @@ namespace bayesnet {
    using namespace torch;

    KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta) {}
-    void KDB::buildModel()
+    void KDB::buildModel(const torch::Tensor& weights)
    {
        /*
        1. For each feature Xi, compute mutual information, I(X;C),
@@ -29,13 +29,13 @@ namespace bayesnet {
        // where C is the class.
        addNodes();
        const Tensor& y = dataset.index({ -1, "..." });
-        vector <float> mi;
+        vector<double> mi;
        for (auto i = 0; i < features.size(); i++) {
            Tensor firstFeature = dataset.index({ i, "..." });
-            mi.push_back(metrics.mutualInformation(firstFeature, y));
+            mi.push_back(metrics.mutualInformation(firstFeature, y, weights));
        }
        // 2. Compute class conditional mutual information I(Xi;XjIC), f or each
-        auto conditionalEdgeWeights = metrics.conditionalEdge();
+        auto conditionalEdgeWeights = metrics.conditionalEdge(weights);
        // 3. Let the used variable list, S, be empty.
        vector<int> S;
        // 4. Let the DAG network being constructed, BN, begin with a single
--- a/src/BayesNet/KDB.h
+++ b/src/BayesNet/KDB.h
@@ -1,5 +1,6 @@
 #ifndef KDB_H
 #define KDB_H
+#include <torch/torch.h>
 #include "Classifier.h"
 #include "bayesnetUtils.h"
 namespace bayesnet {
@@ -11,10 +12,11 @@ namespace bayesnet {
        float theta;
        void add_m_edges(int idx, vector<int>& S, Tensor& weights);
    protected:
-        void buildModel() override;
+        void buildModel(const torch::Tensor& weights) override;
    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;
    };
 }
--- a/src/BayesNet/KDBLd.h
+++ b/src/BayesNet/KDBLd.h
@@ -13,6 +13,7 @@ namespace bayesnet {
        KDBLd& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
        vector<string> graph(const string& name = "KDB") const override;
        Tensor predict(Tensor& X) override;
+        void setHyperparameters(nlohmann::json& hyperparameters) override {};
        static inline string version() { return "0.0.1"; };
    };
 }
--- a/src/BayesNet/Network.cc
+++ b/src/BayesNet/Network.cc
@@ -5,7 +5,6 @@
 namespace bayesnet {
    Network::Network() : features(vector<string>()), className(""), classNumStates(0), fitted(false) {}
    Network::Network(float maxT) : features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
-    Network::Network(float maxT, int smoothing) : laplaceSmoothing(smoothing), features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
    Network::Network(Network& other) : laplaceSmoothing(other.laplaceSmoothing), features(other.features), className(other.className), classNumStates(other.getClassNumStates()), maxThreads(other.
        getmaxThreads()), fitted(other.fitted)
    {
@@ -104,8 +103,11 @@ namespace bayesnet {
    {
        return nodes;
    }
-    void Network::checkFitData(int n_samples, int n_features, int n_samples_y, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
+    void Network::checkFitData(int n_samples, int n_features, int n_samples_y, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states, const torch::Tensor& weights)
    {
+        if (weights.size(0) != n_samples) {
+            throw invalid_argument("Weights (" + to_string(weights.size(0)) + ") must have the same number of elements as samples (" + to_string(n_samples) + ") in Network::fit");
+        }
        if (n_samples != n_samples_y) {
            throw invalid_argument("X and y must have the same number of samples in Network::fit (" + to_string(n_samples) + " != " + to_string(n_samples_y) + ")");
        }
@@ -136,28 +138,29 @@ namespace bayesnet {
        classNumStates = nodes[className]->getNumStates();
    }
    // X comes in nxm, where n is the number of features and m the number of samples
-    void Network::fit(const torch::Tensor& X, const torch::Tensor& y, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
+    void Network::fit(const torch::Tensor& X, const torch::Tensor& y, const torch::Tensor& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
    {
-        checkFitData(X.size(1), X.size(0), y.size(0), featureNames, className, states);
+        checkFitData(X.size(1), X.size(0), y.size(0), featureNames, className, states, weights);
        this->className = className;
        Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1);
        samples = torch::cat({ X , ytmp }, 0);
        for (int i = 0; i < featureNames.size(); ++i) {
            auto row_feature = X.index({ i, "..." });
        }
-        completeFit(states);
+        completeFit(states, weights);
    }
-    void Network::fit(const torch::Tensor& samples, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
+    void Network::fit(const torch::Tensor& samples, const torch::Tensor& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
    {
-        checkFitData(samples.size(1), samples.size(0) - 1, samples.size(1), featureNames, className, states);
+        checkFitData(samples.size(1), samples.size(0) - 1, samples.size(1), featureNames, className, states, weights);
        this->className = className;
        this->samples = samples;
-        completeFit(states);
+        completeFit(states, weights);
    }
    // input_data comes in nxm, where n is the number of features and m the number of samples
-    void Network::fit(const vector<vector<int>>& input_data, const vector<int>& labels, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
+    void Network::fit(const vector<vector<int>>& input_data, const vector<int>& labels, const vector<float>& weights_, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
    {
-        checkFitData(input_data[0].size(), input_data.size(), labels.size(), featureNames, className, states);
+        const torch::Tensor weights = torch::tensor(weights_, torch::kFloat64);
+        checkFitData(input_data[0].size(), input_data.size(), labels.size(), featureNames, className, states, weights);
        this->className = className;
        // Build tensor of samples (nxm) (n+1 because of the class)
        samples = torch::zeros({ static_cast<int>(input_data.size() + 1), static_cast<int>(input_data[0].size()) }, torch::kInt32);
@@ -165,11 +168,12 @@ namespace bayesnet {
            samples.index_put_({ i, "..." }, torch::tensor(input_data[i], torch::kInt32));
        }
        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
-        completeFit(states);
+        completeFit(states, weights);
    }
-    void Network::completeFit(const map<string, vector<int>>& states)
+    void Network::completeFit(const map<string, vector<int>>& states, const torch::Tensor& weights)
    {
        setStates(states);
+        laplaceSmoothing = 1.0 / samples.size(1); // To use in CPT computation
        int maxThreadsRunning = static_cast<int>(std::thread::hardware_concurrency() * maxThreads);
        if (maxThreadsRunning < 1) {
            maxThreadsRunning = 1;
@@ -182,7 +186,7 @@ namespace bayesnet {
        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]() {
+            threads.emplace_back([this, &nextNodeIndex, &mtx, &cv, &activeThreads, &weights]() {
                while (true) {
                    unique_lock<mutex> lock(mtx);
                    if (nextNodeIndex >= nodes.size()) {
@@ -191,7 +195,7 @@ namespace bayesnet {
                    auto& pair = *std::next(nodes.begin(), nextNodeIndex);
                    ++nextNodeIndex;
                    lock.unlock();
-                    pair.second->computeCPT(samples, features, laplaceSmoothing);
+                    pair.second->computeCPT(samples, features, laplaceSmoothing, weights);
                    lock.lock();
                    nodes[pair.first] = std::move(pair.second);
                    lock.unlock();
@@ -343,7 +347,7 @@ namespace bayesnet {
        }
        // Normalize result
        double sum = accumulate(result.begin(), result.end(), 0.0);
-        transform(result.begin(), result.end(), result.begin(), [sum](double& value) { return value / sum; });
+        transform(result.begin(), result.end(), result.begin(), [sum](const double& value) { return value / sum; });
        return result;
    }
    vector<string> Network::show() const
@@ -431,6 +435,7 @@ namespace bayesnet {
    {
        for (auto& node : nodes) {
            cout << "* " << node.first << ": (" << node.second->getNumStates() << ") : " << node.second->getCPT().sizes() << endl;
+            cout << node.second->getCPT() << endl;
        }
    }
 }
--- a/src/BayesNet/Network.h
+++ b/src/BayesNet/Network.h
@@ -13,19 +13,18 @@ namespace bayesnet {
        int classNumStates;
        vector<string> features; // Including classname
        string className;
-        int laplaceSmoothing = 1;
+        double laplaceSmoothing;
        torch::Tensor samples; // nxm tensor used to fit the model
        bool isCyclic(const std::string&, std::unordered_set<std::string>&, std::unordered_set<std::string>&);
        vector<double> predict_sample(const vector<int>&);
        vector<double> predict_sample(const torch::Tensor&);
        vector<double> exactInference(map<string, int>&);
        double computeFactor(map<string, int>&);
-        void completeFit(const map<string, vector<int>>&);
-        void checkFitData(int n_features, int n_samples, int n_samples_y, const vector<string>& featureNames, const string& className, const map<string, vector<int>>&);
+        void completeFit(const map<string, vector<int>>& states, const torch::Tensor& weights);
+        void checkFitData(int n_features, int n_samples, int n_samples_y, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states, const torch::Tensor& weights);
        void setStates(const map<string, vector<int>>&);
    public:
        Network();
-        explicit Network(float, int);
        explicit Network(float);
        explicit Network(Network&);
        torch::Tensor& getSamples();
@@ -39,9 +38,9 @@ namespace bayesnet {
        int getNumEdges() const;
        int getClassNumStates() const;
        string getClassName() const;
-        void fit(const vector<vector<int>>&, const vector<int>&, const vector<string>&, const string&, const map<string, vector<int>>&);
-        void fit(const torch::Tensor&, const torch::Tensor&, const vector<string>&, const string&, const map<string, vector<int>>&);
-        void fit(const torch::Tensor&, const vector<string>&, const string&, const map<string, vector<int>>&);
+        void fit(const vector<vector<int>>& input_data, const vector<int>& labels, const vector<float>& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states);
+        void fit(const torch::Tensor& X, const torch::Tensor& y, const torch::Tensor& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states);
+        void fit(const torch::Tensor& samples, const torch::Tensor& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states);
        vector<int> predict(const vector<vector<int>>&); // Return mx1 vector of predictions
        torch::Tensor predict(const torch::Tensor&); // Return mx1 tensor of predictions
        torch::Tensor predict_tensor(const torch::Tensor& samples, const bool proba);
--- a/src/BayesNet/Node.cc
+++ b/src/BayesNet/Node.cc
@@ -84,7 +84,7 @@ namespace bayesnet {
        }
        return result;
    }
-    void Node::computeCPT(const torch::Tensor& dataset, const vector<string>& features, const int laplaceSmoothing)
+    void Node::computeCPT(const torch::Tensor& dataset, const vector<string>& features, const double laplaceSmoothing, const torch::Tensor& weights)
    {
        dimensions.clear();
        // Get dimensions of the CPT
@@ -111,7 +111,7 @@ namespace bayesnet {
                coordinates.push_back(dataset.index({ parent_index, n_sample }));
            }
            // Increment the count of the corresponding coordinate
-            cpTable.index_put_({ coordinates }, cpTable.index({ coordinates }) + 1);
+            cpTable.index_put_({ coordinates }, cpTable.index({ coordinates }) + weights.index({ n_sample }).item<double>());
        }
        // Normalize the counts
        cpTable = cpTable / cpTable.sum(0);
--- a/src/BayesNet/Node.h
+++ b/src/BayesNet/Node.h
@@ -26,7 +26,7 @@ namespace bayesnet {
        vector<Node*>& getParents();
        vector<Node*>& getChildren();
        torch::Tensor& getCPT();
-        void computeCPT(const torch::Tensor&, const vector<string>&, const int);
+        void computeCPT(const torch::Tensor& dataset, const vector<string>& features, const double laplaceSmoothing, const torch::Tensor& weights);
        int getNumStates() const;
        void setNumStates(int);
        unsigned minFill();
--- a/src/BayesNet/Proposal.cc
+++ b/src/BayesNet/Proposal.cc
@@ -65,7 +65,8 @@ namespace bayesnet {
                //Update new states of the feature/node
                states[pFeatures[index]] = xStates;
            }
-            model.fit(pDataset, pFeatures, pClassName, states);
+            const torch::Tensor weights = torch::full({ pDataset.size(1) }, 1.0 / pDataset.size(1), torch::kDouble);
+            model.fit(pDataset, weights, pFeatures, pClassName, states);
        }
        return states;
    }
--- a/src/BayesNet/SPODE.cc
+++ b/src/BayesNet/SPODE.cc
@@ -4,7 +4,7 @@ namespace bayesnet {

    SPODE::SPODE(int root) : Classifier(Network()), root(root) {}

-    void SPODE::buildModel()
+    void SPODE::buildModel(const torch::Tensor& weights)
    {
        // 0. Add all nodes to the model
        addNodes();
--- a/src/BayesNet/SPODE.h
+++ b/src/BayesNet/SPODE.h
@@ -7,11 +7,12 @@ namespace bayesnet {
    private:
        int root;
    protected:
-        void buildModel() override;
+        void buildModel(const torch::Tensor& weights) override;
    public:
        explicit SPODE(int root);
        virtual ~SPODE() {};
        vector<string> graph(const string& name = "SPODE") const override;
+        void setHyperparameters(nlohmann::json& hyperparameters) override {};
    };
 }
 #endif
--- a/src/BayesNet/SPODELd.cc
+++ b/src/BayesNet/SPODELd.cc
@@ -21,7 +21,6 @@ namespace bayesnet {
    SPODELd& SPODELd::fit(torch::Tensor& dataset, vector<string>& features_, string className_, map<string, vector<int>>& states_)
    {
        Xf = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), "..." }).clone();
-        cout << "Xf " << Xf.sizes() << " dtype: " << Xf.dtype() << endl;
        y = dataset.index({ -1, "..." }).clone();
        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
        features = features_;
--- a/src/BayesNet/SPODELd.h
+++ b/src/BayesNet/SPODELd.h
@@ -13,6 +13,7 @@ namespace bayesnet {
        SPODELd& fit(torch::Tensor& dataset, vector<string>& features, string className, map<string, vector<int>>& states) override;
        vector<string> graph(const string& name = "SPODE") const override;
        Tensor predict(Tensor& X) override;
+        void setHyperparameters(nlohmann::json& hyperparameters) override {};
        static inline string version() { return "0.0.1"; };
    };
 }
--- a/src/BayesNet/TAN.cc
+++ b/src/BayesNet/TAN.cc
@@ -5,7 +5,7 @@ namespace bayesnet {

    TAN::TAN() : Classifier(Network()) {}

-    void TAN::buildModel()
+    void TAN::buildModel(const torch::Tensor& weights)
    {
        // 0. Add all nodes to the model
        addNodes();
@@ -15,15 +15,15 @@ namespace bayesnet {
        Tensor class_dataset = dataset.index({ -1, "..." });
        for (int i = 0; i < static_cast<int>(features.size()); ++i) {
            Tensor feature_dataset = dataset.index({ i, "..." });
-            auto mi_value = metrics.mutualInformation(class_dataset, feature_dataset);
+            auto mi_value = metrics.mutualInformation(class_dataset, feature_dataset, weights);
            mi.push_back({ i, mi_value });
        }
        sort(mi.begin(), mi.end(), [](const auto& left, const auto& right) {return left.second < right.second;});
        auto root = mi[mi.size() - 1].first;
        // 2. Compute mutual information between each feature and the class
-        auto weights = metrics.conditionalEdge();
+        auto weights_matrix = metrics.conditionalEdge(weights);
        // 3. Compute the maximum spanning tree
-        auto mst = metrics.maximumSpanningTree(features, weights, root);
+        auto mst = metrics.maximumSpanningTree(features, weights_matrix, root);
        // 4. Add edges from the maximum spanning tree to the model
        for (auto i = 0; i < mst.size(); ++i) {
            auto [from, to] = mst[i];
--- a/src/BayesNet/TAN.h
+++ b/src/BayesNet/TAN.h
@@ -3,15 +3,15 @@
 #include "Classifier.h"
 namespace bayesnet {
    using namespace std;
-    using namespace torch;
    class TAN : public Classifier {
    private:
    protected:
-        void buildModel() override;
+        void buildModel(const torch::Tensor& weights) override;
    public:
        TAN();
        virtual ~TAN() {};
        vector<string> graph(const string& name = "TAN") const override;
+        void setHyperparameters(nlohmann::json& hyperparameters) override {};
    };
 }
 #endif
--- a/src/BayesNet/TANLd.h
+++ b/src/BayesNet/TANLd.h
@@ -14,6 +14,7 @@ namespace bayesnet {
        vector<string> graph(const string& name = "TAN") const override;
        Tensor predict(Tensor& X) override;
        static inline string version() { return "0.0.1"; };
+        void setHyperparameters(nlohmann::json& hyperparameters) override {};
    };
 }
 #endif // !TANLD_H
--- a/src/BayesNet/bayesnetUtils.cc
+++ b/src/BayesNet/bayesnetUtils.cc
@@ -4,7 +4,7 @@ namespace bayesnet {
    using namespace std;
    using namespace torch;
    // Return the indices in descending order
-    vector<int> argsort(vector<float>& nums)
+    vector<int> argsort(vector<double>& nums)
    {
        int n = nums.size();
        vector<int> indices(n);
--- a/src/BayesNet/bayesnetUtils.h
+++ b/src/BayesNet/bayesnetUtils.h
@@ -5,7 +5,7 @@
 namespace bayesnet {
    using namespace std;
    using namespace torch;
-    vector<int> argsort(vector<float>& nums);
+    vector<int> argsort(vector<double>& nums);
    vector<vector<int>> tensorToVector(Tensor& tensor);
 }
 #endif //BAYESNET_UTILS_H
--- a/src/Platform/CMakeLists.txt
+++ b/src/Platform/CMakeLists.txt
@@ -4,7 +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(manage manage.cc Results.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 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}")
--- a/src/Platform/Datasets.cc
+++ b/src/Platform/Datasets.cc
@@ -24,75 +24,110 @@ namespace platform {
        transform(datasets.begin(), datasets.end(), back_inserter(result), [](const auto& d) { return d.first; });
        return result;
    }
-    vector<string> Datasets::getFeatures(string name)
+    vector<string> Datasets::getFeatures(const string& name) const
    {
-        if (datasets[name]->isLoaded()) {
-            return datasets[name]->getFeatures();
+        if (datasets.at(name)->isLoaded()) {
+            return datasets.at(name)->getFeatures();
        } else {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    map<string, vector<int>> Datasets::getStates(string name)
+    map<string, vector<int>> Datasets::getStates(const string& name) const
    {
-        if (datasets[name]->isLoaded()) {
-            return datasets[name]->getStates();
+        if (datasets.at(name)->isLoaded()) {
+            return datasets.at(name)->getStates();
        } else {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    string Datasets::getClassName(string name)
+    void Datasets::loadDataset(const string& name) const
    {
-        if (datasets[name]->isLoaded()) {
-            return datasets[name]->getClassName();
+        if (datasets.at(name)->isLoaded()) {
+            return;
+        } else {
+            datasets.at(name)->load();
+        }
+    }
+    string Datasets::getClassName(const string& name) const
+    {
+        if (datasets.at(name)->isLoaded()) {
+            return datasets.at(name)->getClassName();
        } else {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    int Datasets::getNSamples(string name)
+    int Datasets::getNSamples(const string& name) const
    {
-        if (datasets[name]->isLoaded()) {
-            return datasets[name]->getNSamples();
+        if (datasets.at(name)->isLoaded()) {
+            return datasets.at(name)->getNSamples();
        } else {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    pair<vector<vector<float>>&, vector<int>&> Datasets::getVectors(string name)
+    int Datasets::getNClasses(const string& name)
+    {
+        if (datasets.at(name)->isLoaded()) {
+            auto className = datasets.at(name)->getClassName();
+            if (discretize) {
+                auto states = getStates(name);
+                return states.at(className).size();
+            }
+            auto [Xv, yv] = getVectors(name);
+            return *max_element(yv.begin(), yv.end()) + 1;
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    vector<int> Datasets::getClassesCounts(const string& name) const
+    {
+        if (datasets.at(name)->isLoaded()) {
+            auto [Xv, yv] = datasets.at(name)->getVectors();
+            vector<int> counts(*max_element(yv.begin(), yv.end()) + 1);
+            for (auto y : yv) {
+                counts[y]++;
+            }
+            return counts;
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    pair<vector<vector<float>>&, vector<int>&> Datasets::getVectors(const string& name)
    {
        if (!datasets[name]->isLoaded()) {
            datasets[name]->load();
        }
        return datasets[name]->getVectors();
    }
-    pair<vector<vector<int>>&, vector<int>&> Datasets::getVectorsDiscretized(string name)
+    pair<vector<vector<int>>&, vector<int>&> Datasets::getVectorsDiscretized(const string& name)
    {
        if (!datasets[name]->isLoaded()) {
            datasets[name]->load();
        }
        return datasets[name]->getVectorsDiscretized();
    }
-    pair<torch::Tensor&, torch::Tensor&> Datasets::getTensors(string name)
+    pair<torch::Tensor&, torch::Tensor&> Datasets::getTensors(const string& name)
    {
        if (!datasets[name]->isLoaded()) {
            datasets[name]->load();
        }
        return datasets[name]->getTensors();
    }
-    bool Datasets::isDataset(const string& name)
+    bool Datasets::isDataset(const string& name) const
    {
        return datasets.find(name) != datasets.end();
    }
    Dataset::Dataset(const Dataset& dataset) : path(dataset.path), name(dataset.name), className(dataset.className), n_samples(dataset.n_samples), n_features(dataset.n_features), features(dataset.features), states(dataset.states), loaded(dataset.loaded), discretize(dataset.discretize), X(dataset.X), y(dataset.y), Xv(dataset.Xv), Xd(dataset.Xd), yv(dataset.yv), fileType(dataset.fileType)
    {
    }
-    string Dataset::getName()
+    string Dataset::getName() const
    {
        return name;
    }
-    string Dataset::getClassName()
+    string Dataset::getClassName() const
    {
        return className;
    }
-    vector<string> Dataset::getFeatures()
+    vector<string> Dataset::getFeatures() const
    {
        if (loaded) {
            return features;
@@ -100,7 +135,7 @@ namespace platform {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    int Dataset::getNFeatures()
+    int Dataset::getNFeatures() const
    {
        if (loaded) {
            return n_features;
@@ -108,7 +143,7 @@ namespace platform {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    int Dataset::getNSamples()
+    int Dataset::getNSamples() const
    {
        if (loaded) {
            return n_samples;
@@ -116,7 +151,7 @@ namespace platform {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    map<string, vector<int>> Dataset::getStates()
+    map<string, vector<int>> Dataset::getStates() const
    {
        if (loaded) {
            return states;
--- a/src/Platform/Datasets.h
+++ b/src/Platform/Datasets.h
@@ -29,15 +29,15 @@ namespace platform {
    public:
        Dataset(const string& path, const string& name, const string& className, bool discretize, fileType_t fileType) : path(path), name(name), className(className), discretize(discretize), loaded(false), fileType(fileType) {};
        explicit Dataset(const Dataset&);
-        string getName();
-        string getClassName();
-        vector<string> getFeatures();
-        map<string, vector<int>> getStates();
+        string getName() const;
+        string getClassName() const;
+        vector<string> getFeatures() const;
+        map<string, vector<int>> getStates() const;
        pair<vector<vector<float>>&, vector<int>&> getVectors();
        pair<vector<vector<int>>&, vector<int>&> getVectorsDiscretized();
        pair<torch::Tensor&, torch::Tensor&> getTensors();
-        int getNFeatures();
-        int getNSamples();
+        int getNFeatures() const;
+        int getNSamples() const;
        void load();
        const bool inline isLoaded() const { return loaded; };
    };
@@ -51,14 +51,17 @@ namespace platform {
    public:
        explicit Datasets(const string& path, bool discretize = false, fileType_t fileType = ARFF) : path(path), discretize(discretize), fileType(fileType) { load(); };
        vector<string> getNames();
-        vector<string> getFeatures(string name);
-        int getNSamples(string name);
-        string getClassName(string name);
-        map<string, vector<int>> getStates(string name);
-        pair<vector<vector<float>>&, vector<int>&> getVectors(string name);
-        pair<vector<vector<int>>&, vector<int>&> getVectorsDiscretized(string name);
-        pair<torch::Tensor&, torch::Tensor&> getTensors(string name);
-        bool isDataset(const string& name);
+        vector<string> getFeatures(const string& name) const;
+        int getNSamples(const string& name) const;
+        string getClassName(const string& name) const;
+        int getNClasses(const string& name);
+        vector<int> getClassesCounts(const string& name) const;
+        map<string, vector<int>> getStates(const string& name) const;
+        pair<vector<vector<float>>&, vector<int>&> getVectors(const string& name);
+        pair<vector<vector<int>>&, vector<int>&> getVectorsDiscretized(const string& name);
+        pair<torch::Tensor&, torch::Tensor&> getTensors(const string& name);
+        bool isDataset(const string& name) const;
+        void loadDataset(const string& name) const;
    };
 };

--- a/src/Platform/Experiment.cc
+++ b/src/Platform/Experiment.cc
@@ -1,7 +1,7 @@
 #include "Experiment.h"
 #include "Datasets.h"
 #include "Models.h"
-#include "Report.h"
+#include "ReportConsole.h"

 namespace platform {
    using json = nlohmann::json;
@@ -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();
@@ -172,11 +181,11 @@ namespace platform {
                item++;
            }
            cout << "end. " << flush;
-            delete fold;
        }
        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);
--- a/src/Platform/Experiment.h
+++ b/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);
--- a/src/Platform/Models.h
+++ b/src/Platform/Models.h
@@ -10,6 +10,7 @@
 #include "KDBLd.h"
 #include "SPODELd.h"
 #include "AODELd.h"
+#include "BoostAODE.h"
 namespace platform {
    class Models {
    private:
--- a/src/Platform/Paths.h
+++ b/src/Platform/Paths.h
@@ -1,10 +1,12 @@
 #ifndef PATHS_H
 #define PATHS_H
+#include <string>
 namespace platform {
    class Paths {
    public:
        static std::string datasets() { return "datasets/"; }
        static std::string results() { return "results/"; }
+        static std::string excel() { return "excel/"; }
    };
 }
 #endif
--- a/src/Platform/Report.h
+++ b/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 = 121;
-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
--- a/src/Platform/ReportBase.cc
+++ b/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();
+    }
+}
--- a/src/Platform/ReportBase.h
+++ b/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
--- a/src/Platform/ReportConsole.cc
+++ b/src/Platform/ReportConsole.cc
@@ -1,53 +1,45 @@
-#include "Report.h"
+#include <sstream>
+#include <locale>
+#include "ReportConsole.h"
 #include "BestResult.h"

+
 namespace platform {
-    string headerLine(const string& text)
+    struct separated : numpunct<char> {
+        char do_decimal_point() const { return ','; }
+        char do_thousands_sep() const { return '.'; }
+        string do_grouping() const { return "\03"; }
+    };
+    
+    string ReportConsole::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)
-    {
-        string result = "";
-
-        for (auto& item : data[key]) {
-            result += to_string(item) + ", ";
-        }
-        return "[" + result.substr(0, result.size() - 2) + "]";
-    }
-    string fVector(const json& data)
-    {
-        string result = "";
-        for (const auto& item : data) {
-            result += to_string(item) + ", ";
-        }
-        return "[" + result.substr(0, result.size() - 2) + "]";
-    }
-    void Report::show()
-    {
-        header();
-        body();
-        footer();
-    }
-    void Report::header()
+    
+    void ReportConsole::header()
    {
+        locale mylocale(cout.getloc(), new separated);
+        locale::global(mylocale);
+        cout.imbue(mylocale);
+        stringstream oss;
        cout << Colors::MAGENTA() << string(MAXL, '*') << endl;
        cout << headerLine("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>());
        cout << headerLine(data["title"].get<string>());
        cout << headerLine("Random seeds: " + fromVector("seeds") + " Stratified: " + (data["stratified"].get<bool>() ? "True" : "False"));
-        cout << headerLine("Execution took  " + to_string(data["duration"].get<float>()) + " seconds,   " + to_string(data["duration"].get<float>() / 3600) + " hours, on " + data["platform"].get<string>());
+        oss << "Execution took  " << setprecision(2) << fixed << data["duration"].get<float>() << " seconds,   " << data["duration"].get<float>() / 3600 << " hours, on " << data["platform"].get<string>();
+        cout << headerLine(oss.str());
        cout << headerLine("Score is " + data["score_name"].get<string>());
        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;
+        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();
@@ -55,9 +47,9 @@ namespace platform {
            cout << setw(6) << right << r["samples"].get<int>() << " ";
            cout << setw(5) << right << r["features"].get<int>() << " ";
            cout << setw(3) << right << r["classes"].get<int>() << " ";
-            cout << setw(7) << setprecision(2) << fixed << r["nodes"].get<float>() << " ";
-            cout << setw(7) << setprecision(2) << fixed << r["leaves"].get<float>() << " ";
-            cout << setw(7) << setprecision(2) << fixed << r["depth"].get<float>() << " ";
+            cout << setw(9) << setprecision(2) << fixed << r["nodes"].get<float>() << " ";
+            cout << setw(9) << setprecision(2) << fixed << r["leaves"].get<float>() << " ";
+            cout << setw(9) << setprecision(2) << fixed << r["depth"].get<float>() << " ";
            cout << setw(8) << right << setprecision(6) << fixed << r["score"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["score_std"].get<double>() << " ";
            cout << setw(11) << right << setprecision(6) << fixed << r["time"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["time_std"].get<double>() << " ";
            try {
@@ -73,21 +65,24 @@ namespace platform {
        }
        if (data["results"].size() == 1) {
            cout << string(MAXL, '*') << endl;
-            cout << headerLine("Train scores: " + fVector(lastResult["scores_train"]));
-            cout << headerLine("Test  scores: " + fVector(lastResult["scores_test"]));
-            cout << headerLine("Train  times: " + fVector(lastResult["times_train"]));
-            cout << headerLine("Test   times: " + fVector(lastResult["times_test"]));
+            cout << headerLine(fVector("Train scores: ", lastResult["scores_train"], 14, 12));
+            cout << headerLine(fVector("Test  scores: ", lastResult["scores_test"], 14, 12));
+            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>();
        if (score == BestResult::scoreName()) {
-            cout << headerLine(score + " compared to " + BestResult::title() + " .:  " + to_string(totalScore / BestResult::score()));
+            stringstream oss;
+            oss << score << " compared to " << BestResult::title() << " .:  " << totalScore / BestResult::score();
+            cout << headerLine(oss.str());
        }
        cout << string(MAXL, '*') << endl << Colors::RESET();
-
    }
 }
--- a/src/Platform/ReportConsole.h
+++ b/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
--- a/src/Platform/ReportExcel.cc
+++ b/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 header = vector<string>(
+            { "Dataset", "Samples", "Features", "Classes", "Nodes", "Edges", "States", "Score", "Score Std.", "Time",
+             "Time Std.", "Hyperparameters" });
+        int col = 1;
+        for (const auto& item : header) {
+            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();
+        }
+    }
+}
--- a/src/Platform/ReportExcel.h
+++ b/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
--- a/src/Platform/Results.cc
+++ b/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);
-        report.show();
+        if (excelReport) {
+            ReportExcel report(data);
+            report.show();
+        } else {
+            ReportConsole report(data);
+            report.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 (index >= 0 && index < files.size()) {
-                    report(index);
-                } else {
-                    cout << "Invalid option" << endl;
+                if (all_of(line.begin(), line.end(), ::isdigit)) {
+                    index = stoi(line);
+                    if (index >= 0 && index < files.size()) {
+                        report(index, false);
+                        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;
--- a/src/Platform/Results.h
+++ b/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();
--- a/src/Platform/list.cc
+++ b/src/Platform/list.cc
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <locale>
+#include "Paths.h"
+#include "Colors.h"
+#include "Datasets.h"
+
+using namespace std;
+const int BALANCE_LENGTH = 75;
+
+struct separated : numpunct<char> {
+    char do_decimal_point() const { return ','; }
+    char do_thousands_sep() const { return '.'; }
+    string do_grouping() const { return "\03"; }
+};
+
+void outputBalance(const string& balance)
+{
+    auto temp = string(balance);
+    while (temp.size() > BALANCE_LENGTH - 1) {
+        auto part = temp.substr(0, BALANCE_LENGTH);
+        cout << part << endl;
+        cout << setw(48) << " ";
+        temp = temp.substr(BALANCE_LENGTH);
+    }
+    cout << temp << endl;
+}
+
+int main(int argc, char** argv)
+{
+    auto data = platform::Datasets(platform::Paths().datasets(), false);
+    locale mylocale(cout.getloc(), new separated);
+    locale::global(mylocale);
+    cout.imbue(mylocale);
+    cout << Colors::GREEN() << "Dataset                        Sampl. Feat. Cls. Balance" << endl;
+    string balanceBars = string(BALANCE_LENGTH, '=');
+    cout << "============================== ====== ===== === " << balanceBars << endl;
+    bool odd = true;
+    for (const auto& dataset : data.getNames()) {
+        auto color = odd ? Colors::CYAN() : Colors::BLUE();
+        cout << color << setw(30) << left << dataset << " ";
+        data.loadDataset(dataset);
+        auto nSamples = data.getNSamples(dataset);
+        cout << setw(6) << right << nSamples << " ";
+        cout << setw(5) << right << data.getFeatures(dataset).size() << " ";
+        cout << setw(3) << right << data.getNClasses(dataset) << " ";
+        stringstream oss;
+        string sep = "";
+        for (auto number : data.getClassesCounts(dataset)) {
+            oss << sep << setprecision(2) << fixed << (float)number / nSamples * 100.0 << "% (" << number << ")";
+            sep = " / ";
+        }
+        outputBalance(oss.str());
+        odd = !odd;
+    }
+    cout << Colors::RESET() << endl;
+    return 0;
+}
--- a/src/Platform/main.cc
+++ b/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;
@@ -103,9 +110,10 @@ int main(int argc, char** argv)
    */
    auto env = platform::DotEnv();
    auto experiment = platform::Experiment();
-    experiment.setTitle(title).setLanguage("cpp").setLanguageVersion("1.0.0");
+    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;
 }
--- a/src/Platform/modelRegister.h
+++ b/src/Platform/modelRegister.h
@@ -16,4 +16,6 @@ static platform::Registrar registrarA("AODE",
    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::AODE();});
 static platform::Registrar registrarALD("AODELd",
    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::AODELd();});
+static platform::Registrar registrarBA("BoostAODE",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::BoostAODE();});
 #endif
Author	SHA1	Message	Date
Ricardo Montañana	97ca8ac084	Move check valid hyperparameters to Classifier	2023-08-22 22:12:20 +02:00
Ricardo Montañana	1c1385b768	Fix maxModels mistake in BoostAODE if !repeatSp Throw exception if wrong hyperparmeter is supplied	2023-08-22 21:55:17 +02:00
Ricardo Montañana	35432b6294	Fix time std was not saved in experiment	2023-08-22 12:30:27 +02:00
Ricardo Montañana	c59dd30e53	Complete Excel Report with data	2023-08-22 11:55:15 +02:00
Ricardo Montañana	d2da0ddb88	Create ReportExcel eq to ReportConsole	2023-08-21 17:51:49 +02:00
Ricardo Montañana	8066701c3c	Refactor Report class into ReportBase & ReportCons	2023-08-21 17:16:29 +02:00
Ricardo Montañana	0f66ac73d0	Revert "Refactor Report into ReportBase & ReportConsole" This reverts commit `4370bf51d7`.	2023-08-21 17:15:14 +02:00
Ricardo Montañana	4370bf51d7	Refactor Report into ReportBase & ReportConsole	2023-08-21 17:14:23 +02:00
Ricardo Montañana	2b7353b9e0	Add default sorting by date in manage	2023-08-21 16:30:10 +02:00
Ricardo Montañana	b686b3c9c3	Enhance copy in Makefile	2023-08-21 12:18:23 +02:00
Ricardo Montañana	2dd04a6c44	enhance saving results and add Makefile copy	2023-08-21 11:57:45 +02:00
Ricardo Montañana	1da83662d0	Always save results	2023-08-21 10:55:20 +02:00
Ricardo Montañana	3ac9593c65	Fix mistake in sample	2023-08-20 20:36:46 +02:00
Ricardo Montañana	6b317accf1	Add hyperparameters and processing order to Boost	2023-08-20 20:31:23 +02:00
Ricardo Montañana	4964aab722	Add hyperparameters management in experiments	2023-08-20 17:57:38 +02:00
Ricardo Montañana Gómez	7a6ec73d63	Merge pull request 'boostAode' (#5 ) from boostAode into main Reviewed-on: https://gitea.rmontanana.es:11000/rmontanana/BayesNet/pulls/5 Implement boostAODE add list datasets add manage results	2023-08-20 09:02:07 +00:00
Ricardo Montañana	1a534888d6	Fix report format	2023-08-19 23:30:44 +02:00
Ricardo Montañana	59ffd179f4	Fix report format	2023-08-19 21:26:48 +02:00
Ricardo Montañana	9972738deb	Add list datasets and add locale format	2023-08-19 19:05:16 +02:00
Ricardo Montañana	bafcb26bb6	Add manage to build target	2023-08-18 13:43:53 +02:00
Ricardo Montañana	2d7999d5f2	Add manage to release targets	2023-08-18 13:43:13 +02:00
Ricardo Montañana	a6bb22dfb5	Complete first BoostAODE	2023-08-18 11:50:34 +02:00
Ricardo Montañana	704dc937be	Remove FeatureSel, add SelectKBest to BayesMetrics	2023-08-16 19:05:18 +02:00
Ricardo Montañana	a3e665eed6	make weights double	2023-08-16 12:46:09 +02:00
Ricardo Montañana	918a7b4180	Remove unneeded output	2023-08-16 12:36:38 +02:00
Ricardo Montañana	80b20f35b4	Fix weights mistakes in computation	2023-08-16 12:32:51 +02:00
Ricardo Montañana	4d4780c1d5	Add BoostAODE model based on AODE	2023-08-15 16:16:04 +02:00
Ricardo Montañana	fa612c531e	Complete Adding weights to Models	2023-08-15 15:59:56 +02:00
Ricardo Montañana	24b68f9ae2	Add weigths as parameter	2023-08-15 15:04:56 +02:00
Ricardo Montañana Gómez	a062ebf445	Merge pull request 'reports' (#4 ) from reports into boostAode Reviewed-on: https://gitea.rmontanana.es:11000/rmontanana/BayesNet/pulls/4	2023-08-14 16:58:48 +00:00
Ricardo Montañana	f26ea1f0ac	Add weights to BayesMetrics	2023-08-13 12:56:06 +02:00
Ricardo Montañana	af0419c9da	First approx with const 1 weights	2023-08-13 00:59:02 +02:00