Add states as result in Proposal methods

Solved Ld poor results
Redo pass states to Network Fit needed in crossval
2023-08-12 16:16:17 +02:00 · 2023-08-12 11:49:18 +02:00 · 2023-08-12 11:10:53 +02:00 · 2023-08-10 02:06:18 +02:00 · 2023-08-08 01:53:41 +02:00 · 2023-08-07 13:50:11 +02:00
59 changed files with 1376 additions and 698 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -13,5 +13,4 @@ HeaderFilterRegex: 'src/*'
 AnalyzeTemporaryDtors: false
 WarningsAsErrors: ''
 FormatStyle: file
-FormatStyleOptions: ''
 ...
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -10,12 +10,13 @@
                "-d",
                "iris",
                "-m",
-                "TAN",
+                "KDB",
+                "-s",
+                "271",
                "-p",
-                "../../data/",
-                "--tensors"
+                "/Users/rmontanana/Code/discretizbench/datasets/",
            ],
-            "cwd": "${workspaceFolder}/build/sample/",
+            //"cwd": "${workspaceFolder}/build/sample/",
        },
        {
            "type": "lldb",
@@ -24,19 +25,14 @@
            "program": "${workspaceFolder}/build/src/Platform/main",
            "args": [
                "-m",
-                "TAN",
+                "SPODELd",
                "-p",
                "/Users/rmontanana/Code/discretizbench/datasets",
-                "--discretize",
                "--stratified",
-                "--title",
-                "Debug test",
-                "--seeds",
-                "1",
                "-d",
-                "ionosphere"
+                "iris"
            ],
-            "cwd": "${workspaceFolder}/build/src/Platform",
+            "cwd": "/Users/rmontanana/Code/discretizbench",
        },
        {
            "name": "Build & debug active file",
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,10 +7,14 @@ project(BayesNet
  LANGUAGES CXX
 )

+if (CODE_COVERAGE AND NOT ENABLE_TESTING)
+  MESSAGE(FATAL_ERROR "Code coverage requires testing enabled")
+endif (CODE_COVERAGE AND NOT ENABLE_TESTING)
+
 find_package(Torch REQUIRED)

 if (POLICY CMP0135)
-    cmake_policy(SET CMP0135 NEW)
+  cmake_policy(SET CMP0135 NEW)
 endif ()

 # Global CMake variables
@@ -24,24 +28,31 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")
 # Options
 # -------
 option(ENABLE_CLANG_TIDY "Enable to add clang tidy."              OFF)
-option(ENABLE_TESTING "Unit testing build"                        ON)
-option(CODE_COVERAGE "Collect coverage from test library"         ON)
-
-set(CMAKE_BUILD_TYPE "Debug")
+option(ENABLE_TESTING "Unit testing build"                        OFF)
+option(CODE_COVERAGE "Collect coverage from test library"         OFF)

 # CMakes modules
 # --------------
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})

 include(AddGitSubmodule)
-include(StaticAnalyzers) # clang-tidy
-include(CodeCoverage)
+if (CODE_COVERAGE)
+    enable_testing()
+    include(CodeCoverage)
+    MESSAGE("Code coverage enabled")
+    set(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
+    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+    SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
+endif (CODE_COVERAGE)
+
+if (ENABLE_CLANG_TIDY)
+  include(StaticAnalyzers) # clang-tidy
+endif (ENABLE_CLANG_TIDY)

 # External libraries - dependencies of BayesNet
 # ---------------------------------------------
 # include(FetchContent)
 add_git_submodule("lib/mdlp")
-add_git_submodule("lib/catch2")
 add_git_submodule("lib/argparse")
 add_git_submodule("lib/json")

@@ -59,18 +70,11 @@ file(GLOB Platform_SOURCES CONFIGURE_DEPENDS ${BayesNet_SOURCE_DIR}/src/Platform

 # Testing
 # -------
+
 if (ENABLE_TESTING)
  MESSAGE("Testing enabled")
-  enable_testing()
-  if (CODE_COVERAGE)
-    #include(CodeCoverage)
-    MESSAGE("Code coverage enabled")
-    set(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
-    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
-    SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
-  endif (CODE_COVERAGE)
-  #find_package(Catch2 3 REQUIRED)
+  add_git_submodule("lib/catch2")
+  
  include(CTest)
-  #include(Catch)
  add_subdirectory(tests)
 endif (ENABLE_TESTING)
--- a/26
+++ b/26
@@ -14,16 +14,30 @@ setup: ## Install dependencies for tests and coverage
 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 project
-	@echo ">>> Building BayesNet ...";
+build: ## Build the main and BayesNetSample
+	cmake --build build -t main -t BayesNetSample -j 32
+
+clean: ## Clean the debug info
+	@echo ">>> Cleaning Debug BayesNet ...";
+	find . -name "*.gcda" -print0 | xargs -0 rm
+	@echo ">>> Done";
+
+debug: ## Build a debug version of the project
+	@echo ">>> Building Debug BayesNet ...";
 	@if [ -d ./build ]; then rm -rf ./build; fi
 	@mkdir build; 
-	cmake -S . -B build; \
-	cd build; \
-	make; \
-	
+	cmake -S . -B build -D CMAKE_BUILD_TYPE=Debug -D ENABLE_TESTING=ON -D CODE_COVERAGE=ON; \
+	cmake --build build -j 32;
 	@echo ">>> Done";

+release: ## Build a Release version of the project
+	@echo ">>> Building Release BayesNet ...";
+	@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;
+	@echo ">>> Done";	
+
 test: ## Run tests
 	@echo "* Running tests...";
 	find . -name "*.gcda" -print0 | xargs -0 rm
--- a/TAN_iris.dot
+++ b/TAN_iris.dot
@@ -0,0 +1,12 @@
+digraph BayesNet {
+label=<BayesNet >
+fontsize=30
+fontcolor=blue
+labelloc=t
+layout=circo
+ class [shape=circle, fontcolor=red, fillcolor=lightblue, style=filled ] 
+ class -> sepallength class -> sepalwidth class -> petallength class -> petalwidth petallength [shape=circle] 
+ petallength -> sepallength petalwidth [shape=circle] 
+ sepallength [shape=circle] 
+ sepallength -> sepalwidth sepalwidth [shape=circle] 
+ sepalwidth -> petalwidth }
--- a/gcovr.cfg
+++ b/gcovr.cfg
@@ -1,5 +1,4 @@
 filter = src/
-exclude = external/
-exclude = tests/
+exclude-directories = build/lib/
 print-summary = yes
 sort-percentage = yes
--- a/lib/mdlp
+++ b/lib/mdlp
--- a/sample/sample.cc
+++ b/sample/sample.cc
@@ -1,7 +1,6 @@
 #include <iostream>
 #include <torch/torch.h>
 #include <string>
-#include <thread>
 #include <map>
 #include <argparse/argparse.hpp>
 #include "ArffFiles.h"
@@ -9,6 +8,7 @@
 #include "CPPFImdlp.h"
 #include "Folding.h"
 #include "Models.h"
+#include "modelRegister.h"


 using namespace std;
@@ -41,7 +41,7 @@ bool file_exists(const std::string& name)
 }
 pair<vector<vector<int>>, vector<int>> extract_indices(vector<int> indices, vector<vector<int>> X, vector<int> y)
 {
-    vector<vector<int>> Xr;
+    vector<vector<int>> Xr; // nxm
    vector<int> yr;
    for (int col = 0; col < X.size(); ++col) {
        Xr.push_back(vector<int>());
@@ -68,9 +68,8 @@ int main(int argc, char** argv)
            {"mfeat-factors",      true},
    };
    auto valid_datasets = vector<string>();
-    for (auto dataset : datasets) {
-        valid_datasets.push_back(dataset.first);
-    }
+    transform(datasets.begin(), datasets.end(), back_inserter(valid_datasets),
+        [](const pair<string, bool>& pair) { return pair.first; });
    argparse::ArgumentParser program("BayesNetSample");
    program.add_argument("-d", "--dataset")
        .help("Dataset file name")
@@ -86,16 +85,17 @@ int main(int argc, char** argv)
        .default_value(string{ PATH }
    );
    program.add_argument("-m", "--model")
-        .help("Model to use " + platform::Models::toString())
+        .help("Model to use " + platform::Models::instance()->toString())
        .action([](const std::string& value) {
-        static const vector<string> choices = platform::Models::getNames();
+        static const vector<string> choices = platform::Models::instance()->getNames();
        if (find(choices.begin(), choices.end(), value) != choices.end()) {
            return value;
        }
-        throw runtime_error("Model must be one of " + platform::Models::toString());
+        throw runtime_error("Model must be one of " + platform::Models::instance()->toString());
            }
    );
    program.add_argument("--discretize").help("Discretize input dataset").default_value(false).implicit_value(true);
+    program.add_argument("--dumpcpt").help("Dump CPT Tables").default_value(false).implicit_value(true);
    program.add_argument("--stratified").help("If Stratified KFold is to be done").default_value(false).implicit_value(true);
    program.add_argument("--tensors").help("Use tensors to store samples").default_value(false).implicit_value(true);
    program.add_argument("-f", "--folds").help("Number of folds").default_value(5).scan<'i', int>().action([](const string& value) {
@@ -113,7 +113,7 @@ int main(int argc, char** argv)
            throw runtime_error("Number of folds must be an integer");
        }});
    program.add_argument("-s", "--seed").help("Random seed").default_value(-1).scan<'i', int>();
-    bool class_last, stratified, tensors;
+    bool class_last, stratified, tensors, dump_cpt;
    string model_name, file_name, path, complete_file_name;
    int nFolds, seed;
    try {
@@ -126,6 +126,7 @@ int main(int argc, char** argv)
        tensors = program.get<bool>("tensors");
        nFolds = program.get<int>("folds");
        seed = program.get<int>("seed");
+        dump_cpt = program.get<bool>("dumpcpt");
        class_last = datasets[file_name];
        if (!file_exists(complete_file_name)) {
            throw runtime_error("Data File " + path + file_name + ".arff" + " does not exist");
@@ -148,9 +149,9 @@ int main(int argc, char** argv)
    // Get className & Features
    auto className = handler.getClassName();
    vector<string> features;
-    for (auto feature : handler.getAttributes()) {
-        features.push_back(feature.first);
-    }
+    auto attributes = handler.getAttributes();
+    transform(attributes.begin(), attributes.end(), back_inserter(features),
+        [](const pair<string, string>& item) { return item.first; });
    // Discretize Dataset
    auto [Xd, maxes] = discretize(X, y, features);
    maxes[className] = *max_element(y.begin(), y.end()) + 1;
@@ -159,64 +160,77 @@ int main(int argc, char** argv)
        states[feature] = vector<int>(maxes[feature]);
    }
    states[className] = vector<int>(maxes[className]);
-
-    bayesnet::BaseClassifier* clf = platform::Models::get(model_name);
+    auto clf = platform::Models::instance()->create(model_name);
    clf->fit(Xd, y, features, className, states);
-    auto score = clf->score(Xd, y);
+    if (dump_cpt) {
+        cout << "--- CPT Tables ---" << endl;
+        clf->dump_cpt();
+    }
    auto lines = clf->show();
-    auto graph = clf->graph();
    for (auto line : lines) {
        cout << line << endl;
    }
+    cout << "--- Topological Order ---" << endl;
+    auto order = clf->topological_order();
+    for (auto name : order) {
+        cout << name << ", ";
+    }
+    cout << "end." << endl;
+    auto score = clf->score(Xd, y);
    cout << "Score: " << score << endl;
-    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);
-            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);
-        }
-        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,14 +2,14 @@

 namespace bayesnet {
    AODE::AODE() : Ensemble() {}
-    void AODE::train()
+    void AODE::buildModel()
    {
        models.clear();
        for (int i = 0; i < features.size(); ++i) {
            models.push_back(std::make_unique<SPODE>(i));
        }
    }
-    vector<string> AODE::graph(string title)
+    vector<string> AODE::graph(const string& title) const
    {
        return Ensemble::graph(title);
    }
--- a/src/BayesNet/AODE.h
+++ b/src/BayesNet/AODE.h
@@ -5,10 +5,11 @@
 namespace bayesnet {
    class AODE : public Ensemble {
    protected:
-        void train() override;
+        void buildModel() override;
    public:
        AODE();
-        vector<string> graph(string title = "AODE") override;
+        virtual ~AODE() {};
+        vector<string> graph(const string& title = "AODE") const override;
    };
 }
 #endif
--- a/src/BayesNet/AODELd.cc
+++ b/src/BayesNet/AODELd.cc
@@ -0,0 +1,40 @@
+#include "AODELd.h"
+#include "Models.h"
+
+namespace bayesnet {
+    using namespace std;
+    AODELd::AODELd() : Ensemble(), Proposal(dataset, features, className) {}
+    AODELd& AODELd::fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    {
+        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
+        features = features_;
+        className = className_;
+        Xf = X_;
+        y = y_;
+        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        states = fit_local_discretization(y);
+        // We have discretized the input data
+        // 1st we need to fit the model to build the normal TAN structure, TAN::fit initializes the base Bayesian network
+        Ensemble::fit(dataset, features, className, states);
+        return *this;
+
+    }
+    void AODELd::buildModel()
+    {
+        models.clear();
+        for (int i = 0; i < features.size(); ++i) {
+            models.push_back(std::make_unique<SPODELd>(i));
+        }
+        n_models = models.size();
+    }
+    void AODELd::trainModel()
+    {
+        for (const auto& model : models) {
+            model->fit(Xf, y, features, className, states);
+        }
+    }
+    vector<string> AODELd::graph(const string& name) const
+    {
+        return Ensemble::graph(name);
+    }
+}
--- a/src/BayesNet/AODELd.h
+++ b/src/BayesNet/AODELd.h
@@ -0,0 +1,21 @@
+#ifndef AODELD_H
+#define AODELD_H
+#include "Ensemble.h"
+#include "Proposal.h"
+#include "SPODELd.h"
+
+namespace bayesnet {
+    using namespace std;
+    class AODELd : public Ensemble, public Proposal {
+    protected:
+        void trainModel() override;
+        void buildModel() 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"; };
+    };
+}
+#endif // !AODELD_H
--- a/src/BayesNet/BaseClassifier.h
+++ b/src/BayesNet/BaseClassifier.h
@@ -5,19 +5,27 @@
 namespace bayesnet {
    using namespace std;
    class BaseClassifier {
+    protected:
+        virtual void trainModel() = 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() = default;
+        torch::Tensor virtual predict(torch::Tensor& X) = 0;
        vector<int> virtual predict(vector<vector<int>>& X) = 0;
        float virtual score(vector<vector<int>>& X, vector<int>& y) = 0;
        float virtual score(torch::Tensor& X, torch::Tensor& y) = 0;
-        int virtual getNumberOfNodes() = 0;
-        int virtual getNumberOfEdges() = 0;
-        int virtual getNumberOfStates() = 0;
-        vector<string> virtual show() = 0;
-        vector<string> virtual graph(string title = "") = 0;
-        virtual ~BaseClassifier() = default;
+        int virtual getNumberOfNodes()const = 0;
+        int virtual getNumberOfEdges()const = 0;
+        int virtual getNumberOfStates() const = 0;
+        vector<string> virtual show() const = 0;
+        vector<string> virtual graph(const string& title = "") const = 0;
        const string inline getVersion() const { return "0.1.0"; };
+        vector<string> virtual topological_order() = 0;
+        void virtual dump_cpt()const = 0;
    };
 }
 #endif
--- a/src/BayesNet/BayesMetrics.cc
+++ b/src/BayesNet/BayesMetrics.cc
@@ -1,13 +1,15 @@
 #include "BayesMetrics.h"
 #include "Mst.h"
 namespace bayesnet {
-    Metrics::Metrics(torch::Tensor& samples, vector<string>& features, string& className, int classNumStates)
+    //samples is nxm tensor used to fit the model
+    Metrics::Metrics(const torch::Tensor& samples, const vector<string>& features, const string& className, const int classNumStates)
        : samples(samples)
        , features(features)
        , className(className)
        , classNumStates(classNumStates)
    {
    }
+    //samples is nxm vector used to fit the model
    Metrics::Metrics(const vector<vector<int>>& vsamples, const vector<int>& labels, const vector<string>& features, const string& className, const int classNumStates)
        : features(features)
        , className(className)
@@ -15,9 +17,9 @@ namespace bayesnet {
        , samples(torch::zeros({ static_cast<int>(vsamples[0].size()), static_cast<int>(vsamples.size() + 1) }, torch::kInt32))
    {
        for (int i = 0; i < vsamples.size(); ++i) {
-            samples.index_put_({ "...", i }, torch::tensor(vsamples[i], torch::kInt32));
+            samples.index_put_({ i,  "..." }, torch::tensor(vsamples[i], torch::kInt32));
        }
-        samples.index_put_({ "...", -1 }, torch::tensor(labels, torch::kInt32));
+        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
    }
    vector<pair<string, string>> Metrics::doCombinations(const vector<string>& source)
    {
@@ -39,17 +41,17 @@ namespace bayesnet {
        // Compute class prior
        auto margin = torch::zeros({ classNumStates });
        for (int value = 0; value < classNumStates; ++value) {
-            auto mask = samples.index({ "...", -1 }) == value;
-            margin[value] = mask.sum().item<float>() / samples.sizes()[0];
+            auto mask = samples.index({ -1,  "..." }) == value;
+            margin[value] = mask.sum().item<float>() / samples.size(1);
        }
        for (auto [first, second] : combinations) {
            int index_first = find(features.begin(), features.end(), first) - features.begin();
            int index_second = find(features.begin(), features.end(), second) - features.begin();
            double accumulated = 0;
            for (int value = 0; value < classNumStates; ++value) {
-                auto mask = samples.index({ "...", -1 }) == value;
-                auto first_dataset = samples.index({ mask, index_first });
-                auto second_dataset = samples.index({ mask, index_second });
+                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>();
                accumulated += pb * mi;
@@ -67,14 +69,14 @@ namespace bayesnet {
        }
        return matrix;
    }
-    // To Interface with Python
+    // To use in Python
    vector<float> Metrics::conditionalEdgeWeights()
    {
        auto matrix = conditionalEdge();
        std::vector<float> v(matrix.data_ptr<float>(), matrix.data_ptr<float>() + matrix.numel());
        return v;
    }
-    double Metrics::entropy(torch::Tensor& feature)
+    double Metrics::entropy(const torch::Tensor& feature)
    {
        torch::Tensor counts = feature.bincount();
        int totalWeight = counts.sum().item<int>();
@@ -84,7 +86,7 @@ namespace bayesnet {
        return entropy.nansum().item<double>();
    }
    // H(Y|X) = sum_{x in X} p(x) H(Y|X=x)
-    double Metrics::conditionalEntropy(torch::Tensor& firstFeature, torch::Tensor& secondFeature)
+    double Metrics::conditionalEntropy(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature)
    {
        int numSamples = firstFeature.sizes()[0];
        torch::Tensor featureCounts = secondFeature.bincount();
@@ -113,7 +115,7 @@ namespace bayesnet {
        return entropyValue;
    }
    // I(X;Y) = H(Y) - H(Y|X)
-    double Metrics::mutualInformation(torch::Tensor& firstFeature, torch::Tensor& secondFeature)
+    double Metrics::mutualInformation(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature)
    {
        return entropy(firstFeature) - conditionalEntropy(firstFeature, secondFeature);
    }
@@ -122,7 +124,7 @@ namespace bayesnet {
    and the indices of the weights as nodes of this square matrix using
    Kruskal algorithm
    */
-    vector<pair<int, int>> Metrics::maximumSpanningTree(vector<string> features, Tensor& weights, int root)
+    vector<pair<int, int>> Metrics::maximumSpanningTree(const vector<string>& features, const Tensor& weights, const int root)
    {
        auto mst = MST(features, weights, root);
        return mst.maximumSpanningTree();
--- a/src/BayesNet/BayesMetrics.h
+++ b/src/BayesNet/BayesMetrics.h
@@ -8,21 +8,21 @@ namespace bayesnet {
    using namespace torch;
    class Metrics {
    private:
-        Tensor samples;
+        Tensor samples; // nxm tensor used to fit the model
        vector<string> features;
        string className;
-        int classNumStates;
+        int classNumStates = 0;
    public:
        Metrics() = default;
-        Metrics(Tensor&, vector<string>&, string&, int);
+        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(Tensor&);
-        double conditionalEntropy(Tensor&, Tensor&);
-        double mutualInformation(Tensor&, Tensor&);
-        vector<float> conditionalEdgeWeights();
+        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>&);
-        vector<pair<int, int>> maximumSpanningTree(vector<string> features, Tensor& weights, int root);
+        vector<pair<int, int>> maximumSpanningTree(const vector<string>& features, const Tensor& weights, const int root);
    };
 }
 #endif
--- a/src/BayesNet/CMakeLists.txt
+++ b/src/BayesNet/CMakeLists.txt
@@ -1,2 +1,7 @@
-add_library(BayesNet bayesnetUtils.cc Network.cc Node.cc BayesMetrics.cc Classifier.cc KDB.cc TAN.cc SPODE.cc Ensemble.cc AODE.cc Mst.cc)
-target_link_libraries(BayesNet "${TORCH_LIBRARIES}")
+include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
+include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
+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}")
--- a/src/BayesNet/Classifier.cc
+++ b/src/BayesNet/Classifier.cc
@@ -4,57 +4,68 @@
 namespace bayesnet {
    using namespace torch;

-    Classifier::Classifier(const Network& model) : model(model), m(0), n(0), metrics(Metrics()), fitted(false) {}
+    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)
    {
-        dataset = torch::cat({ X, y.view({y.size(0), 1}) }, 1);
        this->features = features;
        this->className = className;
        this->states = states;
+        m = dataset.size(1);
+        n = dataset.size(0) - 1;
        checkFitParameters();
        auto n_classes = states[className].size();
        metrics = Metrics(dataset, features, className, n_classes);
-        train();
-        if (Xv == vector<vector<int>>()) {
-            // fit with tensors
-            model.fit(X, y, features, className);
-        } else {
-            // fit with vectors
-            model.fit(Xv, yv, features, className);
-        }
+        model.initialize();
+        buildModel();
+        trainModel();
        fitted = true;
        return *this;
    }
+
+    void Classifier::buildDataset(Tensor& ytmp)
+    {
+        try {
+            auto yresized = torch::transpose(ytmp.view({ ytmp.size(0), 1 }), 0, 1);
+            dataset = torch::cat({ dataset, yresized }, 0);
+        }
+        catch (const std::exception& e) {
+            std::cerr << e.what() << '\n';
+            cout << "X dimensions: " << dataset.sizes() << "\n";
+            cout << "y dimensions: " << ytmp.sizes() << "\n";
+            exit(1);
+        }
+    }
+    void Classifier::trainModel()
+    {
+        model.fit(dataset, 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)
    {
-        this->X = torch::transpose(X, 0, 1);
-        this->y = y;
-        Xv = vector<vector<int>>();
-        yv = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
+        dataset = X;
+        buildDataset(y);
        return build(features, className, states);
    }
-
+    // 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)
    {
-        this->X = torch::zeros({ static_cast<int>(X[0].size()), static_cast<int>(X.size()) }, kInt32);
-        Xv = X;
+        dataset = torch::zeros({ static_cast<int>(X.size()), static_cast<int>(X[0].size()) }, kInt32);
        for (int i = 0; i < X.size(); ++i) {
-            this->X.index_put_({ "...", i }, torch::tensor(X[i], kInt32));
+            dataset.index_put_({ i, "..." }, torch::tensor(X[i], kInt32));
        }
-        this->y = torch::tensor(y, kInt32);
-        yv = y;
+        auto ytmp = torch::tensor(y, kInt32);
+        buildDataset(ytmp);
+        return build(features, className, states);
+    }
+    Classifier& Classifier::fit(torch::Tensor& dataset, vector<string>& features, string className, map<string, vector<int>>& states)
+    {
+        this->dataset = dataset;
        return build(features, className, states);
    }
    void Classifier::checkFitParameters()
    {
-        auto sizes = X.sizes();
-        m = sizes[0];
-        n = sizes[1];
-        if (m != y.size(0)) {
-            throw invalid_argument("X and y must have the same number of samples");
-        }
        if (n != features.size()) {
-            throw invalid_argument("X and features must have the same number of features");
+            throw invalid_argument("X " + to_string(n) + " and features " + to_string(features.size()) + " must have the same number of features");
        }
        if (states.find(className) == states.end()) {
            throw invalid_argument("className not found in states");
@@ -65,23 +76,12 @@ namespace bayesnet {
            }
        }
    }
-
    Tensor Classifier::predict(Tensor& X)
    {
        if (!fitted) {
            throw logic_error("Classifier has not been fitted");
        }
-        auto m_ = X.size(0);
-        auto n_ = X.size(1);
-        //auto Xt = torch::transpose(X, 0, 1);
-        vector<vector<int>> Xd(n_, vector<int>(m_, 0));
-        for (auto i = 0; i < n_; i++) {
-            auto temp = X.index({ "...", i });
-            Xd[i] = vector<int>(temp.data_ptr<int>(), temp.data_ptr<int>() + temp.numel());
-        }
-        auto yp = model.predict(Xd);
-        auto ypred = torch::tensor(yp, torch::kInt32);
-        return ypred;
+        return model.predict(X);
    }
    vector<int> Classifier::predict(vector<vector<int>>& X)
    {
@@ -102,8 +102,7 @@ namespace bayesnet {
        if (!fitted) {
            throw logic_error("Classifier has not been fitted");
        }
-        auto Xt = torch::transpose(X, 0, 1);
-        Tensor y_pred = predict(Xt);
+        Tensor y_pred = predict(X);
        return (y_pred == y).sum().item<float>() / y.size(0);
    }
    float Classifier::score(vector<vector<int>>& X, vector<int>& y)
@@ -111,37 +110,39 @@ namespace bayesnet {
        if (!fitted) {
            throw logic_error("Classifier has not been fitted");
        }
-        auto m_ = X[0].size();
-        auto n_ = X.size();
-        vector<vector<int>> Xd(n_, vector<int>(m_, 0));
-        for (auto i = 0; i < n_; i++) {
-            Xd[i] = vector<int>(X[i].begin(), X[i].end());
-        }
-        return model.score(Xd, y);
+        return model.score(X, y);
    }
-    vector<string> Classifier::show()
+    vector<string> Classifier::show() const
    {
        return model.show();
    }
    void Classifier::addNodes()
    {
        // Add all nodes to the network
-        for (auto feature : features) {
-            model.addNode(feature, states[feature].size());
+        for (const auto& feature : features) {
+            model.addNode(feature);
        }
-        model.addNode(className, states[className].size());
+        model.addNode(className);
    }
-    int Classifier::getNumberOfNodes()
+    int Classifier::getNumberOfNodes() const
    {
        // Features does not include class
        return fitted ? model.getFeatures().size() + 1 : 0;
    }
-    int Classifier::getNumberOfEdges()
+    int Classifier::getNumberOfEdges() const
    {
-        return fitted ? model.getEdges().size() : 0;
+        return fitted ? model.getNumEdges() : 0;
    }
-    int Classifier::getNumberOfStates()
+    int Classifier::getNumberOfStates() const
    {
        return fitted ? model.getStates() : 0;
    }
+    vector<string> Classifier::topological_order()
+    {
+        return model.topological_sort();
+    }
+    void Classifier::dump_cpt() const
+    {
+        model.dump_cpt();
+    }
 }
--- a/src/BayesNet/Classifier.h
+++ b/src/BayesNet/Classifier.h
@@ -10,36 +10,37 @@ using namespace torch;
 namespace bayesnet {
    class Classifier : public BaseClassifier {
    private:
-        bool fitted;
+        void buildDataset(torch::Tensor& y);
        Classifier& build(vector<string>& features, string className, map<string, vector<int>>& states);
    protected:
+        bool fitted;
        Network model;
        int m, n; // m: number of samples, n: number of features
-        Tensor X;
-        vector<vector<int>> Xv;
-        Tensor y;
-        vector<int> yv;
-        Tensor dataset;
+        Tensor dataset; // (n+1)xm tensor
        Metrics metrics;
        vector<string> features;
        string className;
        map<string, vector<int>> states;
        void checkFitParameters();
-        virtual void train() = 0;
+        virtual void buildModel() = 0;
+        void trainModel() override;
    public:
-        Classifier(const Network& model);
+        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;
        void addNodes();
-        int getNumberOfNodes() override;
-        int getNumberOfEdges() override;
-        int getNumberOfStates() override;
-        Tensor predict(Tensor& X);
+        int getNumberOfNodes() const override;
+        int getNumberOfEdges() const override;
+        int getNumberOfStates() const override;
+        Tensor predict(Tensor& X) override;
        vector<int> predict(vector<vector<int>>& X) override;
        float score(Tensor& X, Tensor& y) override;
        float score(vector<vector<int>>& X, vector<int>& y) override;
-        vector<string> show() override;
+        vector<string> show() const override;
+        vector<string> topological_order()  override;
+        void dump_cpt() const override;
    };
 }
 #endif
--- a/src/BayesNet/Ensemble.cc
+++ b/src/BayesNet/Ensemble.cc
@@ -3,69 +3,52 @@
 namespace bayesnet {
    using namespace torch;

-    Ensemble::Ensemble() : m(0), n(0), n_models(0), metrics(Metrics()), fitted(false) {}
-    Ensemble& Ensemble::build(vector<string>& features, string className, map<string, vector<int>>& states)
+    Ensemble::Ensemble() : Classifier(Network()) {}
+
+    void Ensemble::trainModel()
    {
-        dataset = cat({ X, y.view({y.size(0), 1}) }, 1);
-        this->features = features;
-        this->className = className;
-        this->states = states;
-        auto n_classes = states[className].size();
-        metrics = Metrics(dataset, features, className, n_classes);
-        // Build models
-        train();
-        // Train models
        n_models = models.size();
        for (auto i = 0; i < n_models; ++i) {
-            models[i]->fit(Xv, yv, features, className, states);
+            // fit with vectors
+            models[i]->fit(dataset, features, className, states);
        }
-        fitted = true;
-        return *this;
-    }
-    Ensemble& Ensemble::fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states)
-    {
-        this->X = X;
-        this->y = y;
-        Xv = vector<vector<int>>();
-        yv = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
-        return build(features, className, states);
-    }
-    Ensemble& Ensemble::fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states)
-    {
-        this->X = torch::zeros({ static_cast<int>(X[0].size()), static_cast<int>(X.size()) }, kInt32);
-        Xv = X;
-        for (int i = 0; i < X.size(); ++i) {
-            this->X.index_put_({ "...", i }, torch::tensor(X[i], kInt32));
-        }
-        this->y = torch::tensor(y, kInt32);
-        yv = y;
-        return build(features, className, states);
-    }
-    Tensor Ensemble::predict(Tensor& X)
-    {
-        if (!fitted) {
-            throw logic_error("Ensemble has not been fitted");
-        }
-        Tensor y_pred = torch::zeros({ X.size(0), n_models }, kInt32);
-        for (auto i = 0; i < n_models; ++i) {
-            y_pred.index_put_({ "...", i }, models[i]->predict(X));
-        }
-        return torch::tensor(voting(y_pred));
    }
    vector<int> Ensemble::voting(Tensor& y_pred)
    {
        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(states[className].size(), 0);
+            vector<float> votes(y_pred.size(1), 0);
            for (int j = 0; j < y_pred.size(1); ++j) {
                votes[y_pred_[i][j]] += 1;
            }
+            // argsort in descending order
            auto indices = argsort(votes);
            y_pred_final.push_back(indices[0]);
        }
        return y_pred_final;
    }
+    Tensor Ensemble::predict(Tensor& X)
+    {
+        if (!fitted) {
+            throw logic_error("Ensemble has not been fitted");
+        }
+        Tensor y_pred = torch::zeros({ X.size(1), n_models }, kInt32);
+        //Create a threadpool
+        auto threads{ vector<thread>() };
+        mutex mtx;
+        for (auto i = 0; i < n_models; ++i) {
+            threads.push_back(thread([&, i]() {
+                auto ypredict = models[i]->predict(X);
+                lock_guard<mutex> lock(mtx);
+                y_pred.index_put_({ "...", i }, ypredict);
+                }));
+        }
+        for (auto& thread : threads) {
+            thread.join();
+        }
+        return torch::tensor(voting(y_pred));
+    }
    vector<int> Ensemble::predict(vector<vector<int>>& X)
    {
        if (!fitted) {
@@ -110,9 +93,8 @@ namespace bayesnet {
            }
        }
        return (double)correct / y_pred.size();
-
    }
-    vector<string> Ensemble::show()
+    vector<string> Ensemble::show() const
    {
        auto result = vector<string>();
        for (auto i = 0; i < n_models; ++i) {
@@ -121,7 +103,7 @@ namespace bayesnet {
        }
        return result;
    }
-    vector<string> Ensemble::graph(string title)
+    vector<string> Ensemble::graph(const string& title) const
    {
        auto result = vector<string>();
        for (auto i = 0; i < n_models; ++i) {
@@ -130,7 +112,7 @@ namespace bayesnet {
        }
        return result;
    }
-    int Ensemble::getNumberOfNodes()
+    int Ensemble::getNumberOfNodes() const
    {
        int nodes = 0;
        for (auto i = 0; i < n_models; ++i) {
@@ -138,7 +120,7 @@ namespace bayesnet {
        }
        return nodes;
    }
-    int Ensemble::getNumberOfEdges()
+    int Ensemble::getNumberOfEdges() const
    {
        int edges = 0;
        for (auto i = 0; i < n_models; ++i) {
@@ -146,7 +128,7 @@ namespace bayesnet {
        }
        return edges;
    }
-    int Ensemble::getNumberOfStates()
+    int Ensemble::getNumberOfStates() const
    {
        int nstates = 0;
        for (auto i = 0; i < n_models; ++i) {
--- a/src/BayesNet/Ensemble.h
+++ b/src/BayesNet/Ensemble.h
@@ -8,39 +8,33 @@ using namespace std;
 using namespace torch;

 namespace bayesnet {
-    class Ensemble : public BaseClassifier {
+    class Ensemble : public Classifier {
    private:
-        bool fitted;
-        long n_models;
        Ensemble& build(vector<string>& features, string className, map<string, vector<int>>& states);
    protected:
+        unsigned n_models;
        vector<unique_ptr<Classifier>> models;
-        int m, n; // m: number of samples, n: number of features
-        Tensor X;
-        vector<vector<int>> Xv;
-        Tensor y;
-        vector<int> yv;
-        Tensor dataset;
-        Metrics metrics;
-        vector<string> features;
-        string className;
-        map<string, vector<int>> states;
-        void virtual train() = 0;
+        void trainModel() override;
        vector<int> voting(Tensor& y_pred);
    public:
        Ensemble();
        virtual ~Ensemble() = default;
-        Ensemble& fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
-        Ensemble& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
-        Tensor predict(Tensor& X);
+        Tensor predict(Tensor& X) override;
        vector<int> predict(vector<vector<int>>& X) override;
        float score(Tensor& X, Tensor& y) override;
        float score(vector<vector<int>>& X, vector<int>& y) override;
-        int getNumberOfNodes() override;
-        int getNumberOfEdges() override;
-        int getNumberOfStates() override;
-        vector<string> show() override;
-        vector<string> graph(string title) override;
+        int getNumberOfNodes() const override;
+        int getNumberOfEdges() const override;
+        int getNumberOfStates() const override;
+        vector<string> show() const override;
+        vector<string> graph(const string& title) const override;
+        vector<string> topological_order()  override
+        {
+            return vector<string>();
+        }
+        void dump_cpt() const override
+        {
+        }
    };
 }
 #endif
--- 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::train()
+    void KDB::buildModel()
    {
        /*
        1. For each feature Xi, compute mutual information, I(X;C),
@@ -27,9 +27,11 @@ namespace bayesnet {
        */
        // 1. For each feature Xi, compute mutual information, I(X;C),
        // where C is the class.
+        addNodes();
+        const Tensor& y = dataset.index({ -1, "..." });
        vector <float> mi;
        for (auto i = 0; i < features.size(); i++) {
-            Tensor firstFeature = X.index({ "...", i });
+            Tensor firstFeature = dataset.index({ i, "..." });
            mi.push_back(metrics.mutualInformation(firstFeature, y));
        }
        // 2. Compute class conditional mutual information I(Xi;XjIC), f or each
@@ -38,14 +40,12 @@ namespace bayesnet {
        vector<int> S;
        // 4. Let the DAG network being constructed, BN, begin with a single
        // class node, C.
-        model.addNode(className, states[className].size());
        // 5. Repeat until S includes all domain features
        // 5.1. Select feature Xmax which is not in S and has the largest value
        // I(Xmax;C).
        auto order = argsort(mi);
        for (auto idx : order) {
            // 5.2. Add a node to BN representing Xmax.
-            model.addNode(features[idx], states[features[idx]].size());
            // 5.3. Add an arc from C to Xmax in BN.
            model.addEdge(className, features[idx]);
            // 5.4. Add m = min(lSl,/c) arcs from m distinct features Xj in S with
@@ -79,11 +79,12 @@ namespace bayesnet {
            exit_cond = num == n_edges || candidates.size(0) == 0;
        }
    }
-    vector<string> KDB::graph(string title)
+    vector<string> KDB::graph(const string& title) const
    {
+        string header{ title };
        if (title == "KDB") {
-            title += " (k=" + to_string(k) + ", theta=" + to_string(theta) + ")";
+            header += " (k=" + to_string(k) + ", theta=" + to_string(theta) + ")";
        }
-        return model.graph(title);
+        return model.graph(header);
    }
 }
--- a/src/BayesNet/KDB.h
+++ b/src/BayesNet/KDB.h
@@ -11,10 +11,11 @@ namespace bayesnet {
        float theta;
        void add_m_edges(int idx, vector<int>& S, Tensor& weights);
    protected:
-        void train() override;
+        void buildModel() override;
    public:
        explicit KDB(int k, float theta = 0.03);
-        vector<string> graph(string name = "KDB") override;
+        virtual ~KDB() {};
+        vector<string> graph(const string& name = "KDB") const override;
    };
 }
 #endif
--- a/src/BayesNet/KDBLd.cc
+++ b/src/BayesNet/KDBLd.cc
@@ -0,0 +1,30 @@
+#include "KDBLd.h"
+
+namespace bayesnet {
+    using namespace std;
+    KDBLd::KDBLd(int k) : KDB(k), Proposal(dataset, features, className) {}
+    KDBLd& KDBLd::fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    {
+        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
+        features = features_;
+        className = className_;
+        Xf = X_;
+        y = y_;
+        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        states = fit_local_discretization(y);
+        // We have discretized the input data
+        // 1st we need to fit the model to build the normal KDB structure, KDB::fit initializes the base Bayesian network
+        KDB::fit(dataset, features, className, states);
+        states = localDiscretizationProposal(states, model);
+        return *this;
+    }
+    Tensor KDBLd::predict(Tensor& X)
+    {
+        auto Xt = prepareX(X);
+        return KDB::predict(Xt);
+    }
+    vector<string> KDBLd::graph(const string& name) const
+    {
+        return KDB::graph(name);
+    }
+}
--- a/src/BayesNet/KDBLd.h
+++ b/src/BayesNet/KDBLd.h
@@ -0,0 +1,19 @@
+#ifndef KDBLD_H
+#define KDBLD_H
+#include "KDB.h"
+#include "Proposal.h"
+
+namespace bayesnet {
+    using namespace std;
+    class KDBLd : public KDB, public Proposal {
+    private:
+    public:
+        explicit KDBLd(int k);
+        virtual ~KDBLd() = default;
+        KDBLd& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        vector<string> graph(const string& name = "KDB") const override;
+        Tensor predict(Tensor& X) override;
+        static inline string version() { return "0.0.1"; };
+    };
+}
+#endif // !KDBLD_H
--- a/src/BayesNet/Mst.cc
+++ b/src/BayesNet/Mst.cc
@@ -7,7 +7,7 @@

 namespace bayesnet {
    using namespace std;
-    Graph::Graph(int V) : V(V), parent{ vector<int>(V) }
+    Graph::Graph(int V) : V(V), parent(vector<int>(V))
    {
        for (int i = 0; i < V; i++)
            parent[i] = i;
@@ -33,10 +33,9 @@ namespace bayesnet {
    }
    void Graph::kruskal_algorithm()
    {
-        int i;
        // sort the edges ordered on decreasing weight
        sort(G.begin(), G.end(), [](const auto& left, const auto& right) {return left.first > right.first;});
-        for (i = 0; i < G.size(); i++) {
+        for (int i = 0; i < G.size(); i++) {
            int uSt, vEd;
            uSt = find_set(G[i].second.first);
            vEd = find_set(G[i].second.second);
@@ -95,7 +94,7 @@ namespace bayesnet {
        return result;
    }

-    MST::MST(vector<string>& features, Tensor& weights, int root) : features(features), weights(weights), root(root) {}
+    MST::MST(const vector<string>& features, const Tensor& weights, const int root) : features(features), weights(weights), root(root) {}
    vector<pair<int, int>> MST::maximumSpanningTree()
    {
        auto num_features = features.size();
--- a/src/BayesNet/Mst.h
+++ b/src/BayesNet/Mst.h
@@ -10,9 +10,10 @@ namespace bayesnet {
    private:
        Tensor weights;
        vector<string> features;
-        int root;
+        int root = 0;
    public:
-        MST(vector<string>& features, Tensor& weights, int root);
+        MST() = default;
+        MST(const vector<string>& features, const Tensor& weights, const int root);
        vector<pair<int, int>> maximumSpanningTree();
    };
    class Graph {
--- a/src/BayesNet/Network.cc
+++ b/src/BayesNet/Network.cc
@@ -3,15 +3,25 @@
 #include "Network.h"
 #include "bayesnetUtils.h"
 namespace bayesnet {
-    Network::Network() : laplaceSmoothing(1), features(vector<string>()), className(""), classNumStates(0), maxThreads(0.8), fitted(false) {}
-    Network::Network(const float maxT) : laplaceSmoothing(1), features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
-    Network::Network(const float maxT, const int smoothing) : laplaceSmoothing(smoothing), features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
-    Network::Network(const Network& other) : laplaceSmoothing(other.laplaceSmoothing), features(other.features), className(other.className), classNumStates(other.classNumStates), maxThreads(other.maxThreads), fitted(other.fitted)
+    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)
    {
        for (const auto& pair : other.nodes) {
            nodes[pair.first] = std::make_unique<Node>(*pair.second);
        }
    }
+    void Network::initialize()
+    {
+        features = vector<string>();
+        className = "";
+        classNumStates = 0;
+        fitted = false;
+        nodes.clear();
+        samples = torch::Tensor();
+    }
    float Network::getmaxThreads()
    {
        return maxThreads;
@@ -20,28 +30,28 @@ namespace bayesnet {
    {
        return samples;
    }
-    void Network::addNode(const string& name, const int numStates)
+    void Network::addNode(const string& name)
    {
+        if (name == "") {
+            throw invalid_argument("Node name cannot be empty");
+        }
+        if (nodes.find(name) != nodes.end()) {
+            return;
+        }
        if (find(features.begin(), features.end(), name) == features.end()) {
            features.push_back(name);
        }
-        if (nodes.find(name) != nodes.end()) {
-            // if node exists update its number of states and remove parents, children and CPT
-            nodes[name]->clear();
-            nodes[name]->setNumStates(numStates);
-            return;
-        }
-        nodes[name] = std::make_unique<Node>(name, numStates);
+        nodes[name] = std::make_unique<Node>(name);
    }
-    vector<string> Network::getFeatures()
+    vector<string> Network::getFeatures() const
    {
        return features;
    }
-    const int Network::getClassNumStates()
+    int Network::getClassNumStates() const
    {
        return classNumStates;
    }
-    const int Network::getStates()
+    int Network::getStates() const
    {
        int result = 0;
        for (auto& node : nodes) {
@@ -49,7 +59,7 @@ namespace bayesnet {
        }
        return result;
    }
-    const string Network::getClassName()
+    string Network::getClassName() const
    {
        return className;
    }
@@ -94,45 +104,72 @@ namespace bayesnet {
    {
        return nodes;
    }
-    void Network::fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& featureNames, const string& className)
+    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)
    {
-        features = featureNames;
-        this->className = className;
-        dataset.clear();
-        // Specific part
-        classNumStates = torch::max(y).item<int>() + 1;
-        samples = torch::cat({ X, y.view({ y.size(0), 1 }) }, 1);
-        for (int i = 0; i < featureNames.size(); ++i) {
-            auto column = torch::flatten(X.index({ "...", i }));
-            auto k = vector<int>();
-            for (auto z = 0; z < X.size(0); ++z) {
-                k.push_back(column[z].item<int>());
+        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) + ")");
+        }
+        if (n_features != featureNames.size()) {
+            throw invalid_argument("X and features must have the same number of features in Network::fit (" + to_string(n_features) + " != " + to_string(featureNames.size()) + ")");
+        }
+        if (n_features != features.size() - 1) {
+            throw invalid_argument("X and local features must have the same number of features in Network::fit (" + to_string(n_features) + " != " + to_string(features.size() - 1) + ")");
+        }
+        if (find(features.begin(), features.end(), className) == features.end()) {
+            throw invalid_argument("className not found in Network::features");
+        }
+        for (auto& feature : featureNames) {
+            if (find(features.begin(), features.end(), feature) == features.end()) {
+                throw invalid_argument("Feature " + feature + " not found in Network::features");
+            }
+            if (states.find(feature) == states.end()) {
+                throw invalid_argument("Feature " + feature + " not found in states");
            }
-            dataset[featureNames[i]] = k;
        }
-        dataset[className] = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
-        completeFit();
    }
-    void Network::fit(const vector<vector<int>>& input_data, const vector<int>& labels, const vector<string>& featureNames, const string& className)
+    void Network::setStates(const map<string, vector<int>>& states)
    {
-        features = featureNames;
+        // Set states to every Node in the network
+        for (int i = 0; i < features.size(); ++i) {
+            nodes[features[i]]->setNumStates(states.at(features[i]).size());
+        }
+        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)
+    {
+        checkFitData(X.size(1), X.size(0), y.size(0), featureNames, className, states);
        this->className = className;
-        dataset.clear();
-        // Specific part
-        classNumStates = *max_element(labels.begin(), labels.end()) + 1;
-        // Build dataset & tensor of samples
-        samples = torch::zeros({ static_cast<int>(input_data[0].size()), static_cast<int>(input_data.size() + 1) }, torch::kInt32);
+        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) {
-            dataset[featureNames[i]] = input_data[i];
-            samples.index_put_({ "...", i }, torch::tensor(input_data[i], torch::kInt32));
+            auto row_feature = X.index({ i, "..." });
        }
-        dataset[className] = labels;
-        samples.index_put_({ "...", -1 }, torch::tensor(labels, torch::kInt32));
-        completeFit();
+        completeFit(states);
    }
-    void Network::completeFit()
+    void Network::fit(const torch::Tensor& samples, 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);
+        this->className = className;
+        this->samples = samples;
+        completeFit(states);
+    }
+    // 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)
+    {
+        checkFitData(input_data[0].size(), input_data.size(), labels.size(), featureNames, className, states);
+        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);
+        for (int i = 0; i < featureNames.size(); ++i) {
+            samples.index_put_({ i, "..." }, torch::tensor(input_data[i], torch::kInt32));
+        }
+        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
+        completeFit(states);
+    }
+    void Network::completeFit(const map<string, vector<int>>& states)
+    {
+        setStates(states);
        int maxThreadsRunning = static_cast<int>(std::thread::hardware_concurrency() * maxThreads);
        if (maxThreadsRunning < 1) {
            maxThreadsRunning = 1;
@@ -145,9 +182,6 @@ namespace bayesnet {
        while (nextNodeIndex < nodes.size()) {
            unique_lock<mutex> lock(mtx);
            cv.wait(lock, [&activeThreads, &maxThreadsRunning]() { return activeThreads < maxThreadsRunning; });
-            if (nextNodeIndex >= nodes.size()) {
-                break;  // No more work remaining
-            }
            threads.emplace_back([this, &nextNodeIndex, &mtx, &cv, &activeThreads]() {
                while (true) {
                    unique_lock<mutex> lock(mtx);
@@ -157,7 +191,7 @@ namespace bayesnet {
                    auto& pair = *std::next(nodes.begin(), nextNodeIndex);
                    ++nextNodeIndex;
                    lock.unlock();
-                    pair.second->computeCPT(dataset, laplaceSmoothing);
+                    pair.second->computeCPT(samples, features, laplaceSmoothing);
                    lock.lock();
                    nodes[pair.first] = std::move(pair.second);
                    lock.unlock();
@@ -173,7 +207,39 @@ namespace bayesnet {
        }
        fitted = true;
    }
+    torch::Tensor Network::predict_tensor(const torch::Tensor& samples, const bool proba)
+    {
+        if (!fitted) {
+            throw logic_error("You must call fit() before calling predict()");
+        }
+        torch::Tensor result;
+        result = torch::zeros({ samples.size(1), classNumStates }, torch::kFloat64);
+        for (int i = 0; i < samples.size(1); ++i) {
+            const Tensor sample = samples.index({ "...", i });
+            auto psample = predict_sample(sample);
+            auto temp = torch::tensor(psample, torch::kFloat64);
+            //            result.index_put_({ i, "..." }, torch::tensor(predict_sample(sample), torch::kFloat64));
+            result.index_put_({ i, "..." }, temp);
+        }
+        if (proba)
+            return result;
+        else
+            return result.argmax(1);
+    }
+    // Return mxn tensor of probabilities
+    Tensor Network::predict_proba(const Tensor& samples)
+    {
+        return predict_tensor(samples, true);
+    }

+    // Return mxn tensor of probabilities
+    Tensor Network::predict(const Tensor& samples)
+    {
+        return predict_tensor(samples, false);
+    }
+
+    // Return mx1 vector of predictions
+    // tsamples is nxm vector of samples
    vector<int> Network::predict(const vector<vector<int>>& tsamples)
    {
        if (!fitted) {
@@ -194,6 +260,7 @@ namespace bayesnet {
        }
        return predictions;
    }
+    // Return mxn vector of probabilities
    vector<vector<double>> Network::predict_proba(const vector<vector<int>>& tsamples)
    {
        if (!fitted) {
@@ -221,12 +288,13 @@ namespace bayesnet {
        }
        return (double)correct / y_pred.size();
    }
+    // Return 1xn vector of probabilities
    vector<double> Network::predict_sample(const vector<int>& sample)
    {
        // Ensure the sample size is equal to the number of features
-        if (sample.size() != features.size()) {
+        if (sample.size() != features.size() - 1) {
            throw invalid_argument("Sample size (" + to_string(sample.size()) +
-                ") does not match the number of features (" + to_string(features.size()) + ")");
+                ") does not match the number of features (" + to_string(features.size() - 1) + ")");
        }
        map<string, int> evidence;
        for (int i = 0; i < sample.size(); ++i) {
@@ -234,6 +302,20 @@ namespace bayesnet {
        }
        return exactInference(evidence);
    }
+    // Return 1xn vector of probabilities
+    vector<double> Network::predict_sample(const Tensor& sample)
+    {
+        // Ensure the sample size is equal to the number of features
+        if (sample.size(0) != features.size() - 1) {
+            throw invalid_argument("Sample size (" + to_string(sample.size(0)) +
+                ") does not match the number of features (" + to_string(features.size() - 1) + ")");
+        }
+        map<string, int> evidence;
+        for (int i = 0; i < sample.size(0); ++i) {
+            evidence[features[i]] = sample[i].item<int>();
+        }
+        return exactInference(evidence);
+    }
    double Network::computeFactor(map<string, int>& completeEvidence)
    {
        double result = 1.0;
@@ -259,13 +341,12 @@ namespace bayesnet {
        for (auto& thread : threads) {
            thread.join();
        }
-
        // Normalize result
        double sum = accumulate(result.begin(), result.end(), 0.0);
-        transform(result.begin(), result.end(), result.begin(), [sum](double x) { return x / sum; });
+        transform(result.begin(), result.end(), result.begin(), [sum](double& value) { return value / sum; });
        return result;
    }
-    vector<string> Network::show()
+    vector<string> Network::show() const
    {
        vector<string> result;
        // Draw the network
@@ -278,7 +359,7 @@ namespace bayesnet {
        }
        return result;
    }
-    vector<string> Network::graph(const string& title)
+    vector<string> Network::graph(const string& title) const
    {
        auto output = vector<string>();
        auto prefix = "digraph BayesNet {\nlabel=<BayesNet ";
@@ -292,7 +373,7 @@ namespace bayesnet {
        output.push_back("}\n");
        return output;
    }
-    vector<pair<string, string>> Network::getEdges()
+    vector<pair<string, string>> Network::getEdges() const
    {
        auto edges = vector<pair<string, string>>();
        for (const auto& node : nodes) {
@@ -304,4 +385,52 @@ namespace bayesnet {
        }
        return edges;
    }
+    int Network::getNumEdges() const
+    {
+        return getEdges().size();
+    }
+    vector<string> Network::topological_sort()
+    {
+        /* Check if al the fathers of every node are before the node */
+        auto result = features;
+        result.erase(remove(result.begin(), result.end(), className), result.end());
+        bool ending{ false };
+        int idx = 0;
+        while (!ending) {
+            ending = true;
+            for (auto feature : features) {
+                auto fathers = nodes[feature]->getParents();
+                for (const auto& father : fathers) {
+                    auto fatherName = father->getName();
+                    if (fatherName == className) {
+                        continue;
+                    }
+                    // Check if father is placed before the actual feature
+                    auto it = find(result.begin(), result.end(), fatherName);
+                    if (it != result.end()) {
+                        auto it2 = find(result.begin(), result.end(), feature);
+                        if (it2 != result.end()) {
+                            if (distance(it, it2) < 0) {
+                                // if it is not, insert it before the feature
+                                result.erase(remove(result.begin(), result.end(), fatherName), result.end());
+                                result.insert(it2, fatherName);
+                                ending = false;
+                            }
+                        } else {
+                            throw logic_error("Error in topological sort because of node " + feature + " is not in result");
+                        }
+                    } else {
+                        throw logic_error("Error in topological sort because of node father " + fatherName + " is not in result");
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    void Network::dump_cpt() const
+    {
+        for (auto& node : nodes) {
+            cout << "* " << node.first << ": (" << node.second->getNumStates() << ") : " << node.second->getCPT().sizes() << endl;
+        }
+    }
 }
--- a/src/BayesNet/Network.h
+++ b/src/BayesNet/Network.h
@@ -8,47 +8,51 @@ namespace bayesnet {
    class Network {
    private:
        map<string, unique_ptr<Node>> nodes;
-        map<string, vector<int>> dataset;
        bool fitted;
-        float maxThreads;
+        float maxThreads = 0.95;
        int classNumStates;
-        vector<string> features;
+        vector<string> features; // Including classname
        string className;
-        int laplaceSmoothing;
-        torch::Tensor samples;
+        int laplaceSmoothing = 1;
+        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>&);
-        double mutual_info(torch::Tensor&, torch::Tensor&);
-        double entropy(torch::Tensor&);
-        double conditionalEntropy(torch::Tensor&, torch::Tensor&);
-        double mutualInformation(torch::Tensor&, torch::Tensor&);
-        void completeFit();
+        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 setStates(const map<string, vector<int>>&);
    public:
        Network();
-        explicit Network(const float, const int);
-        explicit Network(const float);
-        explicit Network(const Network&);
+        explicit Network(float, int);
+        explicit Network(float);
+        explicit Network(Network&);
        torch::Tensor& getSamples();
        float getmaxThreads();
-        void addNode(const string&, const int);
+        void addNode(const string&);
        void addEdge(const string&, const string&);
        map<string, std::unique_ptr<Node>>& getNodes();
-        vector<string> getFeatures();
-        const int getStates();
-        vector<pair<string, string>> getEdges();
-        const int getClassNumStates();
-        const string getClassName();
-        void fit(const vector<vector<int>>&, const vector<int>&, const vector<string>&, const string&);
-        void fit(torch::Tensor&, torch::Tensor&, const vector<string>&, const string&);
-        vector<int> predict(const vector<vector<int>>&);
-        //Computes the conditional edge weight of variable index u and v conditioned on class_node
-        torch::Tensor conditionalEdgeWeight();
-        vector<vector<double>> predict_proba(const vector<vector<int>>&);
+        vector<string> getFeatures() const;
+        int getStates() const;
+        vector<pair<string, string>> getEdges() const;
+        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>>&);
+        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);
+        vector<vector<double>> predict_proba(const vector<vector<int>>&); // Return mxn vector of probabilities
+        torch::Tensor predict_proba(const torch::Tensor&); // Return mxn tensor of probabilities
        double score(const vector<vector<int>>&, const vector<int>&);
-        vector<string> show();
-        vector<string> graph(const string& title); // Returns a vector of strings representing the graph in graphviz format
+        vector<string> topological_sort();
+        vector<string> show() const;
+        vector<string> graph(const string& title) const; // Returns a vector of strings representing the graph in graphviz format
+        void initialize();
+        void dump_cpt() const;
        inline string version() { return "0.1.0"; }
    };
 }
--- a/src/BayesNet/Node.cc
+++ b/src/BayesNet/Node.cc
@@ -2,8 +2,8 @@

 namespace bayesnet {

-    Node::Node(const std::string& name, int numStates)
-        : name(name), numStates(numStates), cpTable(torch::Tensor()), parents(vector<Node*>()), children(vector<Node*>())
+    Node::Node(const std::string& name)
+        : name(name), numStates(0), cpTable(torch::Tensor()), parents(vector<Node*>()), children(vector<Node*>())
    {
    }
    void Node::clear()
@@ -84,18 +84,32 @@ namespace bayesnet {
        }
        return result;
    }
-    void Node::computeCPT(map<string, vector<int>>& dataset, const int laplaceSmoothing)
+    void Node::computeCPT(const torch::Tensor& dataset, const vector<string>& features, const int laplaceSmoothing)
    {
+        dimensions.clear();
        // Get dimensions of the CPT
        dimensions.push_back(numStates);
-        transform(parents.begin(), parents.end(), back_inserter(dimensions), [](Node* parent) { return parent->getNumStates(); });
+        transform(parents.begin(), parents.end(), back_inserter(dimensions), [](const auto& parent) { return parent->getNumStates(); });
+
        // Create a tensor of zeros with the dimensions of the CPT
        cpTable = torch::zeros(dimensions, torch::kFloat) + laplaceSmoothing;
        // Fill table with counts
-        for (int n_sample = 0; n_sample < dataset[name].size(); ++n_sample) {
+        auto pos = find(features.begin(), features.end(), name);
+        if (pos == features.end()) {
+            throw logic_error("Feature " + name + " not found in dataset");
+        }
+        int name_index = pos - features.begin();
+        for (int n_sample = 0; n_sample < dataset.size(1); ++n_sample) {
            torch::List<c10::optional<torch::Tensor>> coordinates;
-            coordinates.push_back(torch::tensor(dataset[name][n_sample]));
-            transform(parents.begin(), parents.end(), back_inserter(coordinates), [&dataset, &n_sample](Node* parent) { return torch::tensor(dataset[parent->getName()][n_sample]); });
+            coordinates.push_back(dataset.index({ name_index, n_sample }));
+            for (auto parent : parents) {
+                pos = find(features.begin(), features.end(), parent->getName());
+                if (pos == features.end()) {
+                    throw logic_error("Feature parent " + parent->getName() + " not found in dataset");
+                }
+                int parent_index = pos - features.begin();
+                coordinates.push_back(dataset.index({ parent_index, n_sample }));
+            }
            // Increment the count of the corresponding coordinate
            cpTable.index_put_({ coordinates }, cpTable.index({ coordinates }) + 1);
        }
@@ -107,7 +121,7 @@ namespace bayesnet {
        torch::List<c10::optional<torch::Tensor>> coordinates;
        // following predetermined order of indices in the cpTable (see Node.h)
        coordinates.push_back(torch::tensor(evidence[name]));
-        transform(parents.begin(), parents.end(), back_inserter(coordinates), [&evidence](Node* parent) { return torch::tensor(evidence[parent->getName()]); });
+        transform(parents.begin(), parents.end(), back_inserter(coordinates), [&evidence](const auto& parent) { return torch::tensor(evidence[parent->getName()]); });
        return cpTable.index({ coordinates }).item<float>();
    }
    vector<string> Node::graph(const string& className)
@@ -115,7 +129,7 @@ namespace bayesnet {
        auto output = vector<string>();
        auto suffix = name == className ? ", fontcolor=red, fillcolor=lightblue, style=filled " : "";
        output.push_back(name + " [shape=circle" + suffix + "] \n");
-        transform(children.begin(), children.end(), back_inserter(output), [this](Node* child) { return name + " -> " + child->getName() + "\n"; });
+        transform(children.begin(), children.end(), back_inserter(output), [this](const auto& child) { return name + " -> " + child->getName(); });
        return output;
    }
 }
--- a/src/BayesNet/Node.h
+++ b/src/BayesNet/Node.h
@@ -16,7 +16,7 @@ namespace bayesnet {
        vector<int64_t> dimensions; // dimensions of the cpTable
    public:
        vector<pair<string, string>> combinations(const vector<string>&);
-        Node(const std::string&, int);
+        explicit Node(const string&);
        void clear();
        void addParent(Node*);
        void addChild(Node*);
@@ -26,7 +26,7 @@ namespace bayesnet {
        vector<Node*>& getParents();
        vector<Node*>& getChildren();
        torch::Tensor& getCPT();
-        void computeCPT(map<string, vector<int>>&, const int);
+        void computeCPT(const torch::Tensor&, const vector<string>&, const int);
        int getNumStates() const;
        void setNumStates(int);
        unsigned minFill();
--- a/src/BayesNet/Proposal.cc
+++ b/src/BayesNet/Proposal.cc
@@ -0,0 +1,109 @@
+#include "Proposal.h"
+#include "ArffFiles.h"
+
+namespace bayesnet {
+    Proposal::Proposal(torch::Tensor& dataset_, vector<string>& features_, string& className_) : pDataset(dataset_), pFeatures(features_), pClassName(className_) {}
+    Proposal::~Proposal()
+    {
+        for (auto& [key, value] : discretizers) {
+            delete value;
+        }
+    }
+    map<string, vector<int>> Proposal::localDiscretizationProposal(const map<string, vector<int>>& oldStates, Network& model)
+    {
+        // order of local discretization is important. no good 0, 1, 2...
+        // although we rediscretize features after the local discretization of every feature
+        auto order = model.topological_sort();
+        auto& nodes = model.getNodes();
+        map<string, vector<int>> states = oldStates;
+        vector<int> indicesToReDiscretize;
+        bool upgrade = false; // Flag to check if we need to upgrade the model
+        for (auto feature : order) {
+            auto nodeParents = nodes[feature]->getParents();
+            if (nodeParents.size() < 2) continue; // Only has class as parent
+            upgrade = true;
+            int index = find(pFeatures.begin(), pFeatures.end(), feature) - pFeatures.begin();
+            indicesToReDiscretize.push_back(index); // We need to re-discretize this feature
+            vector<string> parents;
+            transform(nodeParents.begin(), nodeParents.end(), back_inserter(parents), [](const auto& p) { return p->getName(); });
+            // Remove class as parent as it will be added later
+            parents.erase(remove(parents.begin(), parents.end(), pClassName), parents.end());
+            // Get the indices of the parents
+            vector<int> indices;
+            indices.push_back(-1); // Add class index
+            transform(parents.begin(), parents.end(), back_inserter(indices), [&](const auto& p) {return find(pFeatures.begin(), pFeatures.end(), p) - pFeatures.begin(); });
+            // Now we fit the discretizer of the feature, conditioned on its parents and the class i.e. discretizer.fit(X[index], X[indices] + y)
+            vector<string> yJoinParents(Xf.size(1));
+            for (auto idx : indices) {
+                for (int i = 0; i < Xf.size(1); ++i) {
+                    yJoinParents[i] += to_string(pDataset.index({ idx, i }).item<int>());
+                }
+            }
+            auto arff = ArffFiles();
+            auto yxv = arff.factorize(yJoinParents);
+            auto xvf_ptr = Xf.index({ index }).data_ptr<float>();
+            auto xvf = vector<mdlp::precision_t>(xvf_ptr, xvf_ptr + Xf.size(1));
+            discretizers[feature]->fit(xvf, yxv);
+            //
+            //
+            //
+            // auto tmp = discretizers[feature]->transform(xvf);
+            // Xv[index] = tmp;
+            // auto xStates = vector<int>(discretizers[pFeatures[index]]->getCutPoints().size() + 1);
+            // iota(xStates.begin(), xStates.end(), 0);
+            // //Update new states of the feature/node
+            // states[feature] = xStates;
+        }
+        if (upgrade) {
+            // Discretize again X (only the affected indices) with the new fitted discretizers
+            for (auto index : indicesToReDiscretize) {
+                auto Xt_ptr = Xf.index({ index }).data_ptr<float>();
+                auto Xt = vector<float>(Xt_ptr, Xt_ptr + Xf.size(1));
+                pDataset.index_put_({ index, "..." }, torch::tensor(discretizers[pFeatures[index]]->transform(Xt)));
+                auto xStates = vector<int>(discretizers[pFeatures[index]]->getCutPoints().size() + 1);
+                iota(xStates.begin(), xStates.end(), 0);
+                //Update new states of the feature/node
+                states[pFeatures[index]] = xStates;
+            }
+            model.fit(pDataset, pFeatures, pClassName, states);
+        }
+        return states;
+    }
+    map<string, vector<int>> Proposal::fit_local_discretization(const torch::Tensor& y)
+    {
+        // Discretize the continuous input data and build pDataset (Classifier::dataset)
+        int m = Xf.size(1);
+        int n = Xf.size(0);
+        map<string, vector<int>> states;
+        pDataset = torch::zeros({ n + 1, m }, kInt32);
+        auto yv = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
+        // discretize input data by feature(row)
+        for (auto i = 0; i < pFeatures.size(); ++i) {
+            auto* discretizer = new mdlp::CPPFImdlp();
+            auto Xt_ptr = Xf.index({ i }).data_ptr<float>();
+            auto Xt = vector<float>(Xt_ptr, Xt_ptr + Xf.size(1));
+            discretizer->fit(Xt, yv);
+            pDataset.index_put_({ i, "..." }, torch::tensor(discretizer->transform(Xt)));
+            auto xStates = vector<int>(discretizer->getCutPoints().size() + 1);
+            iota(xStates.begin(), xStates.end(), 0);
+            states[pFeatures[i]] = xStates;
+            discretizers[pFeatures[i]] = discretizer;
+        }
+        int n_classes = torch::max(y).item<int>() + 1;
+        auto yStates = vector<int>(n_classes);
+        iota(yStates.begin(), yStates.end(), 0);
+        states[pClassName] = yStates;
+        pDataset.index_put_({ n, "..." }, y);
+        return states;
+    }
+    torch::Tensor Proposal::prepareX(torch::Tensor& X)
+    {
+        auto Xtd = torch::zeros_like(X, torch::kInt32);
+        for (int i = 0; i < X.size(0); ++i) {
+            auto Xt = vector<float>(X[i].data_ptr<float>(), X[i].data_ptr<float>() + X.size(1));
+            auto Xd = discretizers[pFeatures[i]]->transform(Xt);
+            Xtd.index_put_({ i }, torch::tensor(Xd, torch::kInt32));
+        }
+        return Xtd;
+    }
+}
--- a/src/BayesNet/Proposal.h
+++ b/src/BayesNet/Proposal.h
@@ -0,0 +1,29 @@
+#ifndef PROPOSAL_H
+#define PROPOSAL_H
+#include <string>
+#include <map>
+#include <torch/torch.h>
+#include "Network.h"
+#include "CPPFImdlp.h"
+#include "Classifier.h"
+
+namespace bayesnet {
+    class Proposal {
+    public:
+        Proposal(torch::Tensor& pDataset, vector<string>& features_, string& className_);
+        virtual ~Proposal();
+    protected:
+        torch::Tensor prepareX(torch::Tensor& X);
+        map<string, vector<int>> localDiscretizationProposal(const map<string, vector<int>>& states, Network& model);
+        map<string, vector<int>> fit_local_discretization(const torch::Tensor& y);
+        torch::Tensor Xf; // X continuous nxm tensor
+        torch::Tensor y; // y discrete nx1 tensor
+        map<string, mdlp::CPPFImdlp*> discretizers;
+    private:
+        torch::Tensor& pDataset; // (n+1)xm tensor
+        vector<string>& pFeatures;
+        string& pClassName;
+    };
+}
+
+#endif  
--- 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::train()
+    void SPODE::buildModel()
    {
        // 0. Add all nodes to the model
        addNodes();
@@ -17,7 +17,7 @@ namespace bayesnet {
            }
        }
    }
-    vector<string> SPODE::graph(string name )
+    vector<string> SPODE::graph(const string& name) const
    {
        return model.graph(name);
    }
--- a/src/BayesNet/SPODE.h
+++ b/src/BayesNet/SPODE.h
@@ -1,15 +1,17 @@
 #ifndef SPODE_H
 #define SPODE_H
 #include "Classifier.h"
+
 namespace bayesnet {
    class SPODE : public Classifier {
    private:
        int root;
    protected:
-        void train() override;
+        void buildModel() override;
    public:
        explicit SPODE(int root);
-        vector<string> graph(string name = "SPODE") override;
+        virtual ~SPODE() {};
+        vector<string> graph(const string& name = "SPODE") const override;
    };
 }
 #endif
--- a/src/BayesNet/SPODELd.cc
+++ b/src/BayesNet/SPODELd.cc
@@ -0,0 +1,47 @@
+#include "SPODELd.h"
+
+namespace bayesnet {
+    using namespace std;
+    SPODELd::SPODELd(int root) : SPODE(root), Proposal(dataset, features, className) {}
+    SPODELd& SPODELd::fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    {
+        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
+        features = features_;
+        className = className_;
+        Xf = X_;
+        y = y_;
+        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        states = fit_local_discretization(y);
+        // We have discretized the input data
+        // 1st we need to fit the model to build the normal SPODE structure, SPODE::fit initializes the base Bayesian network
+        SPODE::fit(dataset, features, className, states);
+        states = localDiscretizationProposal(states, model);
+        return *this;
+    }
+    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_;
+        className = className_;
+        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        states = fit_local_discretization(y);
+        // We have discretized the input data
+        // 1st we need to fit the model to build the normal SPODE structure, SPODE::fit initializes the base Bayesian network
+        SPODE::fit(dataset, features, className, states);
+        states = localDiscretizationProposal(states, model);
+        return *this;
+    }
+
+    Tensor SPODELd::predict(Tensor& X)
+    {
+        auto Xt = prepareX(X);
+        return SPODE::predict(Xt);
+    }
+    vector<string> SPODELd::graph(const string& name) const
+    {
+        return SPODE::graph(name);
+    }
+}
--- a/src/BayesNet/SPODELd.h
+++ b/src/BayesNet/SPODELd.h
@@ -0,0 +1,19 @@
+#ifndef SPODELD_H
+#define SPODELD_H
+#include "SPODE.h"
+#include "Proposal.h"
+
+namespace bayesnet {
+    using namespace std;
+    class SPODELd : public SPODE, public Proposal {
+    public:
+        explicit SPODELd(int root);
+        virtual ~SPODELd() = default;
+        SPODELd& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        SPODELd& fit(torch::Tensor& 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;
+        static inline string version() { return "0.0.1"; };
+    };
+}
+#endif // !SPODELD_H
--- a/src/BayesNet/TAN.cc
+++ b/src/BayesNet/TAN.cc
@@ -5,16 +5,16 @@ namespace bayesnet {

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

-    void TAN::train()
+    void TAN::buildModel()
    {
        // 0. Add all nodes to the model
        addNodes();
        // 1. Compute mutual information between each feature and the class and set the root node
        // as the highest mutual information with the class
        auto mi = vector <pair<int, float >>();
-        Tensor class_dataset = dataset.index({ "...", -1 });
+        Tensor class_dataset = dataset.index({ -1, "..." });
        for (int i = 0; i < static_cast<int>(features.size()); ++i) {
-            Tensor feature_dataset = dataset.index({ "...", i });
+            Tensor feature_dataset = dataset.index({ i, "..." });
            auto mi_value = metrics.mutualInformation(class_dataset, feature_dataset);
            mi.push_back({ i, mi_value });
        }
@@ -34,7 +34,7 @@ namespace bayesnet {
            model.addEdge(className, feature);
        }
    }
-    vector<string> TAN::graph(string title)
+    vector<string> TAN::graph(const string& title) const
    {
        return model.graph(title);
    }
--- a/src/BayesNet/TAN.h
+++ b/src/BayesNet/TAN.h
@@ -7,10 +7,11 @@ namespace bayesnet {
    class TAN : public Classifier {
    private:
    protected:
-        void train() override;
+        void buildModel() override;
    public:
        TAN();
-        vector<string> graph(string name = "TAN") override;
+        virtual ~TAN() {};
+        vector<string> graph(const string& name = "TAN") const override;
    };
 }
 #endif
--- a/src/BayesNet/TANLd.cc
+++ b/src/BayesNet/TANLd.cc
@@ -0,0 +1,31 @@
+#include "TANLd.h"
+
+namespace bayesnet {
+    using namespace std;
+    TANLd::TANLd() : TAN(), Proposal(dataset, features, className) {}
+    TANLd& TANLd::fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    {
+        // This first part should go in a Classifier method called fit_local_discretization o fit_float...
+        features = features_;
+        className = className_;
+        Xf = X_;
+        y = y_;
+        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        states = fit_local_discretization(y);
+        // We have discretized the input data
+        // 1st we need to fit the model to build the normal TAN structure, TAN::fit initializes the base Bayesian network
+        TAN::fit(dataset, features, className, states);
+        states = localDiscretizationProposal(states, model);
+        return *this;
+
+    }
+    Tensor TANLd::predict(Tensor& X)
+    {
+        auto Xt = prepareX(X);
+        return TAN::predict(Xt);
+    }
+    vector<string> TANLd::graph(const string& name) const
+    {
+        return TAN::graph(name);
+    }
+}
--- a/src/BayesNet/TANLd.h
+++ b/src/BayesNet/TANLd.h
@@ -0,0 +1,19 @@
+#ifndef TANLD_H
+#define TANLD_H
+#include "TAN.h"
+#include "Proposal.h"
+
+namespace bayesnet {
+    using namespace std;
+    class TANLd : public TAN, public Proposal {
+    private:
+    public:
+        TANLd();
+        virtual ~TANLd() = default;
+        TANLd& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        vector<string> graph(const string& name = "TAN") const override;
+        Tensor predict(Tensor& X) override;
+        static inline string version() { return "0.0.1"; };
+    };
+}
+#endif // !TANLD_H
--- a/src/BayesNet/bayesnetUtils.cc
+++ b/src/BayesNet/bayesnetUtils.cc
@@ -3,6 +3,7 @@
 namespace bayesnet {
    using namespace std;
    using namespace torch;
+    // Return the indices in descending order
    vector<int> argsort(vector<float>& nums)
    {
        int n = nums.size();
--- a/src/Platform/CMakeLists.txt
+++ b/src/Platform/CMakeLists.txt
@@ -4,5 +4,5 @@ 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 CrossValidation.cc Models.cc)
+add_executable(main main.cc Folding.cc platformUtils.cc Experiment.cc Datasets.cc Models.cc Report.cc)
 target_link_libraries(main BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}")
--- a/src/Platform/CrossValidation.cc
+++ b/src/Platform/CrossValidation.cc
@@ -1,79 +0,0 @@
-#include "CrossValidation.h"
-#include "Models.h"
-
-namespace platform {
-    using json = nlohmann::json;
-    using namespace std::chrono;
-
-    CrossValidation::CrossValidation(const string& modelName, bool stratified, int nfolds, const vector<int>& randomSeeds, platform::Datasets& datasets) : modelName(modelName), stratified(stratified), nfolds(nfolds), randomSeeds(randomSeeds), datasets(datasets)
-    {
-    }
-
-    Result CrossValidation::crossValidate(const string& fileName)
-    {
-        auto [Xt, y] = datasets.getTensors(fileName);
-        auto states = datasets.getStates(fileName);
-        auto className = datasets.getClassName(fileName);
-        auto features = datasets.getFeatures(fileName);
-        auto samples = datasets.getNSamples(fileName);
-        auto result = Result();
-        auto [values, counts] = at::_unique(y);
-        result.setSamples(Xt.size(1)).setFeatures(Xt.size(0)).setClasses(values.size(0));
-        int nSeeds = static_cast<int>(randomSeeds.size());
-        auto accuracy_test = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
-        auto accuracy_train = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
-        auto train_time = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
-        auto test_time = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
-        auto nodes = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
-        auto edges = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
-        auto num_states = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
-        Timer train_timer, test_timer;
-        int item = 0;
-        for (auto seed : randomSeeds) {
-            cout << "(" << seed << ") " << flush;
-            Fold* fold;
-            if (stratified)
-                fold = new StratifiedKFold(nfolds, y, seed);
-            else
-                fold = new KFold(nfolds, samples, seed);
-            cout << "Fold: " << flush;
-            for (int nfold = 0; nfold < nfolds; nfold++) {
-                bayesnet::BaseClassifier* model = Models::get(modelName);
-                result.setModelVersion(model->getVersion());
-                train_timer.start();
-                auto [train, test] = fold->getFold(nfold);
-                auto train_t = torch::tensor(train);
-                auto test_t = torch::tensor(test);
-                auto X_train = Xt.index({ "...", train_t });
-                auto y_train = y.index({ train_t });
-                auto X_test = Xt.index({ "...", test_t });
-                auto y_test = y.index({ test_t });
-                cout << nfold + 1 << ", " << flush;
-                model->fit(X_train, y_train, features, className, states);
-                nodes[item] = model->getNumberOfNodes();
-                edges[item] = model->getNumberOfEdges();
-                num_states[item] = model->getNumberOfStates();
-                train_time[item] = train_timer.getDuration();
-                auto accuracy_train_value = model->score(X_train, y_train);
-                test_timer.start();
-                auto accuracy_test_value = model->score(X_test, y_test);
-                test_time[item] = test_timer.getDuration();
-                accuracy_train[item] = accuracy_train_value;
-                accuracy_test[item] = accuracy_test_value;
-                // Store results and times in vector
-                result.addScoreTrain(accuracy_train_value);
-                result.addScoreTest(accuracy_test_value);
-                result.addTimeTrain(train_time[item].item<double>());
-                result.addTimeTest(test_time[item].item<double>());
-                item++;
-            }
-            delete fold;
-        }
-        cout << "end." << endl;
-        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.setNodes(torch::mean(nodes).item<double>()).setLeaves(torch::mean(edges).item<double>()).setDepth(torch::mean(num_states).item<double>());
-        return result;
-    }
-} // namespace platform
--- a/src/Platform/CrossValidation.h
+++ b/src/Platform/CrossValidation.h
@@ -1,25 +0,0 @@
-#ifndef CROSSVALIDATION_H
-#define CROSSVALIDATION_H
-#include <torch/torch.h>
-#include <nlohmann/json.hpp>
-#include <string>
-#include <chrono>
-#include "Folding.h"
-#include "Datasets.h"
-#include "Experiment.h"
-
-namespace platform {
-    class CrossValidation {
-    private:
-        bool stratified;
-        int nfolds;
-        string modelName;
-        vector<int> randomSeeds;
-        platform::Datasets& datasets;
-    public:
-        CrossValidation(const string& modelName, bool stratified, int nfolds, const vector<int>& randomSeeds, platform::Datasets& datasets);
-        ~CrossValidation() = default;
-        Result crossValidate(const string& fileName);
-    };
-}
-#endif // !CROSSVALIDATION_H
--- a/src/Platform/Datasets.cc
+++ b/src/Platform/Datasets.cc
@@ -2,16 +2,6 @@
 #include "platformUtils.h"
 #include "ArffFiles.h"
 namespace platform {
-    vector<string> split(const string& text, char delimiter)
-    {
-        vector<string> result;
-        stringstream ss(text);
-        string token;
-        while (getline(ss, token, delimiter)) {
-            result.push_back(token);
-        }
-        return result;
-    }
    void Datasets::load()
    {
        ifstream catalog(path + "/all.txt");
@@ -34,7 +24,7 @@ namespace platform {
        transform(datasets.begin(), datasets.end(), back_inserter(result), [](const auto& d) { return d.first; });
        return result;
    }
-    vector<string> Datasets::getFeatures(const string& name)
+    vector<string> Datasets::getFeatures(string name)
    {
        if (datasets[name]->isLoaded()) {
            return datasets[name]->getFeatures();
@@ -42,7 +32,7 @@ namespace platform {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    map<string, vector<int>> Datasets::getStates(const string& name)
+    map<string, vector<int>> Datasets::getStates(string name)
    {
        if (datasets[name]->isLoaded()) {
            return datasets[name]->getStates();
@@ -50,7 +40,7 @@ namespace platform {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    string Datasets::getClassName(const string& name)
+    string Datasets::getClassName(string name)
    {
        if (datasets[name]->isLoaded()) {
            return datasets[name]->getClassName();
@@ -58,7 +48,7 @@ namespace platform {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    int Datasets::getNSamples(const string& name)
+    int Datasets::getNSamples(string name)
    {
        if (datasets[name]->isLoaded()) {
            return datasets[name]->getNSamples();
@@ -66,21 +56,21 @@ namespace platform {
            throw invalid_argument("Dataset not loaded.");
        }
    }
-    pair<vector<vector<float>>&, vector<int>&> Datasets::getVectors(const string& name)
+    pair<vector<vector<float>>&, vector<int>&> Datasets::getVectors(string name)
    {
        if (!datasets[name]->isLoaded()) {
            datasets[name]->load();
        }
        return datasets[name]->getVectors();
    }
-    pair<vector<vector<int>>&, vector<int>&> Datasets::getVectorsDiscretized(const string& name)
+    pair<vector<vector<int>>&, vector<int>&> Datasets::getVectorsDiscretized(string name)
    {
        if (!datasets[name]->isLoaded()) {
            datasets[name]->load();
        }
        return datasets[name]->getVectorsDiscretized();
    }
-    pair<torch::Tensor&, torch::Tensor&> Datasets::getTensors(const string& name)
+    pair<torch::Tensor&, torch::Tensor&> Datasets::getTensors(string name)
    {
        if (!datasets[name]->isLoaded()) {
            datasets[name]->load();
@@ -91,7 +81,9 @@ namespace platform {
    {
        return datasets.find(name) != datasets.end();
    }
-    Dataset::Dataset(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) {}
+    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()
    {
        return name;
@@ -200,7 +192,7 @@ namespace platform {
        // Get className & Features
        className = arff.getClassName();
        auto attributes = arff.getAttributes();
-        transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& f) { return f.first; });
+        transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& attribute) { return attribute.first; });
    }
    void Dataset::load()
    {
@@ -215,9 +207,9 @@ namespace platform {
        if (discretize) {
            Xd = discretizeDataset(Xv, yv);
            computeStates();
-            n_samples = Xd[0].size();
-            n_features = Xd.size();
        }
+        n_samples = Xv[0].size();
+        n_features = Xv.size();
        loaded = true;
    }
    void Dataset::buildTensors()
--- a/src/Platform/Datasets.h
+++ b/src/Platform/Datasets.h
@@ -13,7 +13,7 @@ namespace platform {
        string name;
        fileType_t fileType;
        string className;
-        int n_samples, n_features;
+        int n_samples{ 0 }, n_features{ 0 };
        vector<string> features;
        map<string, vector<int>> states;
        bool loaded;
@@ -27,8 +27,8 @@ namespace platform {
        void load_arff();
        void computeStates();
    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), n_samples(0), n_features(0) {};
-        explicit Dataset(Dataset&);
+        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();
@@ -51,16 +51,15 @@ 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(const string& name);
-        int getNSamples(const string& name);
-        string getClassName(const string& name);
-        map<string, vector<int>> getStates(const string& name);
-        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);
+        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> split(const string&, char);
 };

 #endif
--- a/src/Platform/DotEnv.h
+++ b/src/Platform/DotEnv.h
@@ -4,64 +4,59 @@
 #include <map>
 #include <fstream>
 #include <sstream>
-std::vector<std::string> split(std::string text, char delimiter)
-{
-    std::vector<std::string> result;
-    std::stringstream ss(text);
-    std::string token;
-    while (getline(ss, token, delimiter)) {
-        result.push_back(token);
-    }
-    return result;
+#include "platformUtils.h"
+namespace platform {
+    class DotEnv {
+    private:
+        std::map<std::string, std::string> env;
+        std::string trim(const std::string& str)
+        {
+            std::string result = str;
+            result.erase(result.begin(), std::find_if(result.begin(), result.end(), [](int ch) {
+                return !std::isspace(ch);
+                }));
+            result.erase(std::find_if(result.rbegin(), result.rend(), [](int ch) {
+                return !std::isspace(ch);
+                }).base(), result.end());
+            return result;
+        }
+    public:
+        DotEnv()
+        {
+            std::ifstream file(".env");
+            if (!file.is_open()) {
+                std::cerr << "File .env not found" << std::endl;
+                exit(1);
+            }
+            std::string line;
+            while (std::getline(file, line)) {
+                line = trim(line);
+                if (line.empty() || line[0] == '#') {
+                    continue;
+                }
+                std::istringstream iss(line);
+                std::string key, value;
+                if (std::getline(iss, key, '=') && std::getline(iss, value)) {
+                    env[key] = value;
+                }
+            }
+        }
+        std::string get(const std::string& key)
+        {
+            return env[key];
+        }
+        std::vector<int> getSeeds()
+        {
+            auto seeds = std::vector<int>();
+            auto seeds_str = env["seeds"];
+            seeds_str = trim(seeds_str);
+            seeds_str = seeds_str.substr(1, seeds_str.size() - 2);
+            auto seeds_str_split = split(seeds_str, ',');
+            transform(seeds_str_split.begin(), seeds_str_split.end(), back_inserter(seeds), [](const std::string& str) {
+                return stoi(str);
+                });
+            return seeds;
+        }
+    };
 }
-class DotEnv {
-private:
-    std::map<std::string, std::string> env;
-    std::string trim(const std::string& str)
-    {
-        std::string result = str;
-        result.erase(result.begin(), std::find_if(result.begin(), result.end(), [](int ch) {
-            return !std::isspace(ch);
-            }));
-        result.erase(std::find_if(result.rbegin(), result.rend(), [](int ch) {
-            return !std::isspace(ch);
-            }).base(), result.end());
-        return result;
-    }
-public:
-    DotEnv()
-    {
-        std::ifstream file(".env");
-        if (!file.is_open()) {
-            std::cerr << "File .env not found" << std::endl;
-            exit(1);
-        }
-        std::string line;
-        while (std::getline(file, line)) {
-            line = trim(line);
-            if (line.empty() || line[0] == '#') {
-                continue;
-            }
-            std::istringstream iss(line);
-            std::string key, value;
-            if (std::getline(iss, key, '=') && std::getline(iss, value)) {
-                env[key] = value;
-            }
-        }
-    }
-    std::string get(const std::string& key)
-    {
-        return env[key];
-    }
-    std::vector<int> getSeeds()
-    {
-        auto seeds = std::vector<int>();
-        auto seeds_str = env["seeds"];
-        seeds_str = trim(seeds_str);
-        seeds_str = seeds_str.substr(1, seeds_str.size() - 2);
-        auto seeds_str_split = split(seeds_str, ',');
-        transform(seeds_str_split.begin(), seeds_str_split.end(), back_inserter(seeds), [](const auto& s) { return stoi(s); });
-        return seeds;
-    }
-};
 #endif
--- a/src/Platform/Experiment.cc
+++ b/src/Platform/Experiment.cc
@@ -1,4 +1,7 @@
 #include "Experiment.h"
+#include "Datasets.h"
+#include "Models.h"
+#include "Report.h"

 namespace platform {
    using json = nlohmann::json;
@@ -43,7 +46,7 @@ namespace platform {
        result["discretized"] = discretized;
        result["stratified"] = stratified;
        result["folds"] = nfolds;
-        result["seeds"] = random_seeds;
+        result["seeds"] = randomSeeds;
        result["duration"] = duration;
        result["results"] = json::array();
        for (const auto& r : results) {
@@ -83,10 +86,99 @@ namespace platform {
        file << data;
        file.close();
    }
+
+    void Experiment::report()
+    {
+        json data = build_json();
+        Report report(data);
+        report.show();
+    }
+
    void Experiment::show()
    {
        json data = build_json();
        cout << data.dump(4) << endl;
    }

+    void Experiment::go(vector<string> filesToProcess, const string& path)
+    {
+        cout << "*** Starting experiment: " << title << " ***" << endl;
+        for (auto fileName : filesToProcess) {
+            cout << "- " << setw(20) << left << fileName << " " << right << flush;
+            cross_validation(path, fileName);
+            cout << endl;
+        }
+    }
+
+    void Experiment::cross_validation(const string& path, const string& fileName)
+    {
+        auto datasets = platform::Datasets(path, discretized, platform::ARFF);
+        // Get dataset
+        auto [X, y] = datasets.getTensors(fileName);
+        auto states = datasets.getStates(fileName);
+        auto features = datasets.getFeatures(fileName);
+        auto samples = datasets.getNSamples(fileName);
+        auto className = datasets.getClassName(fileName);
+        cout << " (" << setw(5) << samples << "," << setw(3) << features.size() << ") " << flush;
+        // Prepare Result
+        auto result = Result();
+        auto [values, counts] = at::_unique(y);
+        result.setSamples(X.size(1)).setFeatures(X.size(0)).setClasses(values.size(0));
+        int nResults = nfolds * static_cast<int>(randomSeeds.size());
+        auto accuracy_test = torch::zeros({ nResults }, torch::kFloat64);
+        auto accuracy_train = torch::zeros({ nResults }, torch::kFloat64);
+        auto train_time = torch::zeros({ nResults }, torch::kFloat64);
+        auto test_time = torch::zeros({ nResults }, torch::kFloat64);
+        auto nodes = torch::zeros({ nResults }, torch::kFloat64);
+        auto edges = torch::zeros({ nResults }, torch::kFloat64);
+        auto num_states = torch::zeros({ nResults }, torch::kFloat64);
+        Timer train_timer, test_timer;
+        int item = 0;
+        for (auto seed : randomSeeds) {
+            cout << "(" << seed << ") doing Fold: " << flush;
+            Fold* fold;
+            if (stratified)
+                fold = new StratifiedKFold(nfolds, y, seed);
+            else
+                fold = new KFold(nfolds, y.size(0), seed);
+            for (int nfold = 0; nfold < nfolds; nfold++) {
+                auto clf = Models::instance()->create(model);
+                setModelVersion(clf->getVersion());
+                train_timer.start();
+                auto [train, test] = fold->getFold(nfold);
+                auto train_t = torch::tensor(train);
+                auto test_t = torch::tensor(test);
+                auto X_train = X.index({ "...", train_t });
+                auto y_train = y.index({ train_t });
+                auto X_test = X.index({ "...", test_t });
+                auto y_test = y.index({ test_t });
+                cout << nfold + 1 << ", " << flush;
+                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_timer.start();
+                auto accuracy_test_value = clf->score(X_test, y_test);
+                test_time[item] = test_timer.getDuration();
+                accuracy_train[item] = accuracy_train_value;
+                accuracy_test[item] = accuracy_test_value;
+                // Store results and times in vector
+                result.addScoreTrain(accuracy_train_value);
+                result.addScoreTest(accuracy_test_value);
+                result.addTimeTrain(train_time[item].item<double>());
+                result.addTimeTest(test_time[item].item<double>());
+                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.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
@@ -4,6 +4,11 @@
 #include <nlohmann/json.hpp>
 #include <string>
 #include <chrono>
+#include "Folding.h"
+#include "BaseClassifier.h"
+#include "TAN.h"
+#include "KDB.h"
+#include "AODE.h"

 using namespace std;
 namespace platform {
@@ -24,34 +29,33 @@ namespace platform {
    };
    class Result {
    private:
-        string dataset = "", hyperparameters = "", model_version = "";
+        string dataset, hyperparameters, model_version;
        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;
-        vector<double> scores_train{}, scores_test{}, times_train{}, times_test{};
+        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 };
+        vector<double> scores_train, scores_test, times_train, times_test;
    public:
        Result() = default;
        Result& setDataset(const string& dataset) { this->dataset = dataset; return *this; }
        Result& setHyperparameters(const string& hyperparameters) { this->hyperparameters = hyperparameters; return *this; }
-        Result& setSamples(const int samples) { this->samples = samples; return *this; }
-        Result& setFeatures(const int features) { this->features = features; return *this; }
-        Result& setClasses(const int classes) { this->classes = classes; return *this; }
-        Result& setScoreTrain(const double score) { this->score_train = score; return *this; }
-        Result& setScoreTest(const double score) { this->score_test = score; return *this; }
-        Result& setScoreTrainStd(const double score_std) { this->score_train_std = score_std; return *this; }
-        Result& setScoreTestStd(const double score_std) { this->score_test_std = score_std; return *this; }
-        Result& setTrainTime(const double train_time) { this->train_time = train_time; return *this; }
-        Result& setTrainTimeStd(const double train_time_std) { this->train_time_std = train_time_std; return *this; }
-        Result& setTestTime(const double test_time) { this->test_time = test_time; return *this; }
-        Result& setTestTimeStd(const double test_time_std) { this->test_time_std = test_time_std; return *this; }
-        Result& setNodes(const float nodes) { this->nodes = nodes; return *this; }
-        Result& setLeaves(const float leaves) { this->leaves = leaves; return *this; }
-        Result& setDepth(const float depth) { this->depth = depth; return *this; }
-        Result& setModelVersion(const string& model_version) { this->model_version = model_version; return *this; }
-        Result& addScoreTrain(const double score) { scores_train.push_back(score); return *this; }
-        Result& addScoreTest(const double score) { scores_test.push_back(score); return *this; }
-        Result& addTimeTrain(const double time) { times_train.push_back(time); return *this; }
-        Result& addTimeTest(const double time) { times_test.push_back(time); 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; }
+        Result& setScoreTrain(double score) { this->score_train = score; return *this; }
+        Result& setScoreTest(double score) { this->score_test = score; return *this; }
+        Result& setScoreTrainStd(double score_std) { this->score_train_std = score_std; return *this; }
+        Result& setScoreTestStd(double score_std) { this->score_test_std = score_std; return *this; }
+        Result& setTrainTime(double train_time) { this->train_time = train_time; return *this; }
+        Result& setTrainTimeStd(double train_time_std) { this->train_time_std = train_time_std; return *this; }
+        Result& setTestTime(double test_time) { this->test_time = test_time; return *this; }
+        Result& setTestTimeStd(double test_time_std) { this->test_time_std = test_time_std; return *this; }
+        Result& setNodes(float nodes) { this->nodes = nodes; return *this; }
+        Result& setLeaves(float leaves) { this->leaves = leaves; return *this; }
+        Result& setDepth(float depth) { this->depth = depth; return *this; }
+        Result& addScoreTrain(double score) { scores_train.push_back(score); return *this; }
+        Result& addScoreTest(double score) { scores_test.push_back(score); return *this; }
+        Result& addTimeTrain(double time) { times_train.push_back(time); return *this; }
+        Result& addTimeTest(double time) { times_test.push_back(time); return *this; }
        const float get_score_train() const { return score_train; }
        float get_score_test() { return score_test; }
        const string& getDataset() const { return dataset; }
@@ -74,16 +78,15 @@ namespace platform {
        const vector<double>& getScoresTest() const { return scores_test; }
        const vector<double>& getTimesTrain() const { return times_train; }
        const vector<double>& getTimesTest() const { return times_test; }
-        const string& getModelVersion() const { return model_version; }
    };
    class Experiment {
    private:
-        string title{""}, model{""}, platform{""}, score_name{""}, model_version{""}, language_version{""}, language{""};
-        bool discretized{false}, stratified{false};
+        string title, model, platform, score_name, model_version, language_version, language;
+        bool discretized{ false }, stratified{ false };
        vector<Result> results;
-        vector<int> random_seeds;
-        int nfolds{0};
-        float duration{0};
+        vector<int> randomSeeds;
+        int nfolds{ 0 };
+        float duration{ 0 };
        json build_json();
    public:
        Experiment() = default;
@@ -94,15 +97,18 @@ namespace platform {
        Experiment& setModelVersion(const string& model_version) { this->model_version = model_version; return *this; }
        Experiment& setLanguage(const string& language) { this->language = language; return *this; }
        Experiment& setLanguageVersion(const string& language_version) { this->language_version = language_version; return *this; }
-        Experiment& setDiscretized(const bool discretized) { this->discretized = discretized; return *this; }
-        Experiment& setStratified(const bool stratified) { this->stratified = stratified; return *this; }
-        Experiment& setNFolds(const int nfolds) { this->nfolds = nfolds; return *this; }
+        Experiment& setDiscretized(bool discretized) { this->discretized = discretized; return *this; }
+        Experiment& setStratified(bool stratified) { this->stratified = stratified; return *this; }
+        Experiment& setNFolds(int nfolds) { this->nfolds = nfolds; return *this; }
        Experiment& addResult(Result result) { results.push_back(result); return *this; }
-        Experiment& addRandomSeed(const int random_seed) { random_seeds.push_back(random_seed); return *this; }
-        Experiment& setDuration(const float duration) { this->duration = duration; return *this; }
+        Experiment& addRandomSeed(int randomSeed) { randomSeeds.push_back(randomSeed); return *this; }
+        Experiment& setDuration(float duration) { this->duration = duration; return *this; }
        string get_file_name();
        void save(const string& path);
+        void cross_validation(const string& path, const string& fileName);
+        void go(vector<string> filesToProcess, const string& path);
        void show();
+        void report();
    };
 }
 #endif
--- a/src/Platform/Folding.cc
+++ b/src/Platform/Folding.cc
@@ -7,7 +7,7 @@ Fold::Fold(int k, int n, int seed) : k(k), n(n), seed(seed)
    random_seed = default_random_engine(seed == -1 ? rd() : seed);
    srand(seed == -1 ? time(0) : seed);
 }
-KFold::KFold(int k, int n, int seed) : Fold(k, n, seed), indices(vector<int>())
+KFold::KFold(int k, int n, int seed) : Fold(k, n, seed), indices(vector<int>(n))
 {
    iota(begin(indices), end(indices), 0); // fill with 0, 1, ..., n - 1
    shuffle(indices.begin(), indices.end(), random_seed);
--- a/src/Platform/Models.cc
+++ b/src/Platform/Models.cc
@@ -1,8 +1,54 @@
 #include "Models.h"
 namespace platform {
    using namespace std;
-    map<string, bayesnet::BaseClassifier*> Models::classifiers = map<string, bayesnet::BaseClassifier*>({
-        { "AODE", new bayesnet::AODE() }, { "KDB", new bayesnet::KDB(2) },
-        { "SPODE",  new bayesnet::SPODE(2) }, { "TAN",  new bayesnet::TAN() }
-        });
-}
+    // Idea from: https://www.codeproject.com/Articles/567242/AplusC-2b-2bplusObjectplusFactory
+    Models* Models::factory = nullptr;;
+    Models* Models::instance()
+    {
+        //manages singleton
+        if (factory == nullptr)
+            factory = new Models();
+        return factory;
+    }
+    void Models::registerFactoryFunction(const string& name,
+        function<bayesnet::BaseClassifier* (void)> classFactoryFunction)
+    {
+        // register the class factory function
+        functionRegistry[name] = classFactoryFunction;
+    }
+    shared_ptr<bayesnet::BaseClassifier> Models::create(const string& name)
+    {
+        bayesnet::BaseClassifier* instance = nullptr;
+
+        // find name in the registry and call factory method.
+        auto it = functionRegistry.find(name);
+        if (it != functionRegistry.end())
+            instance = it->second();
+        // wrap instance in a shared ptr and return
+        if (instance != nullptr)
+            return shared_ptr<bayesnet::BaseClassifier>(instance);
+        else
+            return nullptr;
+    }
+    vector<string> Models::getNames()
+    {
+        vector<string> names;
+        transform(functionRegistry.begin(), functionRegistry.end(), back_inserter(names),
+            [](const pair<string, function<bayesnet::BaseClassifier* (void)>>& pair) { return pair.first; });
+        return names;
+    }
+    string Models::toString()
+    {
+        string result = "";
+        for (const auto& pair : functionRegistry) {
+            result += pair.first + ", ";
+        }
+        return "{" + result.substr(0, result.size() - 2) + "}";
+    }
+
+    Registrar::Registrar(const string& name, function<bayesnet::BaseClassifier* (void)> classFactoryFunction)
+    {
+        // register the class factory function 
+        Models::instance()->registerFactoryFunction(name, classFactoryFunction);
+    }
+}
--- a/src/Platform/Models.h
+++ b/src/Platform/Models.h
@@ -6,28 +6,31 @@
 #include "TAN.h"
 #include "KDB.h"
 #include "SPODE.h"
+#include "TANLd.h"
+#include "KDBLd.h"
+#include "SPODELd.h"
+#include "AODELd.h"
 namespace platform {
    class Models {
    private:
-        static map<string, bayesnet::BaseClassifier*> classifiers;
+        map<string, function<bayesnet::BaseClassifier* (void)>> functionRegistry;
+        static Models* factory; //singleton
+        Models() {};
    public:
-        static bayesnet::BaseClassifier* get(string name) { return classifiers[name]; }
-        static vector<string> getNames()
-        {
-            vector<string> names;
-            for (auto& [name, classifier] : classifiers) {
-                names.push_back(name);
-            }
-            return names;
-        }
-        static string toString()
-        {
-            string names = "";
-            for (auto& [name, classifier] : classifiers) {
-                names += name + ", ";
-            }
-            return "{" + names.substr(0, names.size() - 2) + "}";
-        }
+        Models(Models&) = delete;
+        void operator=(const Models&) = delete;
+        // Idea from: https://www.codeproject.com/Articles/567242/AplusC-2b-2bplusObjectplusFactory
+        static Models* instance();
+        shared_ptr<bayesnet::BaseClassifier> create(const string& name);
+        void registerFactoryFunction(const string& name,
+            function<bayesnet::BaseClassifier* (void)> classFactoryFunction);
+        vector<string> getNames();
+        string toString();
+
+    };
+    class Registrar {
+    public:
+        Registrar(const string& className, function<bayesnet::BaseClassifier* (void)> classFactoryFunction);
    };
 }
 #endif
--- a/src/Platform/Report.cc
+++ b/src/Platform/Report.cc
@@ -0,0 +1,67 @@
+#include "Report.h"
+
+namespace platform {
+    string headerLine(const string& text)
+    {
+        int n = MAXL - text.length() - 3;
+        n = n < 0 ? 0 : n;
+        return "* " + text + string(n, ' ') + "*\n";
+    }
+    string Report::fromVector(const string& key)
+    {
+        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();
+    }
+    void Report::header()
+    {
+        cout << 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>());
+        cout << headerLine("Score is " + data["score_name"].get<string>());
+        cout << string(MAXL, '*') << endl;
+        cout << endl;
+    }
+    void Report::body()
+    {
+        cout << "Dataset                        Sampl. Feat. Cls Nodes   Edges   States  Score           Time              Hyperparameters" << endl;
+        cout << "============================== ====== ===== === ======= ======= ======= =============== ================= ===============" << endl;
+        for (const auto& r : data["results"]) {
+            cout << setw(30) << left << r["dataset"].get<string>() << " ";
+            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(8) << right << setprecision(6) << fixed << r["score_test"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["score_test_std"].get<double>() << " ";
+            cout << setw(10) << right << setprecision(6) << fixed << r["test_time"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["test_time_std"].get<double>() << " ";
+            cout << " " << r["hyperparameters"].get<string>();
+            cout << endl;
+            cout << string(MAXL, '*') << endl;
+            cout << headerLine("Train scores: " + fVector(r["scores_train"]));
+            cout << headerLine("Test  scores: " + fVector(r["scores_test"]));
+            cout << headerLine("Train  times: " + fVector(r["times_train"]));
+            cout << headerLine("Test   times: " + fVector(r["times_test"]));
+            cout << string(MAXL, '*') << endl;
+        }
+    }
+}
--- a/src/Platform/Report.h
+++ b/src/Platform/Report.h
@@ -0,0 +1,23 @@
+#ifndef REPORT_H
+#define REPORT_H
+#include <string>
+#include <iostream>
+#include <nlohmann/json.hpp>
+
+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();
+        string fromVector(const string& key);
+        json data;
+    };
+};
+#endif
--- a/src/Platform/main.cc
+++ b/src/Platform/main.cc
@@ -4,9 +4,8 @@
 #include "Experiment.h"
 #include "Datasets.h"
 #include "DotEnv.h"
-#include "CrossValidation.h"
 #include "Models.h"
-
+#include "modelRegister.h"

 using namespace std;
 const string PATH_RESULTS = "results";
@@ -14,7 +13,7 @@ const string PATH_DATASETS = "datasets";

 argparse::ArgumentParser manageArguments(int argc, char** argv)
 {
-    auto env = DotEnv();
+    auto env = platform::DotEnv();
    argparse::ArgumentParser program("BayesNetSample");
    program.add_argument("-d", "--dataset").default_value("").help("Dataset file name");
    program.add_argument("-p", "--path")
@@ -22,13 +21,13 @@ argparse::ArgumentParser manageArguments(int argc, char** argv)
        .default_value(string{ PATH_DATASETS }
    );
    program.add_argument("-m", "--model")
-        .help("Model to use " + platform::Models::toString())
+        .help("Model to use " + platform::Models::instance()->toString())
        .action([](const std::string& value) {
-        static const vector<string> choices = platform::Models::getNames();
+        static const vector<string> choices = platform::Models::instance()->getNames();
        if (find(choices.begin(), choices.end(), value) != choices.end()) {
            return value;
        }
-        throw runtime_error("Model must be one of " + platform::Models::toString());
+        throw runtime_error("Model must be one of " + platform::Models::instance()->toString());
            }
    );
    program.add_argument("--title").default_value("").help("Experiment title");
@@ -84,7 +83,7 @@ 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");
-    vector<string> filesToProcess;
+    vector<string> filesToTest;
    auto datasets = platform::Datasets(path, true, platform::ARFF);
    auto title = program.get<string>("title");
    if (file_name != "") {
@@ -95,42 +94,30 @@ int main(int argc, char** argv)
        if (title == "") {
            title = "Test " + file_name + " " + model_name + " " + to_string(n_folds) + " folds";
        }
-        filesToProcess.push_back(file_name);
+        filesToTest.push_back(file_name);
    } else {
-        filesToProcess = platform::Datasets(path, true, platform::ARFF).getNames();
-        saveResults = true; // Only save results if all datasets are processed
+        filesToTest = platform::Datasets(path, true, platform::ARFF).getNames();
+        saveResults = true;
    }
-
    /*
    * Begin Processing
    */
+    auto env = platform::DotEnv();
    auto experiment = platform::Experiment();
    experiment.setTitle(title).setLanguage("cpp").setLanguageVersion("1.0.0");
-    experiment.setDiscretized(discretize_dataset).setModel(model_name).setPlatform("BayesNet");
+    experiment.setDiscretized(discretize_dataset).setModel(model_name).setPlatform(env.get("platform"));
    experiment.setStratified(stratified).setNFolds(n_folds).setScoreName("accuracy");
    for (auto seed : seeds) {
        experiment.addRandomSeed(seed);
    }
    platform::Timer timer;
-    cout << "*** Starting experiment: " << title << " ***" << endl;
    timer.start();
-    auto validation = platform::CrossValidation(model_name, stratified, n_folds, seeds, datasets);
-    for (auto fileName : filesToProcess) {
-        cout << "- " << setw(20) << left << fileName << " " << right << flush;
-        auto [X, y] = datasets.getTensors(fileName);
-        auto features = datasets.getFeatures(fileName);
-        auto samples = datasets.getNSamples(fileName);
-        cout << " (" << setw(5) << samples << "," << setw(3) << features.size() << ") " << flush;
-        auto result = validation.crossValidate(fileName);
-        result.setDataset(fileName);
-        experiment.setModelVersion(result.getModelVersion());
-        experiment.addResult(result);
-    }
+    experiment.go(filesToTest, path);
    experiment.setDuration(timer.getDuration());
    if (saveResults)
        experiment.save(PATH_RESULTS);
    else
-        experiment.show();
+        experiment.report();
    cout << "Done!" << endl;
    return 0;
 }
--- a/src/Platform/modelRegister.h
+++ b/src/Platform/modelRegister.h
@@ -0,0 +1,19 @@
+#ifndef MODEL_REGISTER_H
+#define MODEL_REGISTER_H
+static platform::Registrar registrarT("TAN",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::TAN();});
+static platform::Registrar registrarTLD("TANLd",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::TANLd();});
+static platform::Registrar registrarS("SPODE",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::SPODE(2);});
+static platform::Registrar registrarSLD("SPODELd",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::SPODELd(2);});
+static platform::Registrar registrarK("KDB",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::KDB(2);});
+static platform::Registrar registrarKLD("KDBLd",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::KDBLd(2);});
+static platform::Registrar registrarA("AODE",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::AODE();});
+static platform::Registrar registrarALD("AODELd",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::AODELd();});
+#endif
--- a/src/Platform/platformUtils.cc
+++ b/src/Platform/platformUtils.cc
@@ -2,6 +2,17 @@

 using namespace torch;

+vector<string> split(const string& text, char delimiter)
+{
+    vector<string> result;
+    stringstream ss(text);
+    string token;
+    while (getline(ss, token, delimiter)) {
+        result.push_back(token);
+    }
+    return result;
+}
+
 pair<vector<mdlp::labels_t>, map<string, int>> discretize(vector<mdlp::samples_t>& X, mdlp::labels_t& y, vector<string> features)
 {
    vector<mdlp::labels_t> Xd;
@@ -28,7 +39,7 @@ vector<mdlp::labels_t> discretizeDataset(vector<mdlp::samples_t>& X, mdlp::label
    return Xd;
 }

-bool file_exists(const std::string& name)
+bool file_exists(const string& name)
 {
    if (FILE* file = fopen(name.c_str(), "r")) {
        fclose(file);
@@ -49,7 +60,7 @@ tuple<Tensor, Tensor, vector<string>, string, map<string, vector<int>>> loadData
    auto className = handler.getClassName();
    vector<string> features;
    auto attributes = handler.getAttributes();
-    transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& f) { return f.first; });
+    transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& pair) { return pair.first; });
    Tensor Xd;
    auto states = map<string, vector<int>>();
    if (discretize_dataset) {
@@ -82,7 +93,7 @@ tuple<vector<vector<int>>, vector<int>, vector<string>, string, map<string, vect
    auto className = handler.getClassName();
    vector<string> features;
    auto attributes = handler.getAttributes();
-    transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& f) { return f.first; });
+    transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& pair) { return pair.first; });
    // Discretize Dataset
    vector<mdlp::labels_t> Xd;
    map<string, int> maxes;
--- a/src/Platform/platformUtils.h
+++ b/src/Platform/platformUtils.h
@@ -11,9 +11,10 @@ using namespace std;
 const string PATH = "../../data/";

 bool file_exists(const std::string& name);
+vector<string> split(const string& text, char delimiter);
 pair<vector<mdlp::labels_t>, map<string, int>> discretize(vector<mdlp::samples_t>& X, mdlp::labels_t& y, vector<string> features);
 vector<mdlp::labels_t> discretizeDataset(vector<mdlp::samples_t>& X, mdlp::labels_t& y);
-// pair<torch::Tensor, map<string, vector<int>>> discretizeTorch(torch::Tensor& X, torch::Tensor& y, vector<string>& features, const string& className);
+pair<torch::Tensor, map<string, vector<int>>> discretizeTorch(torch::Tensor& X, torch::Tensor& y, vector<string>& features, const string& className);
 tuple<vector<vector<int>>, vector<int>, vector<string>, string, map<string, vector<int>>> loadFile(const string& name);
 tuple<torch::Tensor, torch::Tensor, vector<string>, string, map<string, vector<int>>> loadDataset(const string& path, const string& name, bool class_last, bool discretize_dataset);
 map<string, vector<int>> get_states(vector<string>& features, string className, map<string, int>& maxes);
--- a/tests/BayesNetwork.cc
+++ b/tests/BayesNetwork.cc
@@ -9,29 +9,21 @@ TEST_CASE("Test Bayesian Network")
 {
    auto [Xd, y, features, className, states] = loadFile("iris");

-    SECTION("Test Update Nodes")
-    {
-        auto net = bayesnet::Network();
-        net.addNode("A", 3);
-        REQUIRE(net.getStates() == 3);
-        net.addNode("A", 5);
-        REQUIRE(net.getStates() == 5);
-    }
    SECTION("Test get features")
    {
        auto net = bayesnet::Network();
-        net.addNode("A", 3);
-        net.addNode("B", 5);
+        net.addNode("A");
+        net.addNode("B");
        REQUIRE(net.getFeatures() == vector<string>{"A", "B"});
-        net.addNode("C", 2);
+        net.addNode("C");
        REQUIRE(net.getFeatures() == vector<string>{"A", "B", "C"});
    }
    SECTION("Test get edges")
    {
        auto net = bayesnet::Network();
-        net.addNode("A", 3);
-        net.addNode("B", 5);
-        net.addNode("C", 2);
+        net.addNode("A");
+        net.addNode("B");
+        net.addNode("C");
        net.addEdge("A", "B");
        net.addEdge("B", "C");
        REQUIRE(net.getEdges() == vector<pair<string, string>>{ {"A", "B"}, { "B", "C" } });
Author	SHA1	Message	Date
Ricardo Montañana	182b52a887	Add states as result in Proposal methods	2023-08-12 16:16:17 +02:00
Ricardo Montañana	405887f833	Solved Ld poor results	2023-08-12 11:49:18 +02:00
Ricardo Montañana	3a85481a5a	Redo pass states to Network Fit needed in crossval fix mistake in headerline (report)	2023-08-12 11:10:53 +02:00
Ricardo Montañana	0ad5505c16	Spodeld working with poor accuracy	2023-08-10 02:06:18 +02:00
Ricardo Montañana	323444b74a	const functions	2023-08-08 01:53:41 +02:00
Ricardo Montañana	ef1bffcac3	Fixed normal classifiers	2023-08-07 13:50:11 +02:00
Ricardo Montañana	06db8f51ce	Refactor library and models to lighten data stored Refactro Ensemble to inherit from Classifier insted of BaseClassifier	2023-08-07 12:49:37 +02:00
Ricardo Montañana	e74565ba01	update clang-tidy	2023-08-07 00:44:12 +02:00
Ricardo Montañana	2da0fb5d8f	Merge branch 'main' into TANNew	2023-08-06 11:40:10 +02:00
Ricardo Montañana	14ea51648a	Complete AODELd	2023-08-06 11:31:44 +02:00
Ricardo Montañana	9e94f4e140	Rename suffix of proposal classifier to Ld	2023-08-05 23:23:31 +02:00
Ricardo Montañana	1d0fd629c9	Add SPODENew to models	2023-08-05 23:11:36 +02:00
Ricardo Montañana	506ef34c6f	Add report output to main	2023-08-05 20:29:05 +02:00
Ricardo Montañana	7f45495837	Refactor New classifiers to extract predict	2023-08-05 18:39:48 +02:00
Ricardo Montañana	1a09ccca4c	Add KDBNew fix computeCPT error	2023-08-05 14:40:42 +02:00
Ricardo Montañana	a1c6ab18f3	TANNew restructured with poor results	2023-08-04 20:11:22 +02:00
Ricardo Montañana	64ac8fb4f2	TANNew as a TAN variant working	2023-08-04 19:42:18 +02:00
Ricardo Montañana	c568ba111d	Add Proposal class	2023-08-04 13:05:12 +02:00
Ricardo Montañana	45c1d052ac	Compile TANNew with poor accuracy	2023-08-04 01:35:45 +02:00
Ricardo Montañana	eb1cec58a3	Complete nxm	2023-08-03 20:22:33 +02:00
Ricardo Montañana	f520b40016	Almost complete proposal in TANNew	2023-08-02 02:21:55 +02:00
Ricardo Montañana	cdfb45d2cb	Add topological order to Network	2023-08-02 00:56:52 +02:00
Ricardo Montañana	f63a9a64f9	Update Makefile to add Release & Debug build	2023-08-01 19:02:37 +02:00
Ricardo Montañana	285f0938a6	Update mdlp library	2023-08-01 17:33:01 +02:00
Ricardo Montañana	8f8f9773ce	Make TANNew same as TAN with local discretization	2023-08-01 13:17:12 +02:00
Ricardo Montañana	a9ba21560d	Add environment platform to experiment result	2023-08-01 10:55:53 +02:00
Ricardo Montañana	a18fbe5594	Begin implementation	2023-07-31 19:53:55 +02:00
Ricardo Montañana	adf650d257	Max threading	2023-07-31 18:49:18 +02:00
Ricardo Montañana	43bb017d5d	Fix problem with tensors way	2023-07-30 19:00:02 +02:00
Ricardo Montañana	53697648e7	Merge branch 'aftermath' into main	2023-07-30 01:05:31 +02:00
Ricardo Montañana	4ebc9c2013	Complete fixing the linter warnings	2023-07-30 00:16:58 +02:00
Ricardo Montañana	b882569169	Fix some more lint warnings	2023-07-30 00:04:18 +02:00
Ricardo Montañana	8b2ed26ab7	Fix some lint warnings	2023-07-29 20:37:51 +02:00
Ricardo Montañana	5efa3beaee	Fix some lint warnings	2023-07-29 20:20:38 +02:00
Ricardo Montañana	9a0449c12d	Fix some lint warnings	2023-07-29 19:38:42 +02:00
Ricardo Montañana	7222119dfb	Refactor experiment crossvalidation	2023-07-29 19:00:39 +02:00
Ricardo Montañana	cb54f61a69	Refactor Models to be a singleton factory Add Registrar of models	2023-07-29 18:22:15 +02:00
Ricardo Montañana	07d572a98c	Add Model factory	2023-07-29 17:27:43 +02:00
Ricardo Montañana	c4f3e6f19a	Refactor crossvalidation to remove unneeded params	2023-07-29 16:49:06 +02:00
Ricardo Montañana	adc0ca238f	Refactor cross_validation	2023-07-29 16:44:07 +02:00
Ricardo Montañana	b9e76becce	Add show experiment	2023-07-29 16:31:36 +02:00
Ricardo Montañana	85cb447283	Add Dataset, Models and DotEnv	2023-07-29 16:21:38 +02:00