Add openmpi instructions for Oracle Linux

Fix format of duration
Fix duration of task not set
2023-12-17 12:19:50 +01:00 · 2023-12-17 01:45:04 +01:00 · 2023-12-16 19:31:45 +01:00 · 2023-12-16 12:53:25 +01:00 · 2023-12-15 18:09:17 +01:00 · 2023-12-15 01:54:13 +01:00
141 changed files with 5057 additions and 2063 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -32,8 +32,7 @@
 *.out
 *.app
 build/**
-build_debug/**
-build_release/**
+build_*/**
 *.dSYM/**
 cmake-build*/**
 .idea
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,15 +1,25 @@
 [submodule "lib/mdlp"]
 	path = lib/mdlp
 	url = https://github.com/rmontanana/mdlp
+	main = main
+	update = merge
 [submodule "lib/catch2"]
 	path = lib/catch2
+        main  = v2.x
+	update = merge
 	url = https://github.com/catchorg/Catch2.git
 [submodule "lib/argparse"]
 	path = lib/argparse
 	url = https://github.com/p-ranav/argparse
+	master = master
+	update = merge
 [submodule "lib/json"]
 	path = lib/json
 	url = https://github.com/nlohmann/json.git
+        master = master
+	update = merge
 [submodule "lib/libxlsxwriter"]
 	path = lib/libxlsxwriter
 	url = https://github.com/jmcnamara/libxlsxwriter.git
+        main = main
+	update = merge
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -5,7 +5,7 @@
            "type": "lldb",
            "request": "launch",
            "name": "sample",
-            "program": "${workspaceFolder}/build/sample/BayesNetSample",
+            "program": "${workspaceFolder}/build_debug/sample/BayesNetSample",
            "args": [
                "-d",
                "iris",
@@ -21,25 +21,58 @@
        {
            "type": "lldb",
            "request": "launch",
-            "name": "experiment",
-            "program": "${workspaceFolder}/build/src/Platform/b_main",
+            "name": "experimentPy",
+            "program": "${workspaceFolder}/build_debug/src/Platform/b_main",
+            "args": [
+                "-m",
+                "STree",
+                "--stratified",
+                "-d",
+                "iris",
+                //"--discretize"
+                // "--hyperparameters",
+                // "{\"repeatSparent\": true, \"maxModels\": 12}"
+            ],
+            "cwd": "${workspaceFolder}/../discretizbench",
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "gridsearch",
+            "program": "${workspaceFolder}/build_debug/src/Platform/b_grid",
+            "args": [
+                "-m",
+                "KDB",
+                "--discretize",
+                "--continue",
+                "glass",
+                "--only",
+                "--compute"
+            ],
+            "cwd": "${workspaceFolder}/../discretizbench",
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "experimentBayes",
+            "program": "${workspaceFolder}/build_debug/src/Platform/b_main",
            "args": [
                "-m",
                "TAN",
                "--stratified",
+                "--discretize",
                "-d",
-                "zoo",
-                "--discretize"
-                // "--hyperparameters",
-                // "{\"repeatSparent\": true, \"maxModels\": 12}"
+                "iris",
+                "--hyperparameters",
+                "{\"repeatSparent\": true, \"maxModels\": 12}"
            ],
-            "cwd": "/Users/rmontanana/Code/odtebench",
+            "cwd": "/home/rmontanana/Code/discretizbench",
        },
        {
            "type": "lldb",
            "request": "launch",
            "name": "best",
-            "program": "${workspaceFolder}/build/src/Platform/b_best",
+            "program": "${workspaceFolder}/build_debug/src/Platform/b_best",
            "args": [
                "-m",
                "BoostAODE",
@@ -47,33 +80,33 @@
                "accuracy",
                "--build",
            ],
-            "cwd": "/Users/rmontanana/Code/discretizbench",
+            "cwd": "${workspaceFolder}/../discretizbench",
        },
        {
            "type": "lldb",
            "request": "launch",
            "name": "manage",
-            "program": "${workspaceFolder}/build/src/Platform/b_manage",
+            "program": "${workspaceFolder}/build_debug/src/Platform/b_manage",
            "args": [
                "-n",
                "20"
            ],
-            "cwd": "/Users/rmontanana/Code/discretizbench",
+            "cwd": "${workspaceFolder}/../discretizbench",
        },
        {
            "type": "lldb",
            "request": "launch",
            "name": "list",
-            "program": "${workspaceFolder}/build/src/Platform/b_list",
+            "program": "${workspaceFolder}/build_debug/src/Platform/b_list",
            "args": [],
            //"cwd": "/Users/rmontanana/Code/discretizbench",
-            "cwd": "/home/rmontanana/Code/covbench",
+            "cwd": "${workspaceFolder}/../discretizbench",
        },
        {
            "type": "lldb",
            "request": "launch",
            "name": "test",
-            "program": "${workspaceFolder}/build/tests/unit_tests",
+            "program": "${workspaceFolder}/build_debug/tests/unit_tests",
            "args": [
                "-c=\"Metrics Test\"",
                // "-s",
@@ -84,7 +117,7 @@
            "name": "Build & debug active file",
            "type": "cppdbg",
            "request": "launch",
-            "program": "${workspaceFolder}/build/bayesnet",
+            "program": "${workspaceFolder}/build_debug/bayesnet",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,28 +24,39 @@ set(CMAKE_CXX_STANDARD_REQUIRED            ON)
 set(CMAKE_CXX_EXTENSIONS                  OFF)
 set(CMAKE_EXPORT_COMPILE_COMMANDS          ON)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")
-
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
 # Options
 # -------
 option(ENABLE_CLANG_TIDY "Enable to add clang tidy."              OFF)
 option(ENABLE_TESTING "Unit testing build"                        OFF)
 option(CODE_COVERAGE "Collect coverage from test library"         OFF)
+option(MPI_ENABLED "Enable MPI options"                           ON)
+
+if (MPI_ENABLED)
+  find_package(MPI REQUIRED)
+  message("MPI_CXX_LIBRARIES=${MPI_CXX_LIBRARIES}")
+  message("MPI_CXX_INCLUDE_DIRS=${MPI_CXX_INCLUDE_DIRS}")
+endif (MPI_ENABLED)

 # Boost Library
 set(Boost_USE_STATIC_LIBS OFF) 
 set(Boost_USE_MULTITHREADED ON)  
 set(Boost_USE_STATIC_RUNTIME OFF) 
-find_package(Boost 1.66.0 REQUIRED) 
+find_package(Boost 1.66.0 REQUIRED COMPONENTS python3 numpy3) 
 if(Boost_FOUND)
    message("Boost_INCLUDE_DIRS=${Boost_INCLUDE_DIRS}")
    include_directories(${Boost_INCLUDE_DIRS}) 
 endif()

-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+# Python
+find_package(Python3 3.11...3.11.9 COMPONENTS Interpreter Development REQUIRED)
+message("Python3_LIBRARIES=${Python3_LIBRARIES}")
+
 # CMakes modules
 # --------------
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 include(AddGitSubmodule)
+
 if (CODE_COVERAGE)
    enable_testing()
    include(CodeCoverage)
@@ -76,6 +87,7 @@ add_subdirectory(config)
 add_subdirectory(lib/Files)
 add_subdirectory(src/BayesNet)
 add_subdirectory(src/Platform)
+add_subdirectory(src/PyClassifiers)
 add_subdirectory(sample)

 file(GLOB BayesNet_HEADERS CONFIGURE_DEPENDS ${BayesNet_SOURCE_DIR}/src/BayesNet/*.h ${BayesNet_SOURCE_DIR}/BayesNet/*.h)
--- a/16
+++ b/16
@@ -4,7 +4,7 @@ SHELL := /bin/bash

 f_release = build_release
 f_debug = build_debug
-app_targets = b_best b_list b_main b_manage
+app_targets = b_best b_list b_main b_manage b_grid
 test_targets = unit_tests_bayesnet unit_tests_platform
 n_procs = -j 16

@@ -35,11 +35,13 @@ dest ?= ${HOME}/bin
 install: ## Copy binary files to bin folder
 	@echo "Destination folder: $(dest)"
 	make buildr
+	@echo "*******************************************"
 	@echo ">>> Copying files to $(dest)"
-	@cp $(f_release)/src/Platform/b_main $(dest)
-	@cp $(f_release)/src/Platform/b_list $(dest)
-	@cp $(f_release)/src/Platform/b_manage $(dest)
-	@cp $(f_release)/src/Platform/b_best $(dest)
+	@echo "*******************************************"
+	@for item in $(app_targets); do \
+		echo ">>> Copying $$item" ; \
+		cp $(f_release)/src/Platform/$$item $(dest) ; \
+	done

 dependency: ## Create a dependency graph diagram of the project (build/dependency.png)
 	@echo ">>> Creating dependency graph diagram of the project...";
@@ -47,10 +49,10 @@ dependency: ## Create a dependency graph diagram of the project (build/dependenc
 	cd $(f_debug) && cmake .. --graphviz=dependency.dot && dot -Tpng dependency.dot -o dependency.png

 buildd: ## Build the debug targets
-	cmake --build $(f_debug) -t $(app_targets) $(n_procs)
+	cmake --build $(f_debug) -t $(app_targets) BayesNetSample $(n_procs)

 buildr: ## Build the release targets
-	cmake --build $(f_release) -t $(app_targets) $(n_procs)
+	cmake --build $(f_release) -t $(app_targets) BayesNetSample $(n_procs)

 clean: ## Clean the tests info
 	@echo ">>> Cleaning Debug BayesNet tests...";
--- a/README.md
+++ b/README.md
@@ -1,11 +1,27 @@
 # BayesNet

+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 Bayesian Network Classifier with libtorch from scratch

 ## 0. Setup

 Before compiling BayesNet.

+### MPI
+
+In Linux just install openmpi & openmpi-devel packages. Only cmake can't find openmpi install (like in Oracle Linux) set the following variable:
+
+```bash
+export MPI_HOME="/usr/lib64/openmpi"
+```
+
+In Mac OS X, install mpich with brew and if cmake doesn't find it, edit mpicxx wrapper to remove the ",-commons,use_dylibs" from final_ldflags
+
+```bash
+vi /opt/homebrew/bin/mpicx
+```
+
 ### boost library

 [Getting Started](<https://www.boost.org/doc/libs/1_83_0/more/getting_started/index.html>)
@@ -16,12 +32,24 @@ The best option is install the packages that the Linux distribution have in its
 sudo dnf install boost-devel
 ```

-If this is not possible and the compressed packaged is installed, the following environment variable has to be set:
+If this is not possible and the compressed packaged is installed, the following environment variable has to be set pointing to the folder where it was unzipped to:

 ```bash
 export BOOST_ROOT=/path/to/library/
 ```

+In some cases, it is needed to build the library, to do so:
+
+```bash
+cd /path/to/library
+mkdir own
+./bootstrap.sh --prefix=/path/to/library/own
+./b2 install
+export BOOST_ROOT=/path/to/library/own/
+```
+
+Don't forget to add the export BOOST_ROOT statement to .bashrc or wherever it is meant to be.
+
 ### libxlswriter

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

-using namespace std;
-
 ArffFiles::ArffFiles() = default;

-vector<string> ArffFiles::getLines() const
+std::vector<std::string> ArffFiles::getLines() const
 {
    return lines;
 }
@@ -18,48 +16,48 @@ unsigned long int ArffFiles::getSize() const
    return lines.size();
 }

-vector<pair<string, string>> ArffFiles::getAttributes() const
+std::vector<std::pair<std::string, std::string>> ArffFiles::getAttributes() const
 {
    return attributes;
 }

-string ArffFiles::getClassName() const
+std::string ArffFiles::getClassName() const
 {
    return className;
 }

-string ArffFiles::getClassType() const
+std::string ArffFiles::getClassType() const
 {
    return classType;
 }

-vector<vector<float>>& ArffFiles::getX()
+std::vector<std::vector<float>>& ArffFiles::getX()
 {
    return X;
 }

-vector<int>& ArffFiles::getY()
+std::vector<int>& ArffFiles::getY()
 {
    return y;
 }

-void ArffFiles::loadCommon(string fileName)
+void ArffFiles::loadCommon(std::string fileName)
 {
-    ifstream file(fileName);
+    std::ifstream file(fileName);
    if (!file.is_open()) {
-        throw invalid_argument("Unable to open file");
+        throw std::invalid_argument("Unable to open file");
    }
-    string line;
-    string keyword;
-    string attribute;
-    string type;
-    string type_w;
+    std::string line;
+    std::string keyword;
+    std::string attribute;
+    std::string type;
+    std::string type_w;
    while (getline(file, line)) {
        if (line.empty() || line[0] == '%' || line == "\r" || line == " ") {
            continue;
        }
-        if (line.find("@attribute") != string::npos || line.find("@ATTRIBUTE") != string::npos) {
-            stringstream ss(line);
+        if (line.find("@attribute") != std::string::npos || line.find("@ATTRIBUTE") != std::string::npos) {
+            std::stringstream ss(line);
            ss >> keyword >> attribute;
            type = "";
            while (ss >> type_w)
@@ -74,35 +72,35 @@ void ArffFiles::loadCommon(string fileName)
    }
    file.close();
    if (attributes.empty())
-        throw invalid_argument("No attributes found");
+        throw std::invalid_argument("No attributes found");
 }

-void ArffFiles::load(const string& fileName, bool classLast)
+void ArffFiles::load(const std::string& fileName, bool classLast)
 {
    int labelIndex;
    loadCommon(fileName);
    if (classLast) {
-        className = get<0>(attributes.back());
-        classType = get<1>(attributes.back());
+        className = std::get<0>(attributes.back());
+        classType = std::get<1>(attributes.back());
        attributes.pop_back();
        labelIndex = static_cast<int>(attributes.size());
    } else {
-        className = get<0>(attributes.front());
-        classType = get<1>(attributes.front());
+        className = std::get<0>(attributes.front());
+        classType = std::get<1>(attributes.front());
        attributes.erase(attributes.begin());
        labelIndex = 0;
    }
    generateDataset(labelIndex);
 }
-void ArffFiles::load(const string& fileName, const string& name)
+void ArffFiles::load(const std::string& fileName, const std::string& name)
 {
    int labelIndex;
    loadCommon(fileName);
    bool found = false;
    for (int i = 0; i < attributes.size(); ++i) {
        if (attributes[i].first == name) {
-            className = get<0>(attributes[i]);
-            classType = get<1>(attributes[i]);
+            className = std::get<0>(attributes[i]);
+            classType = std::get<1>(attributes[i]);
            attributes.erase(attributes.begin() + i);
            labelIndex = i;
            found = true;
@@ -110,19 +108,19 @@ void ArffFiles::load(const string& fileName, const string& name)
        }
    }
    if (!found) {
-        throw invalid_argument("Class name not found");
+        throw std::invalid_argument("Class name not found");
    }
    generateDataset(labelIndex);
 }

 void ArffFiles::generateDataset(int labelIndex)
 {
-    X = vector<vector<float>>(attributes.size(), vector<float>(lines.size()));
-    auto yy = vector<string>(lines.size(), "");
-    auto removeLines = vector<int>(); // Lines with missing values
+    X = std::vector<std::vector<float>>(attributes.size(), std::vector<float>(lines.size()));
+    auto yy = std::vector<std::string>(lines.size(), "");
+    auto removeLines = std::vector<int>(); // Lines with missing values
    for (size_t i = 0; i < lines.size(); i++) {
-        stringstream ss(lines[i]);
-        string value;
+        std::stringstream ss(lines[i]);
+        std::string value;
        int pos = 0;
        int xIndex = 0;
        while (getline(ss, value, ',')) {
@@ -146,21 +144,21 @@ void ArffFiles::generateDataset(int labelIndex)
    y = factorize(yy);
 }

-string ArffFiles::trim(const string& source)
+std::string ArffFiles::trim(const std::string& source)
 {
-    string s(source);
+    std::string s(source);
    s.erase(0, s.find_first_not_of(" '\n\r\t"));
    s.erase(s.find_last_not_of(" '\n\r\t") + 1);
    return s;
 }

-vector<int> ArffFiles::factorize(const vector<string>& labels_t)
+std::vector<int> ArffFiles::factorize(const std::vector<std::string>& labels_t)
 {
-    vector<int> yy;
+    std::vector<int> yy;
    yy.reserve(labels_t.size());
-    map<string, int> labelMap;
+    std::map<std::string, int> labelMap;
    int i = 0;
-    for (const string& label : labels_t) {
+    for (const std::string& label : labels_t) {
        if (labelMap.find(label) == labelMap.end()) {
            labelMap[label] = i++;
        }
--- a/lib/Files/ArffFiles.h
+++ b/lib/Files/ArffFiles.h
@@ -4,31 +4,29 @@
 #include <string>
 #include <vector>

-using namespace std;
-
 class ArffFiles {
 private:
-    vector<string> lines;
-    vector<pair<string, string>> attributes;
-    string className;
-    string classType;
-    vector<vector<float>> X;
-    vector<int> y;
+    std::vector<std::string> lines;
+    std::vector<std::pair<std::string, std::string>> attributes;
+    std::string className;
+    std::string classType;
+    std::vector<std::vector<float>> X;
+    std::vector<int> y;
    void generateDataset(int);
-    void loadCommon(string);
+    void loadCommon(std::string);
 public:
    ArffFiles();
-    void load(const string&, bool = true);
-    void load(const string&, const string&);
-    vector<string> getLines() const;
+    void load(const std::string&, bool = true);
+    void load(const std::string&, const std::string&);
+    std::vector<std::string> getLines() const;
    unsigned long int getSize() const;
-    string getClassName() const;
-    string getClassType() const;
-    static string trim(const string&);
-    vector<vector<float>>& getX();
-    vector<int>& getY();
-    vector<pair<string, string>> getAttributes() const;
-    static vector<int> factorize(const vector<string>& labels_t);
+    std::string getClassName() const;
+    std::string getClassType() const;
+    static std::string trim(const std::string&);
+    std::vector<std::vector<float>>& getX();
+    std::vector<int>& getY();
+    std::vector<std::pair<std::string, std::string>> getAttributes() const;
+    static std::vector<int> factorize(const std::vector<std::string>& labels_t);
 };

 #endif
--- a/lib/argparse
+++ b/lib/argparse
--- a/lib/catch2
+++ b/lib/catch2
--- a/lib/json
+++ b/lib/json
--- a/mac_mst.txt
+++ b/mac_mst.txt
@@ -1,33 +0,0 @@
-Weights matrix: 
- 0.0000000,   0.0384968,   0.0795434,   0.1546867,  -0.0000000,   0.1788104,   0.2214721,   0.0323837,   0.0366549,  
- 0.0384968,   0.0000000,   0.0200662,   0.0200937,  -0.0000000,   0.0637224,   0.0183005,   0.0127657,   0.0136054,  
- 0.0795434,   0.0200662,   0.0000000,   0.0605489,  -0.0000000,   0.0894469,   0.1689408,   0.0321602,   0.0223184,  
- 0.1546867,   0.0200937,   0.0605489,   0.0000000,  -0.0000000,   0.1150757,   0.1332292,   0.0422865,   0.0191138,  
-0.0000000,  -0.0000000,  -0.0000000,  -0.0000000,   0.0000000,   0.0000000,   0.0000000,   0.0000000,   0.0000000,  
- 0.1788104,   0.0637224,   0.0894469,   0.1150757,   0.0000000,   0.0000000,   0.1407102,   0.0406590,   0.0366986,  
- 0.2214721,   0.0183005,   0.1689408,   0.1332292,   0.0000000,   0.1407102,   0.0000000,   0.0427515,   0.0349965,  
- 0.0323837,   0.0127657,   0.0321602,   0.0422865,   0.0000000,   0.0406590,   0.0427515,   0.0000000,   0.0343376,  
- 0.0366549,   0.0136054,   0.0223184,   0.0191138,   0.0000000,   0.0366986,   0.0349965,   0.0343376,   0.0000000,  
-Edge : Weight
-0 - 6 : 0.2214721
-0 - 5 : 0.1788104
-2 - 6 : 0.1689408
-0 - 3 : 0.1546867
-1 - 5 : 0.0637224
-6 - 7 : 0.0427515
-5 - 8 : 0.0366986
-4 - 5 : 0.0000000
-------------------------------------------------------------------------------
-Metrics Test
-  Test Maximum Spanning Tree
-------------------------------------------------------------------------------
-/Users/rmontanana/Code/BayesNet/tests/TestBayesMetrics.cc:58
-...............................................................................
-
-/Users/rmontanana/Code/BayesNet/tests/TestBayesMetrics.cc:69: PASSED:
-  REQUIRE( result == resultsMST.at(file_name) )
-with expansion:
-  (0, 6) (0, 5) (0, 3) (5, 1) (5, 8) (5, 4) (6, 2) (6, 7)
-  ==
-  (0, 6) (0, 5) (0, 3) (5, 1) (5, 8) (5, 4) (6, 2) (6, 7)
-
--- a/sample/CMakeLists.txt
+++ b/sample/CMakeLists.txt
@@ -1,8 +1,10 @@
 include_directories(${BayesNet_SOURCE_DIR}/src/Platform)
 include_directories(${BayesNet_SOURCE_DIR}/src/BayesNet)
+include_directories(${BayesNet_SOURCE_DIR}/src/PyClassifiers)
+include_directories(${Python3_INCLUDE_DIRS})
 include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
 include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
 include_directories(${BayesNet_SOURCE_DIR}/lib/argparse/include)
 include_directories(${BayesNet_SOURCE_DIR}/lib/json/include)
 add_executable(BayesNetSample sample.cc ${BayesNet_SOURCE_DIR}/src/Platform/Folding.cc ${BayesNet_SOURCE_DIR}/src/Platform/Models.cc) 
-target_link_libraries(BayesNetSample BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}")
+target_link_libraries(BayesNetSample BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}" PyWrap)
--- a/sample/sample.cc
+++ b/sample/sample.cc
@@ -4,7 +4,7 @@
 #include <map>
 #include <argparse/argparse.hpp>
 #include <nlohmann/json.hpp>
-#include "ArffFiles.h"v
+#include "ArffFiles.h"
 #include "BayesMetrics.h"
 #include "CPPFImdlp.h"
 #include "Folding.h"
@@ -12,14 +12,12 @@
 #include "modelRegister.h"
 #include <fstream>

-using namespace std;
+const std::string PATH = "../../data/";

-const string PATH = "../../data/";
-
-pair<vector<mdlp::labels_t>, map<string, int>> discretize(vector<mdlp::samples_t>& X, mdlp::labels_t& y, vector<string> features)
+pair<std::vector<mdlp::labels_t>, map<std::string, int>> discretize(std::vector<mdlp::samples_t>& X, mdlp::labels_t& y, std::vector<std::string> features)
 {
-    vector<mdlp::labels_t>Xd;
-    map<string, int> maxes;
+    std::vector<mdlp::labels_t>Xd;
+    map<std::string, int> maxes;

    auto fimdlp = mdlp::CPPFImdlp();
    for (int i = 0; i < X.size(); i++) {
@@ -40,12 +38,12 @@ bool file_exists(const std::string& name)
        return false;
    }
 }
-pair<vector<vector<int>>, vector<int>> extract_indices(vector<int> indices, vector<vector<int>> X, vector<int> y)
+pair<std::vector<std::vector<int>>, std::vector<int>> extract_indices(std::vector<int> indices, std::vector<std::vector<int>> X, std::vector<int> y)
 {
-    vector<vector<int>> Xr; // nxm
-    vector<int> yr;
+    std::vector<std::vector<int>> Xr; // nxm
+    std::vector<int> yr;
    for (int col = 0; col < X.size(); ++col) {
-        Xr.push_back(vector<int>());
+        Xr.push_back(std::vector<int>());
    }
    for (auto index : indices) {
        for (int col = 0; col < X.size(); ++col) {
@@ -58,7 +56,7 @@ pair<vector<vector<int>>, vector<int>> extract_indices(vector<int> indices, vect

 int main(int argc, char** argv)
 {
-    map<string, bool> datasets = {
+    map<std::string, bool> datasets = {
            {"diabetes",           true},
            {"ecoli",              true},
            {"glass",              true},
@@ -68,9 +66,9 @@ int main(int argc, char** argv)
            {"liver-disorders",    true},
            {"mfeat-factors",      true},
    };
-    auto valid_datasets = vector<string>();
+    auto valid_datasets = std::vector<std::string>();
    transform(datasets.begin(), datasets.end(), back_inserter(valid_datasets),
-        [](const pair<string, bool>& pair) { return pair.first; });
+        [](const pair<std::string, bool>& pair) { return pair.first; });
    argparse::ArgumentParser program("BayesNetSample");
    program.add_argument("-d", "--dataset")
        .help("Dataset file name")
@@ -83,23 +81,23 @@ int main(int argc, char** argv)
    );
    program.add_argument("-p", "--path")
        .help(" folder where the data files are located, default")
-        .default_value(string{ PATH }
+        .default_value(std::string{ PATH }
    );
    program.add_argument("-m", "--model")
-        .help("Model to use " + platform::Models::instance()->toString())
+        .help("Model to use " + platform::Models::instance()->tostring())
        .action([](const std::string& value) {
-        static const vector<string> choices = platform::Models::instance()->getNames();
+        static const std::vector<std::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::instance()->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) {
+    program.add_argument("-f", "--folds").help("Number of folds").default_value(5).scan<'i', int>().action([](const std::string& value) {
        try {
            auto k = stoi(value);
            if (k < 2) {
@@ -115,13 +113,13 @@ int main(int argc, char** argv)
        }});
    program.add_argument("-s", "--seed").help("Random seed").default_value(-1).scan<'i', int>();
    bool class_last, stratified, tensors, dump_cpt;
-    string model_name, file_name, path, complete_file_name;
+    std::string model_name, file_name, path, complete_file_name;
    int nFolds, seed;
    try {
        program.parse_args(argc, argv);
-        file_name = program.get<string>("dataset");
-        path = program.get<string>("path");
-        model_name = program.get<string>("model");
+        file_name = program.get<std::string>("dataset");
+        path = program.get<std::string>("path");
+        model_name = program.get<std::string>("model");
        complete_file_name = path + file_name + ".arff";
        stratified = program.get<bool>("stratified");
        tensors = program.get<bool>("tensors");
@@ -134,7 +132,7 @@ int main(int argc, char** argv)
        }
    }
    catch (const exception& err) {
-        cerr << err.what() << endl;
+        cerr << err.what() << std::endl;
        cerr << program;
        exit(1);
    }
@@ -145,50 +143,50 @@ int main(int argc, char** argv)
    auto handler = ArffFiles();
    handler.load(complete_file_name, class_last);
    // Get Dataset X, y
-    vector<mdlp::samples_t>& X = handler.getX();
+    std::vector<mdlp::samples_t>& X = handler.getX();
    mdlp::labels_t& y = handler.getY();
    // Get className & Features
    auto className = handler.getClassName();
-    vector<string> features;
+    std::vector<std::string> features;
    auto attributes = handler.getAttributes();
    transform(attributes.begin(), attributes.end(), back_inserter(features),
-        [](const pair<string, string>& item) { return item.first; });
+        [](const pair<std::string, std::string>& item) { return item.first; });
    // Discretize Dataset
    auto [Xd, maxes] = discretize(X, y, features);
    maxes[className] = *max_element(y.begin(), y.end()) + 1;
-    map<string, vector<int>> states;
+    map<std::string, std::vector<int>> states;
    for (auto feature : features) {
-        states[feature] = vector<int>(maxes[feature]);
+        states[feature] = std::vector<int>(maxes[feature]);
    }
-    states[className] = vector<int>(maxes[className]);
+    states[className] = std::vector<int>(maxes[className]);
    auto clf = platform::Models::instance()->create(model_name);
    clf->fit(Xd, y, features, className, states);
    if (dump_cpt) {
-        cout << "--- CPT Tables ---" << endl;
+        std::cout << "--- CPT Tables ---" << std::endl;
        clf->dump_cpt();
    }
    auto lines = clf->show();
    for (auto line : lines) {
-        cout << line << endl;
+        std::cout << line << std::endl;
    }
-    cout << "--- Topological Order ---" << endl;
+    std::cout << "--- Topological Order ---" << std::endl;
    auto order = clf->topological_order();
    for (auto name : order) {
-        cout << name << ", ";
+        std::cout << name << ", ";
    }
-    cout << "end." << endl;
+    std::cout << "end." << std::endl;
    auto score = clf->score(Xd, y);
-    cout << "Score: " << score << endl;
+    std::cout << "Score: " << score << std::endl;
    auto graph = clf->graph();
    auto dot_file = model_name + "_" + file_name;
    ofstream file(dot_file + ".dot");
    file << graph;
    file.close();
-    cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << endl;
-    cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << endl;
-    string stratified_string = stratified ? " Stratified" : "";
-    cout << nFolds << " Folds" << stratified_string << " Cross validation" << endl;
-    cout << "==========================================" << endl;
+    std::cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << std::endl;
+    std::cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << std::endl;
+    std::string stratified_string = stratified ? " Stratified" : "";
+    std::cout << nFolds << " Folds" << stratified_string << " Cross validation" << std::endl;
+    std::cout << "==========================================" << std::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) {
@@ -202,7 +200,7 @@ int main(int argc, char** argv)
        fold = new platform::KFold(nFolds, y.size(), seed);
    for (auto i = 0; i < nFolds; ++i) {
        auto [train, test] = fold->getFold(i);
-        cout << "Fold: " << i + 1 << endl;
+        std::cout << "Fold: " << i + 1 << std::endl;
        if (tensors) {
            auto ttrain = torch::tensor(train, torch::kInt64);
            auto ttest = torch::tensor(test, torch::kInt64);
@@ -222,16 +220,16 @@ int main(int argc, char** argv)
            score_test = clf->score(Xtest, ytest);
        }
        if (dump_cpt) {
-            cout << "--- CPT Tables ---" << endl;
+            std::cout << "--- CPT Tables ---" << std::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;
+        std::cout << "Score Train: " << score_train << std::endl;
+        std::cout << "Score Test : " << score_test << std::endl;
+        std::cout << "-------------------------------------------------------------------------------" << std::endl;
    }
-    cout << "**********************************************************************************" << endl;
-    cout << "Average Score Train: " << total_score_train / nFolds << endl;
-    cout << "Average Score Test : " << total_score / nFolds << endl;return 0;
+    std::cout << "**********************************************************************************" << std::endl;
+    std::cout << "Average Score Train: " << total_score_train / nFolds << std::endl;
+    std::cout << "Average Score Test : " << total_score / nFolds << std::endl;return 0;
 }
--- a/src/BayesNet/AODE.cc
+++ b/src/BayesNet/AODE.cc
@@ -9,9 +9,9 @@ namespace bayesnet {
            models.push_back(std::make_unique<SPODE>(i));
        }
        n_models = models.size();
-        significanceModels = vector<double>(n_models, 1.0);
+        significanceModels = std::vector<double>(n_models, 1.0);
    }
-    vector<string> AODE::graph(const string& title) const
+    std::vector<std::string> AODE::graph(const std::string& title) const
    {
        return Ensemble::graph(title);
    }
--- a/src/BayesNet/AODE.h
+++ b/src/BayesNet/AODE.h
@@ -9,7 +9,7 @@ namespace bayesnet {
    public:
        AODE();
        virtual ~AODE() {};
-        vector<string> graph(const string& title = "AODE") const override;
+        std::vector<std::string> graph(const std::string& title = "AODE") const override;
    };
 }
 #endif
--- a/src/BayesNet/AODELd.cc
+++ b/src/BayesNet/AODELd.cc
@@ -1,17 +1,15 @@
 #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_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
+    AODELd& AODELd::fit(torch::Tensor& X_, torch::Tensor& y_, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_)
    {
        checkInput(X_, y_);
        features = features_;
        className = className_;
        Xf = X_;
        y = y_;
-        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        // Fills std::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
@@ -26,7 +24,7 @@ namespace bayesnet {
            models.push_back(std::make_unique<SPODELd>(i));
        }
        n_models = models.size();
-        significanceModels = vector<double>(n_models, 1.0);
+        significanceModels = std::vector<double>(n_models, 1.0);
    }
    void AODELd::trainModel(const torch::Tensor& weights)
    {
@@ -34,7 +32,7 @@ namespace bayesnet {
            model->fit(Xf, y, features, className, states);
        }
    }
-    vector<string> AODELd::graph(const string& name) const
+    std::vector<std::string> AODELd::graph(const std::string& name) const
    {
        return Ensemble::graph(name);
    }
--- a/src/BayesNet/AODELd.h
+++ b/src/BayesNet/AODELd.h
@@ -5,17 +5,16 @@
 #include "SPODELd.h"

 namespace bayesnet {
-    using namespace std;
    class AODELd : public Ensemble, public Proposal {
    protected:
        void trainModel(const torch::Tensor& weights) override;
        void buildModel(const torch::Tensor& weights) override;
    public:
        AODELd();
-        AODELd& fit(torch::Tensor& X_, torch::Tensor& y_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_) override;
+        AODELd& fit(torch::Tensor& X_, torch::Tensor& y_, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_) override;
        virtual ~AODELd() = default;
-        vector<string> graph(const string& name = "AODELd") const override;
-        static inline string version() { return "0.0.1"; };
+        std::vector<std::string> graph(const std::string& name = "AODELd") const override;
+        static inline std::string version() { return "0.0.1"; };
    };
 }
 #endif // !AODELD_H
--- a/src/BayesNet/BaseClassifier.h
+++ b/src/BayesNet/BaseClassifier.h
@@ -4,33 +4,34 @@
 #include <nlohmann/json.hpp>
 #include <vector>
 namespace bayesnet {
-    using namespace std;
    enum status_t { NORMAL, WARNING, ERROR };
    class BaseClassifier {
-    protected:
-        virtual void trainModel(const torch::Tensor& weights) = 0;
    public:
-        // X is nxm vector, y is nx1 vector
-        virtual BaseClassifier& fit(vector<vector<int>>& X, vector<int>& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) = 0;
+        // X is nxm std::vector, y is nx1 std::vector
+        virtual BaseClassifier& fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) = 0;
        // X is nxm tensor, y is nx1 tensor
-        virtual BaseClassifier& fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) = 0;
-        virtual BaseClassifier& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states) = 0;
-        virtual BaseClassifier& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights) = 0;
+        virtual BaseClassifier& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) = 0;
+        virtual BaseClassifier& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) = 0;
+        virtual BaseClassifier& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights) = 0;
        virtual ~BaseClassifier() = default;
        torch::Tensor virtual predict(torch::Tensor& X) = 0;
-        vector<int> virtual predict(vector<vector<int>>& X) = 0;
+        std::vector<int> virtual predict(std::vector<std::vector<int >>& X) = 0;
        status_t virtual getStatus() const = 0;
-        float virtual score(vector<vector<int>>& X, vector<int>& y) = 0;
+        float virtual score(std::vector<std::vector<int>>& X, std::vector<int>& y) = 0;
        float virtual score(torch::Tensor& X, torch::Tensor& y) = 0;
        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.2.0"; };
-        vector<string> virtual topological_order() = 0;
+        std::vector<std::string> virtual show() const = 0;
+        std::vector<std::string> virtual graph(const std::string& title = "") const = 0;
+        virtual std::string getVersion() = 0;
+        std::vector<std::string> virtual topological_order() = 0;
        void virtual dump_cpt()const = 0;
-        virtual void setHyperparameters(nlohmann::json& hyperparameters) = 0;
+        virtual void setHyperparameters(const nlohmann::json& hyperparameters) = 0;
+        std::vector<std::string>& getValidHyperparameters() { return validHyperparameters; }
+    protected:
+        virtual void trainModel(const torch::Tensor& weights) = 0;
+        std::vector<std::string> validHyperparameters;
    };
 }
 #endif
--- a/src/BayesNet/BayesMetrics.cc
+++ b/src/BayesNet/BayesMetrics.cc
@@ -2,15 +2,15 @@
 #include "Mst.h"
 namespace bayesnet {
    //samples is n+1xm tensor used to fit the model
-    Metrics::Metrics(const torch::Tensor& samples, const vector<string>& features, const string& className, const int classNumStates)
+    Metrics::Metrics(const torch::Tensor& samples, const std::vector<std::string>& features, const std::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)
+    //samples is nxm std::vector used to fit the model
+    Metrics::Metrics(const std::vector<std::vector<int>>& vsamples, const std::vector<int>& labels, const std::vector<std::string>& features, const std::string& className, const int classNumStates)
        : features(features)
        , className(className)
        , classNumStates(classNumStates)
@@ -21,7 +21,7 @@ namespace bayesnet {
        }
        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
    }
-    vector<int> Metrics::SelectKBestWeighted(const torch::Tensor& weights, bool ascending, unsigned k)
+    std::vector<int> Metrics::SelectKBestWeighted(const torch::Tensor& weights, bool ascending, unsigned k)
    {
        // Return the K Best features 
        auto n = samples.size(0) - 1;
@@ -56,15 +56,15 @@ namespace bayesnet {
        }
        return featuresKBest;
    }
-    vector<double> Metrics::getScoresKBest() const
+    std::vector<double> Metrics::getScoresKBest() const
    {
        return scoresKBest;
    }

    torch::Tensor Metrics::conditionalEdge(const torch::Tensor& weights)
    {
-        auto result = vector<double>();
-        auto source = vector<string>(features);
+        auto result = std::vector<double>();
+        auto source = std::vector<std::string>(features);
        source.push_back(className);
        auto combinations = doCombinations(source);
        // Compute class prior
@@ -100,7 +100,7 @@ namespace bayesnet {
        return matrix;
    }
    // To use in Python
-    vector<float> Metrics::conditionalEdgeWeights(vector<float>& weights_)
+    std::vector<float> Metrics::conditionalEdgeWeights(std::vector<float>& weights_)
    {
        const torch::Tensor weights = torch::tensor(weights_);
        auto matrix = conditionalEdge(weights);
@@ -121,7 +121,7 @@ namespace bayesnet {
    {
        int numSamples = firstFeature.sizes()[0];
        torch::Tensor featureCounts = secondFeature.bincount(weights);
-        unordered_map<int, unordered_map<int, double>> jointCounts;
+        std::unordered_map<int, std::unordered_map<int, double>> jointCounts;
        double totalWeight = 0;
        for (auto i = 0; i < numSamples; i++) {
            jointCounts[secondFeature[i].item<int>()][firstFeature[i].item<int>()] += weights[i].item<double>();
@@ -155,7 +155,7 @@ namespace bayesnet {
    and the indices of the weights as nodes of this square matrix using
    Kruskal algorithm
    */
-    vector<pair<int, int>> Metrics::maximumSpanningTree(const vector<string>& features, const Tensor& weights, const int root)
+    std::vector<std::pair<int, int>> Metrics::maximumSpanningTree(const std::vector<std::string>& features, const torch::Tensor& weights, const int root)
    {
        auto mst = MST(features, weights, root);
        return mst.maximumSpanningTree();
--- a/src/BayesNet/BayesMetrics.h
+++ b/src/BayesNet/BayesMetrics.h
@@ -4,23 +4,21 @@
 #include <vector>
 #include <string>
 namespace bayesnet {
-    using namespace std;
-    using namespace torch;
    class Metrics {
    private:
        int classNumStates = 0;
-        vector<double> scoresKBest;
-        vector<int> featuresKBest; // sorted indices of the features
-        double conditionalEntropy(const Tensor& firstFeature, const Tensor& secondFeature, const Tensor& weights);
+        std::vector<double> scoresKBest;
+        std::vector<int> featuresKBest; // sorted indices of the features
+        double conditionalEntropy(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature, const torch::Tensor& weights);
    protected:
-        Tensor samples; // n+1xm tensor used to fit the model where samples[-1] is the y vector
-        string className;
-        double entropy(const Tensor& feature, const Tensor& weights);
-        vector<string> features;
+        torch::Tensor samples; // n+1xm torch::Tensor used to fit the model where samples[-1] is the y std::vector
+        std::string className;
+        double entropy(const torch::Tensor& feature, const torch::Tensor& weights);
+        std::vector<std::string> features;
        template <class T>
-        vector<pair<T, T>> doCombinations(const vector<T>& source)
+        std::vector<std::pair<T, T>> doCombinations(const std::vector<T>& source)
        {
-            vector<pair<T, T>> result;
+            std::vector<std::pair<T, T>> result;
            for (int i = 0; i < source.size(); ++i) {
                T temp = source[i];
                for (int j = i + 1; j < source.size(); ++j) {
@@ -30,7 +28,7 @@ namespace bayesnet {
            return result;
        }
        template <class T>
-        T pop_first(vector<T>& v)
+        T pop_first(std::vector<T>& v)
        {
            T temp = v[0];
            v.erase(v.begin());
@@ -38,14 +36,14 @@ namespace bayesnet {
        }
    public:
        Metrics() = default;
-        Metrics(const torch::Tensor& samples, const vector<string>& features, const string& className, const int classNumStates);
-        Metrics(const vector<vector<int>>& vsamples, const vector<int>& labels, const vector<string>& features, const string& className, const int classNumStates);
-        vector<int> SelectKBestWeighted(const torch::Tensor& weights, bool ascending = false, unsigned k = 0);
-        vector<double> getScoresKBest() const;
-        double mutualInformation(const Tensor& firstFeature, const Tensor& secondFeature, const Tensor& weights);
-        vector<float> conditionalEdgeWeights(vector<float>& weights); // To use in Python
-        Tensor conditionalEdge(const torch::Tensor& weights);
-        vector<pair<int, int>> maximumSpanningTree(const vector<string>& features, const Tensor& weights, const int root);
+        Metrics(const torch::Tensor& samples, const std::vector<std::string>& features, const std::string& className, const int classNumStates);
+        Metrics(const std::vector<std::vector<int>>& vsamples, const std::vector<int>& labels, const std::vector<std::string>& features, const std::string& className, const int classNumStates);
+        std::vector<int> SelectKBestWeighted(const torch::Tensor& weights, bool ascending = false, unsigned k = 0);
+        std::vector<double> getScoresKBest() const;
+        double mutualInformation(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature, const torch::Tensor& weights);
+        std::vector<float> conditionalEdgeWeights(std::vector<float>& weights); // To use in Python
+        torch::Tensor conditionalEdge(const torch::Tensor& weights);
+        std::vector<std::pair<int, int>> maximumSpanningTree(const std::vector<std::string>& features, const torch::Tensor& weights, const int root);
    };
 }
 #endif
--- a/src/BayesNet/BoostAODE.cc
+++ b/src/BayesNet/BoostAODE.cc
@@ -10,7 +10,11 @@
 #include "IWSS.h"

 namespace bayesnet {
-    BoostAODE::BoostAODE() : Ensemble() {}
+    BoostAODE::BoostAODE() : Ensemble()
+    {
+        validHyperparameters = { "repeatSparent", "maxModels", "ascending", "convergence", "threshold", "select_features", "tolerance" };
+
+    }
    void BoostAODE::buildModel(const torch::Tensor& weights)
    {
        // Models shall be built in trainModel
@@ -43,60 +47,71 @@ namespace bayesnet {
            y_train = y_;
        }
    }
-    void BoostAODE::setHyperparameters(nlohmann::json& hyperparameters)
+    void BoostAODE::setHyperparameters(const nlohmann::json& hyperparameters_)
    {
-        // Check if hyperparameters are valid
-        const vector<string> validKeys = { "repeatSparent", "maxModels", "ascending", "convergence", "threshold", "select_features" };
-        checkHyperparameters(validKeys, hyperparameters);
+        auto hyperparameters = hyperparameters_;
        if (hyperparameters.contains("repeatSparent")) {
            repeatSparent = hyperparameters["repeatSparent"];
+            hyperparameters.erase("repeatSparent");
        }
        if (hyperparameters.contains("maxModels")) {
            maxModels = hyperparameters["maxModels"];
+            hyperparameters.erase("maxModels");
        }
        if (hyperparameters.contains("ascending")) {
            ascending = hyperparameters["ascending"];
+            hyperparameters.erase("ascending");
        }
        if (hyperparameters.contains("convergence")) {
            convergence = hyperparameters["convergence"];
+            hyperparameters.erase("convergence");
        }
        if (hyperparameters.contains("threshold")) {
            threshold = hyperparameters["threshold"];
+            hyperparameters.erase("threshold");
+        }
+        if (hyperparameters.contains("tolerance")) {
+            tolerance = hyperparameters["tolerance"];
+            hyperparameters.erase("tolerance");
        }
        if (hyperparameters.contains("select_features")) {
            auto selectedAlgorithm = hyperparameters["select_features"];
-            vector<string> algos = { "IWSS", "FCBF", "CFS" };
+            std::vector<std::string> algos = { "IWSS", "FCBF", "CFS" };
            selectFeatures = true;
            algorithm = selectedAlgorithm;
-            if (find(algos.begin(), algos.end(), selectedAlgorithm) == algos.end()) {
-                throw invalid_argument("Invalid selectFeatures value [IWSS, FCBF, CFS]");
+            if (std::find(algos.begin(), algos.end(), selectedAlgorithm) == algos.end()) {
+                throw std::invalid_argument("Invalid selectFeatures value [IWSS, FCBF, CFS]");
+            }
+            hyperparameters.erase("select_features");
+        }
+        if (!hyperparameters.empty()) {
+            throw std::invalid_argument("Invalid hyperparameters" + hyperparameters.dump());
        }
    }
-    }
-    unordered_set<int> BoostAODE::initializeModels()
+    std::unordered_set<int> BoostAODE::initializeModels()
    {
-        unordered_set<int> featuresUsed;
-        Tensor weights_ = torch::full({ m }, 1.0 / m, torch::kFloat64);
+        std::unordered_set<int> featuresUsed;
+        torch::Tensor weights_ = torch::full({ m }, 1.0 / m, torch::kFloat64);
        int maxFeatures = 0;
        if (algorithm == "CFS") {
            featureSelector = new CFS(dataset, features, className, maxFeatures, states.at(className).size(), weights_);
        } else if (algorithm == "IWSS") {
            if (threshold < 0 || threshold >0.5) {
-                throw invalid_argument("Invalid threshold value for IWSS [0, 0.5]");
+                throw std::invalid_argument("Invalid threshold value for IWSS [0, 0.5]");
            }
            featureSelector = new IWSS(dataset, features, className, maxFeatures, states.at(className).size(), weights_, threshold);
        } else if (algorithm == "FCBF") {
            if (threshold < 1e-7 || threshold > 1) {
-                throw invalid_argument("Invalid threshold value [1e-7, 1]");
+                throw std::invalid_argument("Invalid threshold value [1e-7, 1]");
            }
            featureSelector = new FCBF(dataset, features, className, maxFeatures, states.at(className).size(), weights_, threshold);
        }
        featureSelector->fit();
        auto cfsFeatures = featureSelector->getFeatures();
        for (const int& feature : cfsFeatures) {
-            // cout << "Feature: [" << feature << "] " << feature << " " << features.at(feature) << endl;
+            // std::cout << "Feature: [" << feature << "] " << feature << " " << features.at(feature) << std::endl;
            featuresUsed.insert(feature);
-            unique_ptr<Classifier> model = std::make_unique<SPODE>(feature);
+            std::unique_ptr<Classifier> model = std::make_unique<SPODE>(feature);
            model->fit(dataset, features, className, states, weights_);
            models.push_back(std::move(model));
            significanceModels.push_back(1.0);
@@ -107,35 +122,34 @@ namespace bayesnet {
    }
    void BoostAODE::trainModel(const torch::Tensor& weights)
    {
-        unordered_set<int> featuresUsed;
+        std::unordered_set<int> featuresUsed;
        if (selectFeatures) {
            featuresUsed = initializeModels();
        }
        if (maxModels == 0)
            maxModels = .1 * n > 10 ? .1 * n : n;
-        Tensor weights_ = torch::full({ m }, 1.0 / m, torch::kFloat64);
+        torch::Tensor weights_ = torch::full({ m }, 1.0 / m, torch::kFloat64);
        bool exitCondition = false;
        // Variables to control the accuracy finish condition
        double priorAccuracy = 0.0;
        double delta = 1.0;
        double threshold = 1e-4;
-        int tolerance = 5; // number of times the accuracy can be lower than the threshold
        int count = 0; // number of times the accuracy is lower than the threshold
        fitted = true; // to enable predict
        // Step 0: Set the finish condition
        // if not repeatSparent a finish condition is run out of features
        // n_models == maxModels
-        // epsiolon sub t > 0.5 => inverse the weights policy
+        // epsilon sub t > 0.5 => inverse the weights policy
        // validation error is not decreasing
        while (!exitCondition) {
            // Step 1: Build ranking with mutual information
            auto featureSelection = metrics.SelectKBestWeighted(weights_, ascending, n); // Get all the features sorted
-            unique_ptr<Classifier> model;
+            std::unique_ptr<Classifier> model;
            auto feature = featureSelection[0];
            if (!repeatSparent || featuresUsed.size() < featureSelection.size()) {
                bool used = true;
                for (const auto& feat : featureSelection) {
-                    if (find(featuresUsed.begin(), featuresUsed.end(), feat) != featuresUsed.end()) {
+                    if (std::find(featuresUsed.begin(), featuresUsed.end(), feat) != featuresUsed.end()) {
                        continue;
                    }
                    used = false;
@@ -188,7 +202,7 @@ namespace bayesnet {
            status = WARNING;
        }
    }
-    vector<string> BoostAODE::graph(const string& title) const
+    std::vector<std::string> BoostAODE::graph(const std::string& title) const
    {
        return Ensemble::graph(title);
    }
--- a/src/BayesNet/BoostAODE.h
+++ b/src/BayesNet/BoostAODE.h
@@ -8,23 +8,24 @@ namespace bayesnet {
    class BoostAODE : public Ensemble {
    public:
        BoostAODE();
-        virtual ~BoostAODE() {};
-        vector<string> graph(const string& title = "BoostAODE") const override;
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
+        virtual ~BoostAODE() = default;
+        std::vector<std::string> graph(const std::string& title = "BoostAODE") const override;
+        void setHyperparameters(const nlohmann::json& hyperparameters) override;
    protected:
        void buildModel(const torch::Tensor& weights) override;
        void trainModel(const torch::Tensor& weights) override;
    private:
        torch::Tensor dataset_;
        torch::Tensor X_train, y_train, X_test, y_test;
-        unordered_set<int> initializeModels();
+        std::unordered_set<int> initializeModels();
        // Hyperparameters
        bool repeatSparent = false; // if true, a feature can be selected more than once
        int maxModels = 0;
+        int tolerance = 0;
        bool ascending = false; //Process KBest features ascending or descending order
        bool convergence = false; //if true, stop when the model does not improve
        bool selectFeatures = false; // if true, use feature selection
-        string algorithm = ""; // Selected feature selection algorithm
+        std::string algorithm = ""; // Selected feature selection algorithm
        FeatureSelect* featureSelector = nullptr;
        double threshold = -1;
    };
--- a/src/BayesNet/CFS.cc
+++ b/src/BayesNet/CFS.cc
@@ -13,7 +13,7 @@ namespace bayesnet {
        selectedScores.push_back(suLabels[feature]);
        selectedFeatures.erase(selectedFeatures.begin());
        while (continueCondition) {
-            double merit = numeric_limits<double>::lowest();
+            double merit = std::numeric_limits<double>::lowest();
            int bestFeature = -1;
            for (auto feature : featureOrder) {
                selectedFeatures.push_back(feature);
@@ -36,7 +36,7 @@ namespace bayesnet {
        }
        fitted = true;
    }
-    bool CFS::computeContinueCondition(const vector<int>& featureOrder)
+    bool CFS::computeContinueCondition(const std::vector<int>& featureOrder)
    {
        if (selectedFeatures.size() == maxFeatures || featureOrder.size() == 0) {
            return false;
@@ -49,11 +49,11 @@ namespace bayesnet {
            subsets show no improvement over the current best subset."
            as stated in Mark A.Hall Thesis
            */
-            double item_ant = numeric_limits<double>::lowest();
+            double item_ant = std::numeric_limits<double>::lowest();
            int num = 0;
-            vector<double> lastFive(selectedScores.end() - 5, selectedScores.end());
+            std::vector<double> lastFive(selectedScores.end() - 5, selectedScores.end());
            for (auto item : lastFive) {
-                if (item_ant == numeric_limits<double>::lowest()) {
+                if (item_ant == std::numeric_limits<double>::lowest()) {
                    item_ant = item;
                }
                if (item > item_ant) {
--- a/src/BayesNet/CFS.h
+++ b/src/BayesNet/CFS.h
@@ -3,19 +3,18 @@
 #include <torch/torch.h>
 #include <vector>
 #include "FeatureSelect.h"
-using namespace std;
 namespace bayesnet {
    class CFS : public FeatureSelect {
    public:
-        // dataset is a n+1xm tensor of integers where dataset[-1] is the y vector
-        CFS(const torch::Tensor& samples, const vector<string>& features, const string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights) :
+        // dataset is a n+1xm tensor of integers where dataset[-1] is the y std::vector
+        CFS(const torch::Tensor& samples, const std::vector<std::string>& features, const std::string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights) :
            FeatureSelect(samples, features, className, maxFeatures, classNumStates, weights)
        {
        }
        virtual ~CFS() {};
        void fit() override;
    private:
-        bool computeContinueCondition(const vector<int>& featureOrder);
+        bool computeContinueCondition(const std::vector<int>& featureOrder);
    };
 }
 #endif
--- a/src/BayesNet/CMakeLists.txt
+++ b/src/BayesNet/CMakeLists.txt
@@ -3,6 +3,9 @@ include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
 include_directories(${BayesNet_SOURCE_DIR}/lib/json/include)
 include_directories(${BayesNet_SOURCE_DIR}/src/BayesNet)
 include_directories(${BayesNet_SOURCE_DIR}/src/Platform)
+include_directories(${BayesNet_SOURCE_DIR}/src/PyClassifiers)
+include_directories(${Python3_INCLUDE_DIRS})
+
 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 BoostAODE.cc 
    Mst.cc Proposal.cc CFS.cc FCBF.cc IWSS.cc FeatureSelect.cc ${BayesNet_SOURCE_DIR}/src/Platform/Models.cc)
--- a/src/BayesNet/Classifier.cc
+++ b/src/BayesNet/Classifier.cc
@@ -2,10 +2,8 @@
 #include "bayesnetUtils.h"

 namespace bayesnet {
-    using namespace torch;
-
    Classifier::Classifier(Network model) : model(model), m(0), n(0), metrics(Metrics()), fitted(false) {}
-    Classifier& Classifier::build(const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights)
+    Classifier& Classifier::build(const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights)
    {
        this->features = features;
        this->className = className;
@@ -21,7 +19,7 @@ namespace bayesnet {
        fitted = true;
        return *this;
    }
-    void Classifier::buildDataset(Tensor& ytmp)
+    void Classifier::buildDataset(torch::Tensor& ytmp)
    {
        try {
            auto yresized = torch::transpose(ytmp.view({ ytmp.size(0), 1 }), 0, 1);
@@ -29,8 +27,8 @@ namespace bayesnet {
        }
        catch (const std::exception& e) {
            std::cerr << e.what() << '\n';
-            cout << "X dimensions: " << dataset.sizes() << "\n";
-            cout << "y dimensions: " << ytmp.sizes() << "\n";
+            std::cout << "X dimensions: " << dataset.sizes() << "\n";
+            std::cout << "y dimensions: " << ytmp.sizes() << "\n";
            exit(1);
        }
    }
@@ -39,7 +37,7 @@ namespace bayesnet {
        model.fit(dataset, weights, features, className, states);
    }
    // X is nxm where n is the number of features and m the number of samples
-    Classifier& Classifier::fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& features, const string& className, map<string, vector<int>>& states)
+    Classifier& Classifier::fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states)
    {
        dataset = X;
        buildDataset(y);
@@ -47,24 +45,24 @@ namespace bayesnet {
        return build(features, className, states, weights);
    }
    // X is nxm where n is the number of features and m the number of samples
-    Classifier& Classifier::fit(vector<vector<int>>& X, vector<int>& y, const vector<string>& features, const string& className, map<string, vector<int>>& states)
+    Classifier& Classifier::fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states)
    {
-        dataset = torch::zeros({ static_cast<int>(X.size()), static_cast<int>(X[0].size()) }, kInt32);
+        dataset = torch::zeros({ static_cast<int>(X.size()), static_cast<int>(X[0].size()) }, torch::kInt32);
        for (int i = 0; i < X.size(); ++i) {
-            dataset.index_put_({ i, "..." }, torch::tensor(X[i], kInt32));
+            dataset.index_put_({ i, "..." }, torch::tensor(X[i], torch::kInt32));
        }
-        auto ytmp = torch::tensor(y, kInt32);
+        auto ytmp = torch::tensor(y, torch::kInt32);
        buildDataset(ytmp);
        const torch::Tensor weights = torch::full({ dataset.size(1) }, 1.0 / dataset.size(1), torch::kDouble);
        return build(features, className, states, weights);
    }
-    Classifier& Classifier::fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states)
+    Classifier& Classifier::fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states)
    {
        this->dataset = dataset;
        const torch::Tensor weights = torch::full({ dataset.size(1) }, 1.0 / dataset.size(1), torch::kDouble);
        return build(features, className, states, weights);
    }
-    Classifier& Classifier::fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights)
+    Classifier& Classifier::fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights)
    {
        this->dataset = dataset;
        return build(features, className, states, weights);
@@ -72,57 +70,57 @@ namespace bayesnet {
    void Classifier::checkFitParameters()
    {
        if (torch::is_floating_point(dataset)) {
-            throw invalid_argument("dataset (X, y) must be of type Integer");
+            throw std::invalid_argument("dataset (X, y) must be of type Integer");
        }
        if (n != features.size()) {
-            throw invalid_argument("Classifier: X " + to_string(n) + " and features " + to_string(features.size()) + " must have the same number of features");
+            throw std::invalid_argument("Classifier: X " + std::to_string(n) + " and features " + std::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");
+            throw std::invalid_argument("className not found in states");
        }
        for (auto feature : features) {
            if (states.find(feature) == states.end()) {
-                throw invalid_argument("feature [" + feature + "] not found in states");
+                throw std::invalid_argument("feature [" + feature + "] not found in states");
            }
        }
    }
-    Tensor Classifier::predict(Tensor& X)
+    torch::Tensor Classifier::predict(torch::Tensor& X)
    {
        if (!fitted) {
-            throw logic_error("Classifier has not been fitted");
+            throw std::logic_error("Classifier has not been fitted");
        }
        return model.predict(X);
    }
-    vector<int> Classifier::predict(vector<vector<int>>& X)
+    std::vector<int> Classifier::predict(std::vector<std::vector<int>>& X)
    {
        if (!fitted) {
-            throw logic_error("Classifier has not been fitted");
+            throw std::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));
+        std::vector<std::vector<int>> Xd(n_, std::vector<int>(m_, 0));
        for (auto i = 0; i < n_; i++) {
-            Xd[i] = vector<int>(X[i].begin(), X[i].end());
+            Xd[i] = std::vector<int>(X[i].begin(), X[i].end());
        }
        auto yp = model.predict(Xd);
        return yp;
    }
-    float Classifier::score(Tensor& X, Tensor& y)
+    float Classifier::score(torch::Tensor& X, torch::Tensor& y)
    {
        if (!fitted) {
-            throw logic_error("Classifier has not been fitted");
+            throw std::logic_error("Classifier has not been fitted");
        }
-        Tensor y_pred = predict(X);
+        torch::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)
+    float Classifier::score(std::vector<std::vector<int>>& X, std::vector<int>& y)
    {
        if (!fitted) {
-            throw logic_error("Classifier has not been fitted");
+            throw std::logic_error("Classifier has not been fitted");
        }
        return model.score(X, y);
    }
-    vector<string> Classifier::show() const
+    std::vector<std::string> Classifier::show() const
    {
        return model.show();
    }
@@ -137,7 +135,7 @@ namespace bayesnet {
    int Classifier::getNumberOfNodes() const
    {
        // Features does not include class
-        return fitted ? model.getFeatures().size() + 1 : 0;
+        return fitted ? model.getFeatures().size() : 0;
    }
    int Classifier::getNumberOfEdges() const
    {
@@ -147,7 +145,7 @@ namespace bayesnet {
    {
        return fitted ? model.getStates() : 0;
    }
-    vector<string> Classifier::topological_order()
+    std::vector<std::string> Classifier::topological_order()
    {
        return model.topological_sort();
    }
@@ -155,18 +153,8 @@ namespace bayesnet {
    {
        model.dump_cpt();
    }
-    void Classifier::checkHyperparameters(const vector<string>& validKeys, nlohmann::json& hyperparameters)
+    void Classifier::setHyperparameters(const nlohmann::json& hyperparameters)
    {
-        for (const auto& item : hyperparameters.items()) {
-            if (find(validKeys.begin(), validKeys.end(), item.key()) == validKeys.end()) {
-                throw invalid_argument("Hyperparameter " + item.key() + " is not valid");
-            }
-        }
-    }
-    void Classifier::setHyperparameters(nlohmann::json& hyperparameters)
-    {
-        // Check if hyperparameters are valid, default is no hyperparameters
-        const vector<string> validKeys = { };
-        checkHyperparameters(validKeys, hyperparameters);
+        //For classifiers that don't have hyperparameters
    }
 }
--- a/src/BayesNet/Classifier.h
+++ b/src/BayesNet/Classifier.h
@@ -4,48 +4,46 @@
 #include "BaseClassifier.h"
 #include "Network.h"
 #include "BayesMetrics.h"
-using namespace std;
-using namespace torch;

 namespace bayesnet {
    class Classifier : public BaseClassifier {
    private:
-        Classifier& build(const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights);
+        Classifier& build(const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights);
    protected:
        bool fitted;
        int m, n; // m: number of samples, n: number of features
        Network model;
        Metrics metrics;
-        vector<string> features;
-        string className;
-        map<string, vector<int>> states;
-        Tensor dataset; // (n+1)xm tensor
+        std::vector<std::string> features;
+        std::string className;
+        std::map<std::string, std::vector<int>> states;
+        torch::Tensor dataset; // (n+1)xm tensor
        status_t status = NORMAL;
        void checkFitParameters();
        virtual void buildModel(const torch::Tensor& weights) = 0;
        void trainModel(const torch::Tensor& weights) override;
-        void checkHyperparameters(const vector<string>& validKeys, nlohmann::json& hyperparameters);
        void buildDataset(torch::Tensor& y);
    public:
        Classifier(Network model);
        virtual ~Classifier() = default;
-        Classifier& fit(vector<vector<int>>& X, vector<int>& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        Classifier& fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        Classifier& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        Classifier& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights) override;
+        Classifier& fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) override;
+        Classifier& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) override;
+        Classifier& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) override;
+        Classifier& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights) override;
        void addNodes();
        int getNumberOfNodes() const override;
        int getNumberOfEdges() const override;
        int getNumberOfStates() const override;
-        Tensor predict(Tensor& X) override;
+        torch::Tensor predict(torch::Tensor& X) override;
        status_t getStatus() const override { return status; }
-        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() const override;
-        vector<string> topological_order()  override;
+        std::string getVersion() override { return "0.2.0"; };
+        std::vector<int> predict(std::vector<std::vector<int>>& X) override;
+        float score(torch::Tensor& X, torch::Tensor& y) override;
+        float score(std::vector<std::vector<int>>& X, std::vector<int>& y) override;
+        std::vector<std::string> show() const override;
+        std::vector<std::string> topological_order()  override;
        void dump_cpt() const override;
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
+        void setHyperparameters(const nlohmann::json& hyperparameters) override; //For classifiers that don't have hyperparameters
    };
 }
 #endif
--- a/src/BayesNet/Ensemble.cc
+++ b/src/BayesNet/Ensemble.cc
@@ -1,7 +1,6 @@
 #include "Ensemble.h"

 namespace bayesnet {
-    using namespace torch;

    Ensemble::Ensemble() : Classifier(Network()), n_models(0) {}

@@ -9,20 +8,20 @@ namespace bayesnet {
    {
        n_models = models.size();
        for (auto i = 0; i < n_models; ++i) {
-            // fit with vectors
+            // fit with std::vectors
            models[i]->fit(dataset, features, className, states);
        }
    }
-    vector<int> Ensemble::voting(Tensor& y_pred)
+    std::vector<int> Ensemble::voting(torch::Tensor& y_pred)
    {
        auto y_pred_ = y_pred.accessor<int, 2>();
-        vector<int> y_pred_final;
+        std::vector<int> y_pred_final;
        int numClasses = states.at(className).size();
        // y_pred is m x n_models with the prediction of every model for each sample
        for (int i = 0; i < y_pred.size(0); ++i) {
            // votes store in each index (value of class) the significance added by each model
            // i.e. votes[0] contains how much value has the value 0 of class. That value is generated by the models predictions
-            vector<double> votes(numClasses, 0.0);
+            std::vector<double> votes(numClasses, 0.0);
            for (int j = 0; j < n_models; ++j) {
                votes[y_pred_[i][j]] += significanceModels.at(j);
            }
@@ -32,18 +31,18 @@ namespace bayesnet {
        }
        return y_pred_final;
    }
-    Tensor Ensemble::predict(Tensor& X)
+    torch::Tensor Ensemble::predict(torch::Tensor& X)
    {
        if (!fitted) {
-            throw logic_error("Ensemble has not been fitted");
+            throw std::logic_error("Ensemble has not been fitted");
        }
-        Tensor y_pred = torch::zeros({ X.size(1), n_models }, kInt32);
-        auto threads{ vector<thread>() };
-        mutex mtx;
+        torch::Tensor y_pred = torch::zeros({ X.size(1), n_models }, torch::kInt32);
+        auto threads{ std::vector<std::thread>() };
+        std::mutex mtx;
        for (auto i = 0; i < n_models; ++i) {
-            threads.push_back(thread([&, i]() {
+            threads.push_back(std::thread([&, i]() {
                auto ypredict = models[i]->predict(X);
-                lock_guard<mutex> lock(mtx);
+                std::lock_guard<std::mutex> lock(mtx);
                y_pred.index_put_({ "...", i }, ypredict);
                }));
        }
@@ -52,27 +51,27 @@ namespace bayesnet {
        }
        return torch::tensor(voting(y_pred));
    }
-    vector<int> Ensemble::predict(vector<vector<int>>& X)
+    std::vector<int> Ensemble::predict(std::vector<std::vector<int>>& X)
    {
        if (!fitted) {
-            throw logic_error("Ensemble has not been fitted");
+            throw std::logic_error("Ensemble has not been fitted");
        }
        long m_ = X[0].size();
        long n_ = X.size();
-        vector<vector<int>> Xd(n_, vector<int>(m_, 0));
+        std::vector<std::vector<int>> Xd(n_, std::vector<int>(m_, 0));
        for (auto i = 0; i < n_; i++) {
-            Xd[i] = vector<int>(X[i].begin(), X[i].end());
+            Xd[i] = std::vector<int>(X[i].begin(), X[i].end());
        }
-        Tensor y_pred = torch::zeros({ m_, n_models }, kInt32);
+        torch::Tensor y_pred = torch::zeros({ m_, n_models }, torch::kInt32);
        for (auto i = 0; i < n_models; ++i) {
-            y_pred.index_put_({ "...", i }, torch::tensor(models[i]->predict(Xd), kInt32));
+            y_pred.index_put_({ "...", i }, torch::tensor(models[i]->predict(Xd), torch::kInt32));
        }
        return voting(y_pred);
    }
-    float Ensemble::score(Tensor& X, Tensor& y)
+    float Ensemble::score(torch::Tensor& X, torch::Tensor& y)
    {
        if (!fitted) {
-            throw logic_error("Ensemble has not been fitted");
+            throw std::logic_error("Ensemble has not been fitted");
        }
        auto y_pred = predict(X);
        int correct = 0;
@@ -83,10 +82,10 @@ namespace bayesnet {
        }
        return (double)correct / y_pred.size(0);
    }
-    float Ensemble::score(vector<vector<int>>& X, vector<int>& y)
+    float Ensemble::score(std::vector<std::vector<int>>& X, std::vector<int>& y)
    {
        if (!fitted) {
-            throw logic_error("Ensemble has not been fitted");
+            throw std::logic_error("Ensemble has not been fitted");
        }
        auto y_pred = predict(X);
        int correct = 0;
@@ -97,20 +96,20 @@ namespace bayesnet {
        }
        return (double)correct / y_pred.size();
    }
-    vector<string> Ensemble::show() const
+    std::vector<std::string> Ensemble::show() const
    {
-        auto result = vector<string>();
+        auto result = std::vector<std::string>();
        for (auto i = 0; i < n_models; ++i) {
            auto res = models[i]->show();
            result.insert(result.end(), res.begin(), res.end());
        }
        return result;
    }
-    vector<string> Ensemble::graph(const string& title) const
+    std::vector<std::string> Ensemble::graph(const std::string& title) const
    {
-        auto result = vector<string>();
+        auto result = std::vector<std::string>();
        for (auto i = 0; i < n_models; ++i) {
-            auto res = models[i]->graph(title + "_" + to_string(i));
+            auto res = models[i]->graph(title + "_" + std::to_string(i));
            result.insert(result.end(), res.begin(), res.end());
        }
        return result;
--- a/src/BayesNet/Ensemble.h
+++ b/src/BayesNet/Ensemble.h
@@ -4,34 +4,32 @@
 #include "Classifier.h"
 #include "BayesMetrics.h"
 #include "bayesnetUtils.h"
-using namespace std;
-using namespace torch;

 namespace bayesnet {
    class Ensemble : public Classifier {
    private:
-        Ensemble& build(vector<string>& features, string className, map<string, vector<int>>& states);
+        Ensemble& build(std::vector<std::string>& features, std::string className, std::map<std::string, std::vector<int>>& states);
    protected:
        unsigned n_models;
-        vector<unique_ptr<Classifier>> models;
-        vector<double> significanceModels;
+        std::vector<std::unique_ptr<Classifier>> models;
+        std::vector<double> significanceModels;
        void trainModel(const torch::Tensor& weights) override;
-        vector<int> voting(Tensor& y_pred);
+        std::vector<int> voting(torch::Tensor& y_pred);
    public:
        Ensemble();
        virtual ~Ensemble() = default;
-        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;
+        torch::Tensor predict(torch::Tensor& X) override;
+        std::vector<int> predict(std::vector<std::vector<int>>& X) override;
+        float score(torch::Tensor& X, torch::Tensor& y) override;
+        float score(std::vector<std::vector<int>>& X, std::vector<int>& y) 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
+        std::vector<std::string> show() const override;
+        std::vector<std::string> graph(const std::string& title) const override;
+        std::vector<std::string> topological_order()  override
        {
-            return vector<string>();
+            return std::vector<std::string>();
        }
        void dump_cpt() const override
        {
--- a/src/BayesNet/FCBF.cc
+++ b/src/BayesNet/FCBF.cc
@@ -2,7 +2,7 @@
 #include "FCBF.h"
 namespace bayesnet {

-    FCBF::FCBF(const torch::Tensor& samples, const vector<string>& features, const string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights, const double threshold) :
+    FCBF::FCBF(const torch::Tensor& samples, const std::vector<std::string>& features, const std::string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights, const double threshold) :
        FeatureSelect(samples, features, className, maxFeatures, classNumStates, weights), threshold(threshold)
    {
        if (threshold < 1e-7) {
--- a/src/BayesNet/FCBF.h
+++ b/src/BayesNet/FCBF.h
@@ -3,12 +3,11 @@
 #include <torch/torch.h>
 #include <vector>
 #include "FeatureSelect.h"
-using namespace std;
 namespace bayesnet {
    class FCBF : public FeatureSelect {
    public:
-        // dataset is a n+1xm tensor of integers where dataset[-1] is the y vector
-        FCBF(const torch::Tensor& samples, const vector<string>& features, const string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights, const double threshold);
+        // dataset is a n+1xm tensor of integers where dataset[-1] is the y std::vector
+        FCBF(const torch::Tensor& samples, const std::vector<std::string>& features, const std::string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights, const double threshold);
        virtual ~FCBF() {};
        void fit() override;
    private:
--- a/src/BayesNet/FeatureSelect.cc
+++ b/src/BayesNet/FeatureSelect.cc
@@ -2,7 +2,7 @@
 #include <limits>
 #include "bayesnetUtils.h"
 namespace bayesnet {
-    FeatureSelect::FeatureSelect(const torch::Tensor& samples, const vector<string>& features, const string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights) :
+    FeatureSelect::FeatureSelect(const torch::Tensor& samples, const std::vector<std::string>& features, const std::string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights) :
        Metrics(samples, features, className, classNumStates), maxFeatures(maxFeatures == 0 ? samples.size(0) - 1 : maxFeatures), weights(weights)

    {
@@ -42,7 +42,7 @@ namespace bayesnet {
        try {
            return suFeatures.at({ firstFeature, secondFeature });
        }
-        catch (const out_of_range& e) {
+        catch (const std::out_of_range& e) {
            double result = symmetricalUncertainty(firstFeature, secondFeature);
            suFeatures[{firstFeature, secondFeature}] = result;
            return result;
@@ -62,17 +62,17 @@ namespace bayesnet {
        }
        return rcf / sqrt(n + (n * n - n) * rff);
    }
-    vector<int> FeatureSelect::getFeatures() const
+    std::vector<int> FeatureSelect::getFeatures() const
    {
        if (!fitted) {
-            throw runtime_error("FeatureSelect not fitted");
+            throw std::runtime_error("FeatureSelect not fitted");
        }
        return selectedFeatures;
    }
-    vector<double> FeatureSelect::getScores() const
+    std::vector<double> FeatureSelect::getScores() const
    {
        if (!fitted) {
-            throw runtime_error("FeatureSelect not fitted");
+            throw std::runtime_error("FeatureSelect not fitted");
        }
        return selectedScores;
    }
--- a/src/BayesNet/FeatureSelect.h
+++ b/src/BayesNet/FeatureSelect.h
@@ -3,16 +3,15 @@
 #include <torch/torch.h>
 #include <vector>
 #include "BayesMetrics.h"
-using namespace std;
 namespace bayesnet {
    class FeatureSelect : public Metrics {
    public:
-        // dataset is a n+1xm tensor of integers where dataset[-1] is the y vector
-        FeatureSelect(const torch::Tensor& samples, const vector<string>& features, const string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights);
+        // dataset is a n+1xm tensor of integers where dataset[-1] is the y std::vector
+        FeatureSelect(const torch::Tensor& samples, const std::vector<std::string>& features, const std::string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights);
        virtual ~FeatureSelect() {};
        virtual void fit() = 0;
-        vector<int> getFeatures() const;
-        vector<double> getScores() const;
+        std::vector<int> getFeatures() const;
+        std::vector<double> getScores() const;
    protected:
        void initialize();
        void computeSuLabels();
@@ -21,10 +20,10 @@ namespace bayesnet {
        double computeMeritCFS();
        const torch::Tensor& weights;
        int maxFeatures;
-        vector<int> selectedFeatures;
-        vector<double> selectedScores;
-        vector<double> suLabels;
-        map<pair<int, int>, double> suFeatures;
+        std::vector<int> selectedFeatures;
+        std::vector<double> selectedScores;
+        std::vector<double> suLabels;
+        std::map<std::pair<int, int>, double> suFeatures;
        bool fitted = false;
    };
 }
--- a/src/BayesNet/IWSS.cc
+++ b/src/BayesNet/IWSS.cc
@@ -2,7 +2,7 @@
 #include <limits>
 #include "bayesnetUtils.h"
 namespace bayesnet {
-    IWSS::IWSS(const torch::Tensor& samples, const vector<string>& features, const string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights, const double threshold) :
+    IWSS::IWSS(const torch::Tensor& samples, const std::vector<std::string>& features, const std::string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights, const double threshold) :
        FeatureSelect(samples, features, className, maxFeatures, classNumStates, weights), threshold(threshold)
    {
        if (threshold < 0 || threshold > .5) {
--- a/src/BayesNet/IWSS.h
+++ b/src/BayesNet/IWSS.h
@@ -3,12 +3,11 @@
 #include <torch/torch.h>
 #include <vector>
 #include "FeatureSelect.h"
-using namespace std;
 namespace bayesnet {
    class IWSS : public FeatureSelect {
    public:
-        // dataset is a n+1xm tensor of integers where dataset[-1] is the y vector
-        IWSS(const torch::Tensor& samples, const vector<string>& features, const string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights, const double threshold);
+        // dataset is a n+1xm tensor of integers where dataset[-1] is the y std::vector
+        IWSS(const torch::Tensor& samples, const std::vector<std::string>& features, const std::string& className, const int maxFeatures, const int classNumStates, const torch::Tensor& weights, const double threshold);
        virtual ~IWSS() {};
        void fit() override;
    private:
--- a/src/BayesNet/KDB.cc
+++ b/src/BayesNet/KDB.cc
@@ -1,14 +1,13 @@
 #include "KDB.h"

 namespace bayesnet {
-    using namespace torch;
-
-    KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta) {}
-    void KDB::setHyperparameters(nlohmann::json& hyperparameters)
+    KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta)
+    {
+        validHyperparameters = { "k", "theta" };
+
+    }
+    void KDB::setHyperparameters(const nlohmann::json& hyperparameters)
    {
-        // Check if hyperparameters are valid
-        const vector<string> validKeys = { "k", "theta" };
-        checkHyperparameters(validKeys, hyperparameters);
        if (hyperparameters.contains("k")) {
            k = hyperparameters["k"];
        }
@@ -40,16 +39,16 @@ 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<double> mi;
+        const torch::Tensor& y = dataset.index({ -1, "..." });
+        std::vector<double> mi;
        for (auto i = 0; i < features.size(); i++) {
-            Tensor firstFeature = dataset.index({ i, "..." });
+            torch::Tensor firstFeature = dataset.index({ i, "..." });
            mi.push_back(metrics.mutualInformation(firstFeature, y, weights));
        }
        // 2. Compute class conditional mutual information I(Xi;XjIC), f or each
        auto conditionalEdgeWeights = metrics.conditionalEdge(weights);
        // 3. Let the used variable list, S, be empty.
-        vector<int> S;
+        std::vector<int> S;
        // 4. Let the DAG network being constructed, BN, begin with a single
        // class node, C.
        // 5. Repeat until S includes all domain features
@@ -67,9 +66,9 @@ namespace bayesnet {
            S.push_back(idx);
        }
    }
-    void KDB::add_m_edges(int idx, vector<int>& S, Tensor& weights)
+    void KDB::add_m_edges(int idx, std::vector<int>& S, torch::Tensor& weights)
    {
-        auto n_edges = min(k, static_cast<int>(S.size()));
+        auto n_edges = std::min(k, static_cast<int>(S.size()));
        auto cond_w = clone(weights);
        bool exit_cond = k == 0;
        int num = 0;
@@ -81,7 +80,7 @@ namespace bayesnet {
                    model.addEdge(features[max_minfo], features[idx]);
                    num++;
                }
-                catch (const invalid_argument& e) {
+                catch (const std::invalid_argument& e) {
                    // Loops are not allowed
                }
            }
@@ -91,11 +90,11 @@ namespace bayesnet {
            exit_cond = num == n_edges || candidates.size(0) == 0;
        }
    }
-    vector<string> KDB::graph(const string& title) const
+    std::vector<std::string> KDB::graph(const std::string& title) const
    {
-        string header{ title };
+        std::string header{ title };
        if (title == "KDB") {
-            header += " (k=" + to_string(k) + ", theta=" + to_string(theta) + ")";
+            header += " (k=" + std::to_string(k) + ", theta=" + std::to_string(theta) + ")";
        }
        return model.graph(header);
    }
--- a/src/BayesNet/KDB.h
+++ b/src/BayesNet/KDB.h
@@ -4,20 +4,18 @@
 #include "Classifier.h"
 #include "bayesnetUtils.h"
 namespace bayesnet {
-    using namespace std;
-    using namespace torch;
    class KDB : public Classifier {
    private:
        int k;
        float theta;
-        void add_m_edges(int idx, vector<int>& S, Tensor& weights);
+        void add_m_edges(int idx, std::vector<int>& S, torch::Tensor& weights);
    protected:
        void buildModel(const torch::Tensor& weights) override;
    public:
        explicit KDB(int k, float theta = 0.03);
-        virtual ~KDB() {};
-        void setHyperparameters(nlohmann::json& hyperparameters) override;
-        vector<string> graph(const string& name = "KDB") const override;
+        virtual ~KDB() = default;
+        void setHyperparameters(const nlohmann::json& hyperparameters) override;
+        std::vector<std::string> graph(const std::string& name = "KDB") const override;
    };
 }
 #endif
--- a/src/BayesNet/KDBLd.cc
+++ b/src/BayesNet/KDBLd.cc
@@ -1,16 +1,15 @@
 #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_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
+    KDBLd& KDBLd::fit(torch::Tensor& X_, torch::Tensor& y_, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_)
    {
        checkInput(X_, y_);
        features = features_;
        className = className_;
        Xf = X_;
        y = y_;
-        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        // Fills std::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
@@ -18,12 +17,12 @@ namespace bayesnet {
        states = localDiscretizationProposal(states, model);
        return *this;
    }
-    Tensor KDBLd::predict(Tensor& X)
+    torch::Tensor KDBLd::predict(torch::Tensor& X)
    {
        auto Xt = prepareX(X);
        return KDB::predict(Xt);
    }
-    vector<string> KDBLd::graph(const string& name) const
+    std::vector<std::string> KDBLd::graph(const std::string& name) const
    {
        return KDB::graph(name);
    }
--- a/src/BayesNet/KDBLd.h
+++ b/src/BayesNet/KDBLd.h
@@ -4,16 +4,15 @@
 #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, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        vector<string> graph(const string& name = "KDB") const override;
-        Tensor predict(Tensor& X) override;
-        static inline string version() { return "0.0.1"; };
+        KDBLd& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, map<std::string, std::vector<int>>& states) override;
+        std::vector<std::string> graph(const std::string& name = "KDB") const override;
+        torch::Tensor predict(torch::Tensor& X) override;
+        static inline std::string version() { return "0.0.1"; };
    };
 }
 #endif // !KDBLD_H
--- a/src/BayesNet/Mst.cc
+++ b/src/BayesNet/Mst.cc
@@ -7,8 +7,7 @@
 */

 namespace bayesnet {
-    using namespace std;
-    Graph::Graph(int V) : V(V), parent(vector<int>(V))
+    Graph::Graph(int V) : V(V), parent(std::vector<int>(V))
    {
        for (int i = 0; i < V; i++)
            parent[i] = i;
@@ -41,35 +40,35 @@ namespace bayesnet {
            uSt = find_set(G[i].second.first);
            vEd = find_set(G[i].second.second);
            if (uSt != vEd) {
-                T.push_back(G[i]); // add to mst vector
+                T.push_back(G[i]); // add to mst std::vector
                union_set(uSt, vEd);
            }
        }
    }
    void Graph::display_mst()
    {
-        cout << "Edge :" << " Weight" << endl;
+        std::cout << "Edge :" << " Weight" << std::endl;
        for (int i = 0; i < T.size(); i++) {
-            cout << T[i].second.first << " - " << T[i].second.second << " : "
+            std::cout << T[i].second.first << " - " << T[i].second.second << " : "
                << T[i].first;
-            cout << endl;
+            std::cout << std::endl;
        }
    }

-    void insertElement(list<int>& variables, int variable)
+    void insertElement(std::list<int>& variables, int variable)
    {
-        if (find(variables.begin(), variables.end(), variable) == variables.end()) {
+        if (std::find(variables.begin(), variables.end(), variable) == variables.end()) {
            variables.push_front(variable);
        }
    }

-    vector<pair<int, int>> reorder(vector<pair<float, pair<int, int>>> T, int root_original)
+    std::vector<std::pair<int, int>> reorder(std::vector<std::pair<float, std::pair<int, int>>> T, int root_original)
    {
        // Create the edges of a DAG from the MST
        // replacing unordered_set with list because unordered_set cannot guarantee the order of the elements inserted
-        auto result = vector<pair<int, int>>();
-        auto visited = vector<int>();
-        auto nextVariables = list<int>();
+        auto result = std::vector<std::pair<int, int>>();
+        auto visited = std::vector<int>();
+        auto nextVariables = std::list<int>();
        nextVariables.push_front(root_original);
        while (nextVariables.size() > 0) {
            int root = nextVariables.front();
@@ -104,8 +103,8 @@ namespace bayesnet {
        return result;
    }

-    MST::MST(const vector<string>& features, const Tensor& weights, const int root) : features(features), weights(weights), root(root) {}
-    vector<pair<int, int>> MST::maximumSpanningTree()
+    MST::MST(const std::vector<std::string>& features, const torch::Tensor& weights, const int root) : features(features), weights(weights), root(root) {}
+    std::vector<std::pair<int, int>> MST::maximumSpanningTree()
    {
        auto num_features = features.size();
        Graph g(num_features);
--- a/src/BayesNet/Mst.h
+++ b/src/BayesNet/Mst.h
@@ -4,24 +4,22 @@
 #include <vector>
 #include <string>
 namespace bayesnet {
-    using namespace std;
-    using namespace torch;
    class MST {
    private:
-        Tensor weights;
-        vector<string> features;
+        torch::Tensor weights;
+        std::vector<std::string> features;
        int root = 0;
    public:
        MST() = default;
-        MST(const vector<string>& features, const Tensor& weights, const int root);
-        vector<pair<int, int>> maximumSpanningTree();
+        MST(const std::vector<std::string>& features, const torch::Tensor& weights, const int root);
+        std::vector<std::pair<int, int>> maximumSpanningTree();
    };
    class Graph {
    private:
        int V;      // number of nodes in graph
-        vector <pair<float, pair<int, int>>> G; // vector for graph
-        vector <pair<float, pair<int, int>>> T; // vector for mst
-        vector<int> parent;
+        std::vector <std::pair<float, std::pair<int, int>>> G; // std::vector for graph
+        std::vector <std::pair<float, std::pair<int, int>>> T; // std::vector for mst
+        std::vector<int> parent;
    public:
        explicit Graph(int V);
        void addEdge(int u, int v, float wt);
@@ -29,7 +27,7 @@ namespace bayesnet {
        void union_set(int u, int v);
        void kruskal_algorithm();
        void display_mst();
-        vector <pair<float, pair<int, int>>> get_mst() { return T; }
+        std::vector <std::pair<float, std::pair<int, int>>> get_mst() { return T; }
    };
 }
 #endif
--- a/src/BayesNet/Network.cc
+++ b/src/BayesNet/Network.cc
@@ -3,18 +3,18 @@
 #include "Network.h"
 #include "bayesnetUtils.h"
 namespace bayesnet {
-    Network::Network() : features(vector<string>()), className(""), classNumStates(0), fitted(false), laplaceSmoothing(0) {}
-    Network::Network(float maxT) : features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false), laplaceSmoothing(0) {}
+    Network::Network() : features(std::vector<std::string>()), className(""), classNumStates(0), fitted(false), laplaceSmoothing(0) {}
+    Network::Network(float maxT) : features(std::vector<std::string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false), laplaceSmoothing(0) {}
    Network::Network(Network& other) : laplaceSmoothing(other.laplaceSmoothing), features(other.features), className(other.className), classNumStates(other.getClassNumStates()), maxThreads(other.
        getmaxThreads()), fitted(other.fitted)
    {
-        for (const auto& pair : other.nodes) {
-            nodes[pair.first] = std::make_unique<Node>(*pair.second);
+        for (const auto& node : other.nodes) {
+            nodes[node.first] = std::make_unique<Node>(*node.second);
        }
    }
    void Network::initialize()
    {
-        features = vector<string>();
+        features = std::vector<std::string>();
        className = "";
        classNumStates = 0;
        fitted = false;
@@ -29,10 +29,10 @@ namespace bayesnet {
    {
        return samples;
    }
-    void Network::addNode(const string& name)
+    void Network::addNode(const std::string& name)
    {
        if (name == "") {
-            throw invalid_argument("Node name cannot be empty");
+            throw std::invalid_argument("Node name cannot be empty");
        }
        if (nodes.find(name) != nodes.end()) {
            return;
@@ -42,7 +42,7 @@ namespace bayesnet {
        }
        nodes[name] = std::make_unique<Node>(name);
    }
-    vector<string> Network::getFeatures() const
+    std::vector<std::string> Network::getFeatures() const
    {
        return features;
    }
@@ -58,11 +58,11 @@ namespace bayesnet {
        }
        return result;
    }
-    string Network::getClassName() const
+    std::string Network::getClassName() const
    {
        return className;
    }
-    bool Network::isCyclic(const string& nodeId, unordered_set<string>& visited, unordered_set<string>& recStack)
+    bool Network::isCyclic(const std::string& nodeId, std::unordered_set<std::string>& visited, std::unordered_set<std::string>& recStack)
    {
        if (visited.find(nodeId) == visited.end()) // if node hasn't been visited yet
        {
@@ -78,78 +78,78 @@ namespace bayesnet {
        recStack.erase(nodeId); // remove node from recursion stack before function ends
        return false;
    }
-    void Network::addEdge(const string& parent, const string& child)
+    void Network::addEdge(const std::string& parent, const std::string& child)
    {
        if (nodes.find(parent) == nodes.end()) {
-            throw invalid_argument("Parent node " + parent + " does not exist");
+            throw std::invalid_argument("Parent node " + parent + " does not exist");
        }
        if (nodes.find(child) == nodes.end()) {
-            throw invalid_argument("Child node " + child + " does not exist");
+            throw std::invalid_argument("Child node " + child + " does not exist");
        }
        // Temporarily add edge to check for cycles
        nodes[parent]->addChild(nodes[child].get());
        nodes[child]->addParent(nodes[parent].get());
-        unordered_set<string> visited;
-        unordered_set<string> recStack;
+        std::unordered_set<std::string> visited;
+        std::unordered_set<std::string> recStack;
        if (isCyclic(nodes[child]->getName(), visited, recStack)) // if adding this edge forms a cycle
        {
            // remove problematic edge
            nodes[parent]->removeChild(nodes[child].get());
            nodes[child]->removeParent(nodes[parent].get());
-            throw invalid_argument("Adding this edge forms a cycle in the graph.");
+            throw std::invalid_argument("Adding this edge forms a cycle in the graph.");
        }
    }
-    map<string, std::unique_ptr<Node>>& Network::getNodes()
+    std::map<std::string, std::unique_ptr<Node>>& Network::getNodes()
    {
        return nodes;
    }
-    void Network::checkFitData(int n_samples, int n_features, int n_samples_y, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states, const torch::Tensor& weights)
+    void Network::checkFitData(int n_samples, int n_features, int n_samples_y, const std::vector<std::string>& featureNames, const std::string& className, const std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights)
    {
        if (weights.size(0) != n_samples) {
-            throw invalid_argument("Weights (" + to_string(weights.size(0)) + ") must have the same number of elements as samples (" + to_string(n_samples) + ") in Network::fit");
+            throw std::invalid_argument("Weights (" + std::to_string(weights.size(0)) + ") must have the same number of elements as samples (" + std::to_string(n_samples) + ") in Network::fit");
        }
        if (n_samples != n_samples_y) {
-            throw invalid_argument("X and y must have the same number of samples in Network::fit (" + to_string(n_samples) + " != " + to_string(n_samples_y) + ")");
+            throw std::invalid_argument("X and y must have the same number of samples in Network::fit (" + std::to_string(n_samples) + " != " + std::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()) + ")");
+            throw std::invalid_argument("X and features must have the same number of features in Network::fit (" + std::to_string(n_features) + " != " + std::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) + ")");
+            throw std::invalid_argument("X and local features must have the same number of features in Network::fit (" + std::to_string(n_features) + " != " + std::to_string(features.size() - 1) + ")");
        }
        if (find(features.begin(), features.end(), className) == features.end()) {
-            throw invalid_argument("className not found in Network::features");
+            throw std::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");
+                throw std::invalid_argument("Feature " + feature + " not found in Network::features");
            }
            if (states.find(feature) == states.end()) {
-                throw invalid_argument("Feature " + feature + " not found in states");
+                throw std::invalid_argument("Feature " + feature + " not found in states");
            }
        }
    }
-    void Network::setStates(const map<string, vector<int>>& states)
+    void Network::setStates(const std::map<std::string, std::vector<int>>& states)
    {
        // Set states to every Node in the network
-        for_each(features.begin(), features.end(), [this, &states](const string& feature) {
+        for_each(features.begin(), features.end(), [this, &states](const std::string& feature) {
            nodes.at(feature)->setNumStates(states.at(feature).size());
            });
        classNumStates = nodes.at(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 torch::Tensor& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
+    void Network::fit(const torch::Tensor& X, const torch::Tensor& y, const torch::Tensor& weights, const std::vector<std::string>& featureNames, const std::string& className, const std::map<std::string, std::vector<int>>& states)
    {
        checkFitData(X.size(1), X.size(0), y.size(0), featureNames, className, states, weights);
        this->className = className;
-        Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1);
+        torch::Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1);
        samples = torch::cat({ X , ytmp }, 0);
        for (int i = 0; i < featureNames.size(); ++i) {
            auto row_feature = X.index({ i, "..." });
        }
        completeFit(states, weights);
    }
-    void Network::fit(const torch::Tensor& samples, const torch::Tensor& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
+    void Network::fit(const torch::Tensor& samples, const torch::Tensor& weights, const std::vector<std::string>& featureNames, const std::string& className, const std::map<std::string, std::vector<int>>& states)
    {
        checkFitData(samples.size(1), samples.size(0) - 1, samples.size(1), featureNames, className, states, weights);
        this->className = className;
@@ -157,7 +157,7 @@ namespace bayesnet {
        completeFit(states, weights);
    }
    // input_data comes in nxm, where n is the number of features and m the number of samples
-    void Network::fit(const vector<vector<int>>& input_data, const vector<int>& labels, const vector<double>& weights_, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
+    void Network::fit(const std::vector<std::vector<int>>& input_data, const std::vector<int>& labels, const std::vector<double>& weights_, const std::vector<std::string>& featureNames, const std::string& className, const std::map<std::string, std::vector<int>>& states)
    {
        const torch::Tensor weights = torch::tensor(weights_, torch::kFloat64);
        checkFitData(input_data[0].size(), input_data.size(), labels.size(), featureNames, className, states, weights);
@@ -170,11 +170,11 @@ namespace bayesnet {
        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
        completeFit(states, weights);
    }
-    void Network::completeFit(const map<string, vector<int>>& states, const torch::Tensor& weights)
+    void Network::completeFit(const std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights)
    {
        setStates(states);
        laplaceSmoothing = 1.0 / samples.size(1); // To use in CPT computation
-        vector<thread> threads;
+        std::vector<std::thread> threads;
        for (auto& node : nodes) {
            threads.emplace_back([this, &node, &weights]() {
                node.second->computeCPT(samples, features, laplaceSmoothing, weights);
@@ -188,12 +188,12 @@ namespace bayesnet {
    torch::Tensor Network::predict_tensor(const torch::Tensor& samples, const bool proba)
    {
        if (!fitted) {
-            throw logic_error("You must call fit() before calling predict()");
+            throw std::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 });
+            const torch::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));
@@ -204,32 +204,32 @@ namespace bayesnet {
        return result.argmax(1);
    }
    // Return mxn tensor of probabilities
-    Tensor Network::predict_proba(const Tensor& samples)
+    torch::Tensor Network::predict_proba(const torch::Tensor& samples)
    {
        return predict_tensor(samples, true);
    }

    // Return mxn tensor of probabilities
-    Tensor Network::predict(const Tensor& samples)
+    torch::Tensor Network::predict(const torch::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)
+    // Return mx1 std::vector of predictions
+    // tsamples is nxm std::vector of samples
+    std::vector<int> Network::predict(const std::vector<std::vector<int>>& tsamples)
    {
        if (!fitted) {
-            throw logic_error("You must call fit() before calling predict()");
+            throw std::logic_error("You must call fit() before calling predict()");
        }
-        vector<int> predictions;
-        vector<int> sample;
+        std::vector<int> predictions;
+        std::vector<int> sample;
        for (int row = 0; row < tsamples[0].size(); ++row) {
            sample.clear();
            for (int col = 0; col < tsamples.size(); ++col) {
                sample.push_back(tsamples[col][row]);
            }
-            vector<double> classProbabilities = predict_sample(sample);
+            std::vector<double> classProbabilities = predict_sample(sample);
            // Find the class with the maximum posterior probability
            auto maxElem = max_element(classProbabilities.begin(), classProbabilities.end());
            int predictedClass = distance(classProbabilities.begin(), maxElem);
@@ -237,14 +237,14 @@ namespace bayesnet {
        }
        return predictions;
    }
-    // Return mxn vector of probabilities
-    vector<vector<double>> Network::predict_proba(const vector<vector<int>>& tsamples)
+    // Return mxn std::vector of probabilities
+    std::vector<std::vector<double>> Network::predict_proba(const std::vector<std::vector<int>>& tsamples)
    {
        if (!fitted) {
-            throw logic_error("You must call fit() before calling predict_proba()");
+            throw std::logic_error("You must call fit() before calling predict_proba()");
        }
-        vector<vector<double>> predictions;
-        vector<int> sample;
+        std::vector<std::vector<double>> predictions;
+        std::vector<int> sample;
        for (int row = 0; row < tsamples[0].size(); ++row) {
            sample.clear();
            for (int col = 0; col < tsamples.size(); ++col) {
@@ -254,9 +254,9 @@ namespace bayesnet {
        }
        return predictions;
    }
-    double Network::score(const vector<vector<int>>& tsamples, const vector<int>& labels)
+    double Network::score(const std::vector<std::vector<int>>& tsamples, const std::vector<int>& labels)
    {
-        vector<int> y_pred = predict(tsamples);
+        std::vector<int> y_pred = predict(tsamples);
        int correct = 0;
        for (int i = 0; i < y_pred.size(); ++i) {
            if (y_pred[i] == labels[i]) {
@@ -265,35 +265,35 @@ namespace bayesnet {
        }
        return (double)correct / y_pred.size();
    }
-    // Return 1xn vector of probabilities
-    vector<double> Network::predict_sample(const vector<int>& sample)
+    // Return 1xn std::vector of probabilities
+    std::vector<double> Network::predict_sample(const std::vector<int>& sample)
    {
        // Ensure the sample size is equal to the number of features
        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() - 1) + ")");
+            throw std::invalid_argument("Sample size (" + std::to_string(sample.size()) +
+                ") does not match the number of features (" + std::to_string(features.size() - 1) + ")");
        }
-        map<string, int> evidence;
+        std::map<std::string, int> evidence;
        for (int i = 0; i < sample.size(); ++i) {
            evidence[features[i]] = sample[i];
        }
        return exactInference(evidence);
    }
-    // Return 1xn vector of probabilities
-    vector<double> Network::predict_sample(const Tensor& sample)
+    // Return 1xn std::vector of probabilities
+    std::vector<double> Network::predict_sample(const torch::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) + ")");
+            throw std::invalid_argument("Sample size (" + std::to_string(sample.size(0)) +
+                ") does not match the number of features (" + std::to_string(features.size() - 1) + ")");
        }
-        map<string, int> evidence;
+        std::map<std::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 Network::computeFactor(std::map<std::string, int>& completeEvidence)
    {
        double result = 1.0;
        for (auto& node : getNodes()) {
@@ -301,17 +301,17 @@ namespace bayesnet {
        }
        return result;
    }
-    vector<double> Network::exactInference(map<string, int>& evidence)
+    std::vector<double> Network::exactInference(std::map<std::string, int>& evidence)
    {
-        vector<double> result(classNumStates, 0.0);
-        vector<thread> threads;
-        mutex mtx;
+        std::vector<double> result(classNumStates, 0.0);
+        std::vector<std::thread> threads;
+        std::mutex mtx;
        for (int i = 0; i < classNumStates; ++i) {
            threads.emplace_back([this, &result, &evidence, i, &mtx]() {
-                auto completeEvidence = map<string, int>(evidence);
+                auto completeEvidence = std::map<std::string, int>(evidence);
                completeEvidence[getClassName()] = i;
                double factor = computeFactor(completeEvidence);
-                lock_guard<mutex> lock(mtx);
+                std::lock_guard<std::mutex> lock(mtx);
                result[i] = factor;
                });
        }
@@ -323,12 +323,12 @@ namespace bayesnet {
        transform(result.begin(), result.end(), result.begin(), [sum](const double& value) { return value / sum; });
        return result;
    }
-    vector<string> Network::show() const
+    std::vector<std::string> Network::show() const
    {
-        vector<string> result;
+        std::vector<std::string> result;
        // Draw the network
        for (auto& node : nodes) {
-            string line = node.first + " -> ";
+            std::string line = node.first + " -> ";
            for (auto child : node.second->getChildren()) {
                line += child->getName() + ", ";
            }
@@ -336,12 +336,12 @@ namespace bayesnet {
        }
        return result;
    }
-    vector<string> Network::graph(const string& title) const
+    std::vector<std::string> Network::graph(const std::string& title) const
    {
-        auto output = vector<string>();
+        auto output = std::vector<std::string>();
        auto prefix = "digraph BayesNet {\nlabel=<BayesNet ";
        auto suffix = ">\nfontsize=30\nfontcolor=blue\nlabelloc=t\nlayout=circo\n";
-        string header = prefix + title + suffix;
+        std::string header = prefix + title + suffix;
        output.push_back(header);
        for (auto& node : nodes) {
            auto result = node.second->graph(className);
@@ -350,9 +350,9 @@ namespace bayesnet {
        output.push_back("}\n");
        return output;
    }
-    vector<pair<string, string>> Network::getEdges() const
+    std::vector<std::pair<std::string, std::string>> Network::getEdges() const
    {
-        auto edges = vector<pair<string, string>>();
+        auto edges = std::vector<std::pair<std::string, std::string>>();
        for (const auto& node : nodes) {
            auto head = node.first;
            for (const auto& child : node.second->getChildren()) {
@@ -366,7 +366,7 @@ namespace bayesnet {
    {
        return getEdges().size();
    }
-    vector<string> Network::topological_sort()
+    std::vector<std::string> Network::topological_sort()
    {
        /* Check if al the fathers of every node are before the node */
        auto result = features;
@@ -393,10 +393,10 @@ namespace bayesnet {
                                ending = false;
                            }
                        } else {
-                            throw logic_error("Error in topological sort because of node " + feature + " is not in result");
+                            throw std::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");
+                        throw std::logic_error("Error in topological sort because of node father " + fatherName + " is not in result");
                    }
                }
            }
@@ -406,8 +406,8 @@ namespace bayesnet {
    void Network::dump_cpt() const
    {
        for (auto& node : nodes) {
-            cout << "* " << node.first << ": (" << node.second->getNumStates() << ") : " << node.second->getCPT().sizes() << endl;
-            cout << node.second->getCPT() << endl;
+            std::cout << "* " << node.first << ": (" << node.second->getNumStates() << ") : " << node.second->getCPT().sizes() << std::endl;
+            std::cout << node.second->getCPT() << std::endl;
        }
    }
 }
--- a/src/BayesNet/Network.h
+++ b/src/BayesNet/Network.h
@@ -7,22 +7,22 @@
 namespace bayesnet {
    class Network {
    private:
-        map<string, unique_ptr<Node>> nodes;
+        std::map<std::string, std::unique_ptr<Node>> nodes;
        bool fitted;
        float maxThreads = 0.95;
        int classNumStates;
-        vector<string> features; // Including classname
-        string className;
+        std::vector<std::string> features; // Including classname
+        std::string className;
        double laplaceSmoothing;
        torch::Tensor samples; // nxm tensor used to fit the model
        bool isCyclic(const std::string&, std::unordered_set<std::string>&, std::unordered_set<std::string>&);
-        vector<double> predict_sample(const vector<int>&);
-        vector<double> predict_sample(const torch::Tensor&);
-        vector<double> exactInference(map<string, int>&);
-        double computeFactor(map<string, int>&);
-        void completeFit(const map<string, vector<int>>& states, const torch::Tensor& weights);
-        void checkFitData(int n_features, int n_samples, int n_samples_y, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states, const torch::Tensor& weights);
-        void setStates(const map<string, vector<int>>&);
+        std::vector<double> predict_sample(const std::vector<int>&);
+        std::vector<double> predict_sample(const torch::Tensor&);
+        std::vector<double> exactInference(std::map<std::string, int>&);
+        double computeFactor(std::map<std::string, int>&);
+        void completeFit(const std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights);
+        void checkFitData(int n_features, int n_samples, int n_samples_y, const std::vector<std::string>& featureNames, const std::string& className, const std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights);
+        void setStates(const std::map<std::string, std::vector<int>>&);
    public:
        Network();
        explicit Network(float);
@@ -30,33 +30,33 @@ namespace bayesnet {
        ~Network() = default;
        torch::Tensor& getSamples();
        float getmaxThreads();
-        void addNode(const string&);
-        void addEdge(const string&, const string&);
-        map<string, std::unique_ptr<Node>>& getNodes();
-        vector<string> getFeatures() const;
+        void addNode(const std::string&);
+        void addEdge(const std::string&, const std::string&);
+        std::map<std::string, std::unique_ptr<Node>>& getNodes();
+        std::vector<std::string> getFeatures() const;
        int getStates() const;
-        vector<pair<string, string>> getEdges() const;
+        std::vector<std::pair<std::string, std::string>> getEdges() const;
        int getNumEdges() const;
        int getClassNumStates() const;
-        string getClassName() const;
+        std::string getClassName() const;
        /*
        Notice: Nodes have to be inserted in the same order as they are in the dataset, i.e., first node is first column and so on.
        */
-        void fit(const vector<vector<int>>& input_data, const vector<int>& labels, const vector<double>& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states);
-        void fit(const torch::Tensor& X, const torch::Tensor& y, const torch::Tensor& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states);
-        void fit(const torch::Tensor& samples, const torch::Tensor& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states);
-        vector<int> predict(const vector<vector<int>>&); // Return mx1 vector of predictions
+        void fit(const std::vector<std::vector<int>>& input_data, const std::vector<int>& labels, const std::vector<double>& weights, const std::vector<std::string>& featureNames, const std::string& className, const std::map<std::string, std::vector<int>>& states);
+        void fit(const torch::Tensor& X, const torch::Tensor& y, const torch::Tensor& weights, const std::vector<std::string>& featureNames, const std::string& className, const std::map<std::string, std::vector<int>>& states);
+        void fit(const torch::Tensor& samples, const torch::Tensor& weights, const std::vector<std::string>& featureNames, const std::string& className, const std::map<std::string, std::vector<int>>& states);
+        std::vector<int> predict(const std::vector<std::vector<int>>&); // Return mx1 std::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
+        std::vector<std::vector<double>> predict_proba(const std::vector<std::vector<int>>&); // Return mxn std::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> topological_sort();
-        vector<string> show() const;
-        vector<string> graph(const string& title) const; // Returns a vector of strings representing the graph in graphviz format
+        double score(const std::vector<std::vector<int>>&, const std::vector<int>&);
+        std::vector<std::string> topological_sort();
+        std::vector<std::string> show() const;
+        std::vector<std::string> graph(const std::string& title) const; // Returns a std::vector of std::strings representing the graph in graphviz format
        void initialize();
        void dump_cpt() const;
-        inline string version() { return "0.2.0"; }
+        inline std::string version() { return "0.2.0"; }
    };
 }
 #endif
--- a/src/BayesNet/Node.cc
+++ b/src/BayesNet/Node.cc
@@ -3,7 +3,7 @@
 namespace bayesnet {

    Node::Node(const std::string& name)
-        : name(name), numStates(0), cpTable(torch::Tensor()), parents(vector<Node*>()), children(vector<Node*>())
+        : name(name), numStates(0), cpTable(torch::Tensor()), parents(std::vector<Node*>()), children(std::vector<Node*>())
    {
    }
    void Node::clear()
@@ -14,7 +14,7 @@ namespace bayesnet {
        dimensions.clear();
        numStates = 0;
    }
-    string Node::getName() const
+    std::string Node::getName() const
    {
        return name;
    }
@@ -34,11 +34,11 @@ namespace bayesnet {
    {
        children.push_back(child);
    }
-    vector<Node*>& Node::getParents()
+    std::vector<Node*>& Node::getParents()
    {
        return parents;
    }
-    vector<Node*>& Node::getChildren()
+    std::vector<Node*>& Node::getChildren()
    {
        return children;
    }
@@ -63,28 +63,28 @@ namespace bayesnet {
    */
    unsigned Node::minFill()
    {
-        unordered_set<string> neighbors;
+        std::unordered_set<std::string> neighbors;
        for (auto child : children) {
            neighbors.emplace(child->getName());
        }
        for (auto parent : parents) {
            neighbors.emplace(parent->getName());
        }
-        auto source = vector<string>(neighbors.begin(), neighbors.end());
+        auto source = std::vector<std::string>(neighbors.begin(), neighbors.end());
        return combinations(source).size();
    }
-    vector<pair<string, string>> Node::combinations(const vector<string>& source)
+    std::vector<std::pair<std::string, std::string>> Node::combinations(const std::vector<std::string>& source)
    {
-        vector<pair<string, string>> result;
+        std::vector<std::pair<std::string, std::string>> result;
        for (int i = 0; i < source.size(); ++i) {
-            string temp = source[i];
+            std::string temp = source[i];
            for (int j = i + 1; j < source.size(); ++j) {
                result.push_back({ temp, source[j] });
            }
        }
        return result;
    }
-    void Node::computeCPT(const torch::Tensor& dataset, const vector<string>& features, const double laplaceSmoothing, const torch::Tensor& weights)
+    void Node::computeCPT(const torch::Tensor& dataset, const std::vector<std::string>& features, const double laplaceSmoothing, const torch::Tensor& weights)
    {
        dimensions.clear();
        // Get dimensions of the CPT
@@ -96,7 +96,7 @@ namespace bayesnet {
        // Fill table with counts
        auto pos = find(features.begin(), features.end(), name);
        if (pos == features.end()) {
-            throw logic_error("Feature " + name + " not found in dataset");
+            throw std::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) {
@@ -105,7 +105,7 @@ namespace bayesnet {
            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");
+                    throw std::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 }));
@@ -116,17 +116,17 @@ namespace bayesnet {
        // Normalize the counts
        cpTable = cpTable / cpTable.sum(0);
    }
-    float Node::getFactorValue(map<string, int>& evidence)
+    float Node::getFactorValue(std::map<std::string, int>& evidence)
    {
        c10::List<c10::optional<at::Tensor>> coordinates;
        // following predetermined order of indices in the cpTable (see Node.h)
        coordinates.push_back(at::tensor(evidence[name]));
-        transform(parents.begin(), parents.end(), back_inserter(coordinates), [&evidence](const auto& parent) { return at::tensor(evidence[parent->getName()]); });
+        transform(parents.begin(), parents.end(), std::back_inserter(coordinates), [&evidence](const auto& parent) { return at::tensor(evidence[parent->getName()]); });
        return cpTable.index({ coordinates }).item<float>();
    }
-    vector<string> Node::graph(const string& className)
+    std::vector<std::string> Node::graph(const std::string& className)
    {
-        auto output = vector<string>();
+        auto output = std::vector<std::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](const auto& child) { return name + " -> " + child->getName(); });
--- a/src/BayesNet/Node.h
+++ b/src/BayesNet/Node.h
@@ -5,33 +5,32 @@
 #include <vector>
 #include <string>
 namespace bayesnet {
-    using namespace std;
    class Node {
    private:
-        string name;
-        vector<Node*> parents;
-        vector<Node*> children;
+        std::string name;
+        std::vector<Node*> parents;
+        std::vector<Node*> children;
        int numStates; // number of states of the variable
        torch::Tensor cpTable; // Order of indices is 0-> node variable, 1-> 1st parent, 2-> 2nd parent, ...
-        vector<int64_t> dimensions; // dimensions of the cpTable
-        vector<pair<string, string>> combinations(const vector<string>&);
+        std::vector<int64_t> dimensions; // dimensions of the cpTable
+        std::vector<std::pair<std::string, std::string>> combinations(const std::vector<std::string>&);
    public:
-        explicit Node(const string&);
+        explicit Node(const std::string&);
        void clear();
        void addParent(Node*);
        void addChild(Node*);
        void removeParent(Node*);
        void removeChild(Node*);
-        string getName() const;
-        vector<Node*>& getParents();
-        vector<Node*>& getChildren();
+        std::string getName() const;
+        std::vector<Node*>& getParents();
+        std::vector<Node*>& getChildren();
        torch::Tensor& getCPT();
-        void computeCPT(const torch::Tensor& dataset, const vector<string>& features, const double laplaceSmoothing, const torch::Tensor& weights);
+        void computeCPT(const torch::Tensor& dataset, const std::vector<std::string>& features, const double laplaceSmoothing, const torch::Tensor& weights);
        int getNumStates() const;
        void setNumStates(int);
        unsigned minFill();
-        vector<string> graph(const string& clasName); // Returns a vector of strings representing the graph in graphviz format
-        float getFactorValue(map<string, int>&);
+        std::vector<std::string> graph(const std::string& clasName); // Returns a std::vector of std::strings representing the graph in graphviz format
+        float getFactorValue(std::map<std::string, int>&);
    };
 }
 #endif
--- a/src/BayesNet/Proposal.cc
+++ b/src/BayesNet/Proposal.cc
@@ -2,7 +2,7 @@
 #include "ArffFiles.h"

 namespace bayesnet {
-    Proposal::Proposal(torch::Tensor& dataset_, vector<string>& features_, string& className_) : pDataset(dataset_), pFeatures(features_), pClassName(className_) {}
+    Proposal::Proposal(torch::Tensor& dataset_, std::vector<std::string>& features_, std::string& className_) : pDataset(dataset_), pFeatures(features_), pClassName(className_) {}
    Proposal::~Proposal()
    {
        for (auto& [key, value] : discretizers) {
@@ -18,14 +18,14 @@ namespace bayesnet {
            throw std::invalid_argument("y must be an integer tensor");
        }
    }
-    map<string, vector<int>> Proposal::localDiscretizationProposal(const map<string, vector<int>>& oldStates, Network& model)
+    map<std::string, std::vector<int>> Proposal::localDiscretizationProposal(const map<std::string, std::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;
+        map<std::string, std::vector<int>> states = oldStates;
+        std::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();
@@ -33,16 +33,16 @@ namespace bayesnet {
            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;
+            std::vector<std::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;
+            std::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));
+            std::vector<std::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>());
@@ -51,16 +51,16 @@ namespace bayesnet {
            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));
+            auto xvf = std::vector<mdlp::precision_t>(xvf_ptr, xvf_ptr + Xf.size(1));
            discretizers[feature]->fit(xvf, yxv);
        }
        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));
+                auto Xt = std::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);
+                auto xStates = std::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;
@@ -70,28 +70,28 @@ namespace bayesnet {
        }
        return states;
    }
-    map<string, vector<int>> Proposal::fit_local_discretization(const torch::Tensor& y)
+    map<std::string, std::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));
+        map<std::string, std::vector<int>> states;
+        pDataset = torch::zeros({ n + 1, m }, torch::kInt32);
+        auto yv = std::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));
+            auto Xt = std::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);
+            auto xStates = std::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);
+        auto yStates = std::vector<int>(n_classes);
        iota(yStates.begin(), yStates.end(), 0);
        states[pClassName] = yStates;
        pDataset.index_put_({ n, "..." }, y);
@@ -101,7 +101,7 @@ namespace bayesnet {
    {
        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 Xt = std::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));
        }
--- a/src/BayesNet/Proposal.h
+++ b/src/BayesNet/Proposal.h
@@ -10,20 +10,20 @@
 namespace bayesnet {
    class Proposal {
    public:
-        Proposal(torch::Tensor& pDataset, vector<string>& features_, string& className_);
+        Proposal(torch::Tensor& pDataset, std::vector<std::string>& features_, std::string& className_);
        virtual ~Proposal();
    protected:
        void checkInput(const torch::Tensor& X, const torch::Tensor& y);
        torch::Tensor prepareX(torch::Tensor& X);
-        map<string, vector<int>> localDiscretizationProposal(const map<string, vector<int>>& states, Network& model);
-        map<string, vector<int>> fit_local_discretization(const torch::Tensor& y);
+        map<std::string, std::vector<int>> localDiscretizationProposal(const map<std::string, std::vector<int>>& states, Network& model);
+        map<std::string, std::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;
+        map<std::string, mdlp::CPPFImdlp*> discretizers;
    private:
        torch::Tensor& pDataset; // (n+1)xm tensor
-        vector<string>& pFeatures;
-        string& pClassName;
+        std::vector<std::string>& pFeatures;
+        std::string& pClassName;
    };
 }

--- a/src/BayesNet/SPODE.cc
+++ b/src/BayesNet/SPODE.cc
@@ -17,7 +17,7 @@ namespace bayesnet {
            }
        }
    }
-    vector<string> SPODE::graph(const string& name) const
+    std::vector<std::string> SPODE::graph(const std::string& name) const
    {
        return model.graph(name);
    }
--- a/src/BayesNet/SPODE.h
+++ b/src/BayesNet/SPODE.h
@@ -10,8 +10,8 @@ namespace bayesnet {
        void buildModel(const torch::Tensor& weights) override;
    public:
        explicit SPODE(int root);
-        virtual ~SPODE() {};
-        vector<string> graph(const string& name = "SPODE") const override;
+        virtual ~SPODE() = default;
+        std::vector<std::string> graph(const std::string& name = "SPODE") const override;
    };
 }
 #endif
--- a/src/BayesNet/SPODELd.cc
+++ b/src/BayesNet/SPODELd.cc
@@ -1,16 +1,15 @@
 #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_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
+    SPODELd& SPODELd::fit(torch::Tensor& X_, torch::Tensor& y_, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_)
    {
        checkInput(X_, y_);
        features = features_;
        className = className_;
        Xf = X_;
        y = y_;
-        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        // Fills std::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
@@ -18,7 +17,7 @@ namespace bayesnet {
        states = localDiscretizationProposal(states, model);
        return *this;
    }
-    SPODELd& SPODELd::fit(torch::Tensor& dataset, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
+    SPODELd& SPODELd::fit(torch::Tensor& dataset, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_)
    {
        if (!torch::is_floating_point(dataset)) {
            throw std::runtime_error("Dataset must be a floating point tensor");
@@ -27,7 +26,7 @@ namespace bayesnet {
        y = dataset.index({ -1, "..." }).clone();
        features = features_;
        className = className_;
-        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        // Fills std::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
@@ -36,12 +35,12 @@ namespace bayesnet {
        return *this;
    }

-    Tensor SPODELd::predict(Tensor& X)
+    torch::Tensor SPODELd::predict(torch::Tensor& X)
    {
        auto Xt = prepareX(X);
        return SPODE::predict(Xt);
    }
-    vector<string> SPODELd::graph(const string& name) const
+    std::vector<std::string> SPODELd::graph(const std::string& name) const
    {
        return SPODE::graph(name);
    }
--- a/src/BayesNet/SPODELd.h
+++ b/src/BayesNet/SPODELd.h
@@ -4,16 +4,15 @@
 #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, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        SPODELd& fit(torch::Tensor& dataset, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        vector<string> graph(const string& name = "SPODE") const override;
-        Tensor predict(Tensor& X) override;
-        static inline string version() { return "0.0.1"; };
+        SPODELd& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, map<std::string, std::vector<int>>& states) override;
+        SPODELd& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, map<std::string, std::vector<int>>& states) override;
+        std::vector<std::string> graph(const std::string& name = "SPODE") const override;
+        torch::Tensor predict(torch::Tensor& X) override;
+        static inline std::string version() { return "0.0.1"; };
    };
 }
 #endif // !SPODELD_H
--- a/src/BayesNet/TAN.cc
+++ b/src/BayesNet/TAN.cc
@@ -1,8 +1,6 @@
 #include "TAN.h"

 namespace bayesnet {
-    using namespace torch;
-
    TAN::TAN() : Classifier(Network()) {}

    void TAN::buildModel(const torch::Tensor& weights)
@@ -11,10 +9,10 @@ namespace bayesnet {
        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, "..." });
+        auto mi = std::vector <std::pair<int, float >>();
+        torch::Tensor class_dataset = dataset.index({ -1, "..." });
        for (int i = 0; i < static_cast<int>(features.size()); ++i) {
-            Tensor feature_dataset = dataset.index({ i, "..." });
+            torch::Tensor feature_dataset = dataset.index({ i, "..." });
            auto mi_value = metrics.mutualInformation(class_dataset, feature_dataset, weights);
            mi.push_back({ i, mi_value });
        }
@@ -34,7 +32,7 @@ namespace bayesnet {
            model.addEdge(className, feature);
        }
    }
-    vector<string> TAN::graph(const string& title) const
+    std::vector<std::string> TAN::graph(const std::string& title) const
    {
        return model.graph(title);
    }
--- a/src/BayesNet/TAN.h
+++ b/src/BayesNet/TAN.h
@@ -2,15 +2,14 @@
 #define TAN_H
 #include "Classifier.h"
 namespace bayesnet {
-    using namespace std;
    class TAN : public Classifier {
    private:
    protected:
        void buildModel(const torch::Tensor& weights) override;
    public:
        TAN();
-        virtual ~TAN() {};
-        vector<string> graph(const string& name = "TAN") const override;
+        virtual ~TAN() = default;
+        std::vector<std::string> graph(const std::string& name = "TAN") const override;
    };
 }
 #endif
--- a/src/BayesNet/TANLd.cc
+++ b/src/BayesNet/TANLd.cc
@@ -1,16 +1,15 @@
 #include "TANLd.h"

 namespace bayesnet {
-    using namespace std;
    TANLd::TANLd() : TAN(), Proposal(dataset, features, className) {}
-    TANLd& TANLd::fit(torch::Tensor& X_, torch::Tensor& y_, const vector<string>& features_, const string& className_, map<string, vector<int>>& states_)
+    TANLd& TANLd::fit(torch::Tensor& X_, torch::Tensor& y_, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_)
    {
        checkInput(X_, y_);
        features = features_;
        className = className_;
        Xf = X_;
        y = y_;
-        // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y
+        // Fills std::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
@@ -19,12 +18,12 @@ namespace bayesnet {
        return *this;

    }
-    Tensor TANLd::predict(Tensor& X)
+    torch::Tensor TANLd::predict(torch::Tensor& X)
    {
        auto Xt = prepareX(X);
        return TAN::predict(Xt);
    }
-    vector<string> TANLd::graph(const string& name) const
+    std::vector<std::string> TANLd::graph(const std::string& name) const
    {
        return TAN::graph(name);
    }
--- a/src/BayesNet/TANLd.h
+++ b/src/BayesNet/TANLd.h
@@ -4,16 +4,15 @@
 #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, const vector<string>& features, const string& className, map<string, vector<int>>& states) override;
-        vector<string> graph(const string& name = "TAN") const override;
-        Tensor predict(Tensor& X) override;
-        static inline string version() { return "0.0.1"; };
+        TANLd& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, map<std::string, std::vector<int>>& states) override;
+        std::vector<std::string> graph(const std::string& name = "TAN") const override;
+        torch::Tensor predict(torch::Tensor& X) override;
+        static inline std::string version() { return "0.0.1"; };
    };
 }
 #endif // !TANLD_H
--- a/src/BayesNet/bayesnetUtils.cc
+++ b/src/BayesNet/bayesnetUtils.cc
@@ -1,25 +1,23 @@

 #include "bayesnetUtils.h"
 namespace bayesnet {
-    using namespace std;
-    using namespace torch;
    // Return the indices in descending order
-    vector<int> argsort(vector<double>& nums)
+    std::vector<int> argsort(std::vector<double>& nums)
    {
        int n = nums.size();
-        vector<int> indices(n);
+        std::vector<int> indices(n);
        iota(indices.begin(), indices.end(), 0);
        sort(indices.begin(), indices.end(), [&nums](int i, int j) {return nums[i] > nums[j];});
        return indices;
    }
-    vector<vector<int>> tensorToVector(Tensor& tensor)
+    std::vector<std::vector<int>> tensorToVector(torch::Tensor& tensor)
    {
-        // convert mxn tensor to nxm vector
-        vector<vector<int>> result;
+        // convert mxn tensor to nxm std::vector
+        std::vector<std::vector<int>> result;
        // Iterate over cols
        for (int i = 0; i < tensor.size(1); ++i) {
            auto col_tensor = tensor.index({ "...", i });
-            auto col = vector<int>(col_tensor.data_ptr<int>(), col_tensor.data_ptr<int>() + tensor.size(0));
+            auto col = std::vector<int>(col_tensor.data_ptr<int>(), col_tensor.data_ptr<int>() + tensor.size(0));
            result.push_back(col);
        }
        return result;
--- a/src/BayesNet/bayesnetUtils.h
+++ b/src/BayesNet/bayesnetUtils.h
@@ -3,9 +3,7 @@
 #include <torch/torch.h>
 #include <vector>
 namespace bayesnet {
-    using namespace std;
-    using namespace torch;
-    vector<int> argsort(vector<double>& nums);
-    vector<vector<int>> tensorToVector(Tensor& tensor);
+    std::vector<int> argsort(std::vector<double>& nums);
+    std::vector<std::vector<int>> tensorToVector(torch::Tensor& tensor);
 }
 #endif //BAYESNET_UTILS_H
--- a/src/Platform/BestResults.cc
+++ b/src/Platform/BestResults.cc
@@ -3,6 +3,7 @@
 #include <fstream>
 #include <iostream>
 #include <sstream>
+#include <algorithm>
 #include "BestResults.h"
 #include "Result.h"
 #include "Colors.h"
@@ -12,27 +13,25 @@


 namespace fs = std::filesystem;
-// function ftime_to_string, Code taken from 
+// function ftime_to_std::string, Code taken from 
 // https://stackoverflow.com/a/58237530/1389271
 template <typename TP>
 std::string ftime_to_string(TP tp)
 {
-    using namespace std::chrono;
-    auto sctp = time_point_cast<system_clock::duration>(tp - TP::clock::now()
-        + system_clock::now());
-    auto tt = system_clock::to_time_t(sctp);
+    auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(tp - TP::clock::now()
+        + std::chrono::system_clock::now());
+    auto tt = std::chrono::system_clock::to_time_t(sctp);
    std::tm* gmt = std::gmtime(&tt);
    std::stringstream buffer;
    buffer << std::put_time(gmt, "%Y-%m-%d %H:%M");
    return buffer.str();
 }
 namespace platform {
-
-    string BestResults::build()
+    std::string BestResults::build()
    {
        auto files = loadResultFiles();
        if (files.size() == 0) {
-            cerr << Colors::MAGENTA() << "No result files were found!" << Colors::RESET() << endl;
+            std::cerr << Colors::MAGENTA() << "No result files were found!" << Colors::RESET() << std::endl;
            exit(1);
        }
        json bests;
@@ -42,7 +41,7 @@ namespace platform {
            for (auto const& item : data.at("results")) {
                bool update = false;
                // Check if results file contains only one dataset
-                auto datasetName = item.at("dataset").get<string>();
+                auto datasetName = item.at("dataset").get<std::string>();
                if (bests.contains(datasetName)) {
                    if (item.at("score").get<double>() > bests[datasetName].at(0).get<double>()) {
                        update = true;
@@ -55,42 +54,39 @@ namespace platform {
                }
            }
        }
-        string bestFileName = path + bestResultFile();
+        std::string bestFileName = path + bestResultFile();
        if (FILE* fileTest = fopen(bestFileName.c_str(), "r")) {
            fclose(fileTest);
-            cout << Colors::MAGENTA() << "File " << bestFileName << " already exists and it shall be overwritten." << Colors::RESET() << endl;
+            std::cout << Colors::MAGENTA() << "File " << bestFileName << " already exists and it shall be overwritten." << Colors::RESET() << std::endl;
        }
-        ofstream file(bestFileName);
+        std::ofstream file(bestFileName);
        file << bests;
        file.close();
        return bestFileName;
    }
-
-    string BestResults::bestResultFile()
+    std::string BestResults::bestResultFile()
    {
        return "best_results_" + score + "_" + model + ".json";
    }
-
-    pair<string, string> getModelScore(string name)
+    std::pair<std::string, std::string> getModelScore(std::string name)
    {
        // results_accuracy_BoostAODE_MacBookpro16_2023-09-06_12:27:00_1.json
        int i = 0;
        auto pos = name.find("_");
        auto pos2 = name.find("_", pos + 1);
-        string score = name.substr(pos + 1, pos2 - pos - 1);
+        std::string score = name.substr(pos + 1, pos2 - pos - 1);
        pos = name.find("_", pos2 + 1);
-        string model = name.substr(pos2 + 1, pos - pos2 - 1);
+        std::string model = name.substr(pos2 + 1, pos - pos2 - 1);
        return { model, score };
    }
-
-    vector<string> BestResults::loadResultFiles()
+    std::vector<std::string> BestResults::loadResultFiles()
    {
-        vector<string> files;
+        std::vector<std::string> files;
        using std::filesystem::directory_iterator;
-        string fileModel, fileScore;
+        std::string fileModel, fileScore;
        for (const auto& file : directory_iterator(path)) {
            auto fileName = file.path().filename().string();
-            if (fileName.find(".json") != string::npos && fileName.find("results_") == 0) {
+            if (fileName.find(".json") != std::string::npos && fileName.find("results_") == 0) {
                tie(fileModel, fileScore) = getModelScore(fileName);
                if (score == fileScore && (model == fileModel || model == "any")) {
                    files.push_back(fileName);
@@ -99,100 +95,110 @@ namespace platform {
        }
        return files;
    }
-
-    json BestResults::loadFile(const string& fileName)
+    json BestResults::loadFile(const std::string& fileName)
    {
-        ifstream resultData(fileName);
+        std::ifstream resultData(fileName);
        if (resultData.is_open()) {
            json data = json::parse(resultData);
            return data;
        }
-        throw invalid_argument("Unable to open result file. [" + fileName + "]");
+        throw std::invalid_argument("Unable to open result file. [" + fileName + "]");
    }
-    vector<string> BestResults::getModels()
+    std::vector<std::string> BestResults::getModels()
    {
-        set<string> models;
-        vector<string> result;
+        std::set<std::string> models;
+        std::vector<std::string> result;
        auto files = loadResultFiles();
        if (files.size() == 0) {
-            cerr << Colors::MAGENTA() << "No result files were found!" << Colors::RESET() << endl;
+            std::cerr << Colors::MAGENTA() << "No result files were found!" << Colors::RESET() << std::endl;
            exit(1);
        }
-        string fileModel, fileScore;
+        std::string fileModel, fileScore;
        for (const auto& file : files) {
            // extract the model from the file name
            tie(fileModel, fileScore) = getModelScore(file);
-            // add the model to the vector of models
+            // add the model to the std::vector of models
            models.insert(fileModel);
        }
-        result = vector<string>(models.begin(), models.end());
+        result = std::vector<std::string>(models.begin(), models.end());
        return result;
    }
-    vector<string> BestResults::getDatasets(json table)
+    std::vector<std::string> BestResults::getDatasets(json table)
    {
-        vector<string> datasets;
+        std::vector<std::string> datasets;
        for (const auto& dataset : table.items()) {
            datasets.push_back(dataset.key());
        }
        return datasets;
    }
-
    void BestResults::buildAll()
    {
        auto models = getModels();
        for (const auto& model : models) {
-            cout << "Building best results for model: " << model << endl;
+            std::cout << "Building best results for model: " << model << std::endl;
            this->model = model;
            build();
        }
        model = "any";
    }
-
-    void BestResults::reportSingle()
+    void BestResults::listFile()
    {
-        string bestFileName = path + bestResultFile();
+        std::string bestFileName = path + bestResultFile();
        if (FILE* fileTest = fopen(bestFileName.c_str(), "r")) {
            fclose(fileTest);
        } else {
-            cerr << Colors::MAGENTA() << "File " << bestFileName << " doesn't exist." << Colors::RESET() << endl;
+            std::cerr << Colors::MAGENTA() << "File " << bestFileName << " doesn't exist." << Colors::RESET() << std::endl;
            exit(1);
        }
        auto temp = ConfigLocale();
-        auto date = ftime_to_string(filesystem::last_write_time(bestFileName));
+        auto date = ftime_to_string(std::filesystem::last_write_time(bestFileName));
        auto data = loadFile(bestFileName);
        auto datasets = getDatasets(data);
-        int maxDatasetName = (*max_element(datasets.begin(), datasets.end(), [](const string& a, const string& b) { return a.size() < b.size(); })).size();
-        cout << Colors::GREEN() << "Best results for " << model << " and " << score << " as of " << date << endl;
-        cout << "--------------------------------------------------------" << endl;
-        cout << Colors::GREEN() << " #  " << setw(maxDatasetName + 1) << left << string("Dataset") << "Score       File                                                               Hyperparameters" << endl;
-        cout << "=== " << string(maxDatasetName, '=') << " =========== ================================================================== ================================================= " << endl;
+        int maxDatasetName = (*max_element(datasets.begin(), datasets.end(), [](const std::string& a, const std::string& b) { return a.size() < b.size(); })).size();
+        int maxFileName = 0;
+        int maxHyper = 15;
+        for (auto const& item : data.items()) {
+            maxHyper = std::max(maxHyper, (int)item.value().at(1).dump().size());
+            maxFileName = std::max(maxFileName, (int)item.value().at(2).get<std::string>().size());
+        }
+        std::stringstream oss;
+        oss << Colors::GREEN() << "Best results for " << model << " as of " << date << std::endl;
+        std::cout << oss.str();
+        std::cout << std::string(oss.str().size() - 8, '-') << std::endl;
+        std::cout << Colors::GREEN() << " #  " << std::setw(maxDatasetName + 1) << std::left << "Dataset" << "Score       " << std::setw(maxFileName) << "File" << " Hyperparameters" << std::endl;
+        std::cout << "=== " << std::string(maxDatasetName, '=') << " =========== " << std::string(maxFileName, '=') << " " << std::string(maxHyper, '=') << std::endl;
        auto i = 0;
        bool odd = true;
+        double total = 0;
        for (auto const& item : data.items()) {
            auto color = odd ? Colors::BLUE() : Colors::CYAN();
-            cout << color << setw(3) << fixed << right << i++ << " ";
-            cout << setw(maxDatasetName) << left << item.key() << " ";
-            cout << setw(11) << setprecision(9) << fixed << item.value().at(0).get<double>() << " ";
-            cout << setw(66) << item.value().at(2).get<string>() << " ";
-            cout << item.value().at(1) << " ";
-            cout << endl;
+            double value = item.value().at(0).get<double>();
+            std::cout << color << std::setw(3) << std::fixed << std::right << i++ << " ";
+            std::cout << std::setw(maxDatasetName) << std::left << item.key() << " ";
+            std::cout << std::setw(11) << std::setprecision(9) << std::fixed << value << " ";
+            std::cout << std::setw(maxFileName) << item.value().at(2).get<std::string>() << " ";
+            std::cout << item.value().at(1) << " ";
+            std::cout << std::endl;
+            total += value;
            odd = !odd;
        }
+        std::cout << Colors::GREEN() << "=== " << std::string(maxDatasetName, '=') << " ===========" << std::endl;
+        std::cout << std::setw(5 + maxDatasetName) << "Total.................. " << std::setw(11) << std::setprecision(8) << std::fixed << total << std::endl;
    }
-    json BestResults::buildTableResults(vector<string> models)
+    json BestResults::buildTableResults(std::vector<std::string> models)
    {
        json table;
-        auto maxDate = filesystem::file_time_type::max();
+        auto maxDate = std::filesystem::file_time_type::max();
        for (const auto& model : models) {
            this->model = model;
-            string bestFileName = path + bestResultFile();
+            std::string bestFileName = path + bestResultFile();
            if (FILE* fileTest = fopen(bestFileName.c_str(), "r")) {
                fclose(fileTest);
            } else {
-                cerr << Colors::MAGENTA() << "File " << bestFileName << " doesn't exist." << Colors::RESET() << endl;
+                std::cerr << Colors::MAGENTA() << "File " << bestFileName << " doesn't exist." << Colors::RESET() << std::endl;
                exit(1);
            }
-            auto dateWrite = filesystem::last_write_time(bestFileName);
+            auto dateWrite = std::filesystem::last_write_time(bestFileName);
            if (dateWrite < maxDate) {
                maxDate = dateWrite;
            }
@@ -202,24 +208,25 @@ namespace platform {
        table["dateTable"] = ftime_to_string(maxDate);
        return table;
    }
-
-    void BestResults::printTableResults(vector<string> models, json table)
+    void BestResults::printTableResults(std::vector<std::string> models, json table)
    {
-        cout << Colors::GREEN() << "Best results for " << score << " as of " << table.at("dateTable").get<string>() << endl;
-        cout << "------------------------------------------------" << endl;
-        cout << Colors::GREEN() << " #  " << setw(maxDatasetName + 1) << left << string("Dataset");
+        std::stringstream oss;
+        oss << Colors::GREEN() << "Best results for " << score << " as of " << table.at("dateTable").get<std::string>() << std::endl;
+        std::cout << oss.str();
+        std::cout << std::string(oss.str().size() - 8, '-') << std::endl;
+        std::cout << Colors::GREEN() << " #  " << std::setw(maxDatasetName + 1) << std::left << std::string("Dataset");
        for (const auto& model : models) {
-            cout << setw(maxModelName) << left << model << " ";
+            std::cout << std::setw(maxModelName) << std::left << model << " ";
        }
-        cout << endl;
-        cout << "=== " << string(maxDatasetName, '=') << " ";
+        std::cout << std::endl;
+        std::cout << "=== " << std::string(maxDatasetName, '=') << " ";
        for (const auto& model : models) {
-            cout << string(maxModelName, '=') << " ";
+            std::cout << std::string(maxModelName, '=') << " ";
        }
-        cout << endl;
+        std::cout << std::endl;
        auto i = 0;
        bool odd = true;
-        map<string, double> totals;
+        std::map<std::string, double> totals;
        int nDatasets = table.begin().value().size();
        for (const auto& model : models) {
            totals[model] = 0.0;
@@ -227,8 +234,8 @@ namespace platform {
        auto datasets = getDatasets(table.begin().value());
        for (auto const& dataset : datasets) {
            auto color = odd ? Colors::BLUE() : Colors::CYAN();
-            cout << color << setw(3) << fixed << right << i++ << " ";
-            cout << setw(maxDatasetName) << left << dataset << " ";
+            std::cout << color << std::setw(3) << std::fixed << std::right << i++ << " ";
+            std::cout << std::setw(maxDatasetName) << std::left << dataset << " ";
            double maxValue = 0;
            // Find out the max value for this dataset
            for (const auto& model : models) {
@@ -239,23 +246,23 @@ namespace platform {
            }
            // Print the row with red colors on max values
            for (const auto& model : models) {
-                string efectiveColor = color;
+                std::string efectiveColor = color;
                double value = table[model].at(dataset).at(0).get<double>();
                if (value == maxValue) {
                    efectiveColor = Colors::RED();
                }
                totals[model] += value;
-                cout << efectiveColor << setw(maxModelName) << setprecision(maxModelName - 2) << fixed << value << " ";
+                std::cout << efectiveColor << std::setw(maxModelName) << std::setprecision(maxModelName - 2) << std::fixed << value << " ";
            }
-            cout << endl;
+            std::cout << std::endl;
            odd = !odd;
        }
-        cout << Colors::GREEN() << "=== " << string(maxDatasetName, '=') << " ";
+        std::cout << Colors::GREEN() << "=== " << std::string(maxDatasetName, '=') << " ";
        for (const auto& model : models) {
-            cout << string(maxModelName, '=') << " ";
+            std::cout << std::string(maxModelName, '=') << " ";
        }
-        cout << endl;
-        cout << Colors::GREEN() << setw(5 + maxDatasetName) << "    Totals...................";
+        std::cout << std::endl;
+        std::cout << Colors::GREEN() << std::setw(5 + maxDatasetName) << "    Totals...................";
        double max = 0.0;
        for (const auto& total : totals) {
            if (total.second > max) {
@@ -263,28 +270,41 @@ namespace platform {
            }
        }
        for (const auto& model : models) {
-            string efectiveColor = Colors::GREEN();
+            std::string efectiveColor = Colors::GREEN();
            if (totals[model] == max) {
                efectiveColor = Colors::RED();
            }
-            cout << efectiveColor << right << setw(maxModelName) << setprecision(maxModelName - 4) << fixed << totals[model] << " ";
+            std::cout << efectiveColor << std::right << std::setw(maxModelName) << std::setprecision(maxModelName - 4) << std::fixed << totals[model] << " ";
+        }
+        std::cout << std::endl;
+    }
+    void BestResults::reportSingle(bool excel)
+    {
+        listFile();
+        if (excel) {
+            auto models = getModels();
+            // Build the table of results
+            json table = buildTableResults(models);
+            std::vector<std::string> datasets = getDatasets(table.begin().value());
+            BestResultsExcel excel(score, datasets);
+            excel.reportSingle(model, path + bestResultFile());
+            messageExcelFile(excel.getFileName());
        }
-        cout << endl;
    }
    void BestResults::reportAll(bool excel)
    {
        auto models = getModels();
        // Build the table of results
        json table = buildTableResults(models);
-        vector<string> datasets = getDatasets(table.begin().value());
-        maxModelName = (*max_element(models.begin(), models.end(), [](const string& a, const string& b) { return a.size() < b.size(); })).size();
-        maxModelName = max(12, maxModelName);
-        maxDatasetName = (*max_element(datasets.begin(), datasets.end(), [](const string& a, const string& b) { return a.size() < b.size(); })).size();
-        maxDatasetName = max(25, maxDatasetName);
+        std::vector<std::string> datasets = getDatasets(table.begin().value());
+        maxModelName = (*max_element(models.begin(), models.end(), [](const std::string& a, const std::string& b) { return a.size() < b.size(); })).size();
+        maxModelName = std::max(12, maxModelName);
+        maxDatasetName = (*max_element(datasets.begin(), datasets.end(), [](const std::string& a, const std::string& b) { return a.size() < b.size(); })).size();
+        maxDatasetName = std::max(25, maxDatasetName);
        // Print the table of results
        printTableResults(models, table);
        // Compute the Friedman test
-        map<string, map<string, float>> ranksModels;
+        std::map<std::string, std::map<std::string, float>> ranksModels;
        if (friedman) {
            Statistics stats(models, datasets, table, significance);
            auto result = stats.friedmanTest();
@@ -292,9 +312,32 @@ namespace platform {
            ranksModels = stats.getRanks();
        }
        if (excel) {
-            BestResultsExcel excel(score, models, datasets, table, ranksModels, friedman, significance);
-            excel.build();
-            cout << Colors::YELLOW() << "** Excel file generated: " << excel.getFileName() << Colors::RESET() << endl;
+            BestResultsExcel excel(score, datasets);
+            excel.reportAll(models, table, ranksModels, friedman, significance);
+            if (friedman) {
+                int idx = -1;
+                double min = 2000;
+                // Find out the control model
+                auto totals = std::vector<double>(models.size(), 0.0);
+                for (const auto& dataset : datasets) {
+                    for (int i = 0; i < models.size(); ++i) {
+                        totals[i] += ranksModels[dataset][models[i]];
                    }
                }
+                for (int i = 0; i < models.size(); ++i) {
+                    if (totals[i] < min) {
+                        min = totals[i];
+                        idx = i;
+                    }
+                }
+                model = models.at(idx);
+                excel.reportSingle(model, path + bestResultFile());
+            }
+            messageExcelFile(excel.getFileName());
+        }
+    }
+    void BestResults::messageExcelFile(const std::string& fileName)
+    {
+        std::cout << Colors::YELLOW() << "** Excel file generated: " << fileName << Colors::RESET() << std::endl;
+    }
 }
--- a/src/Platform/BestResults.h
+++ b/src/Platform/BestResults.h
@@ -2,27 +2,31 @@
 #define BESTRESULTS_H
 #include <string>
 #include <nlohmann/json.hpp>
-using namespace std;
 using json = nlohmann::json;
 namespace platform {
    class BestResults {
    public:
-        explicit BestResults(const string& path, const string& score, const string& model, bool friedman, double significance = 0.05) : path(path), score(score), model(model), friedman(friedman), significance(significance) {}
-        string build();
-        void reportSingle();
+        explicit BestResults(const std::string& path, const std::string& score, const std::string& model, bool friedman, double significance = 0.05)
+            : path(path), score(score), model(model), friedman(friedman), significance(significance)
+        {
+        }
+        std::string build();
+        void reportSingle(bool excel);
        void reportAll(bool excel);
        void buildAll();
    private:
-        vector<string> getModels();
-        vector<string> getDatasets(json table);
-        vector<string> loadResultFiles();
-        json buildTableResults(vector<string> models);
-        void printTableResults(vector<string> models, json table);
-        string bestResultFile();
-        json loadFile(const string& fileName);
-        string path;
-        string score;
-        string model;
+        std::vector<std::string> getModels();
+        std::vector<std::string> getDatasets(json table);
+        std::vector<std::string> loadResultFiles();
+        void messageExcelFile(const std::string& fileName);
+        json buildTableResults(std::vector<std::string> models);
+        void printTableResults(std::vector<std::string> models, json table);
+        std::string bestResultFile();
+        json loadFile(const std::string& fileName);
+        void listFile();
+        std::string path;
+        std::string score;
+        std::string model;
        bool friedman;
        double significance;
        int maxModelName = 0;
--- a/src/Platform/BestResultsExcel.cc
+++ b/src/Platform/BestResultsExcel.cc
@@ -1,21 +1,122 @@
 #include <sstream>
 #include "BestResultsExcel.h"
 #include "Paths.h"
+#include <map>
+#include <nlohmann/json.hpp>
 #include "Statistics.h"
+#include "ReportExcel.h"

 namespace platform {
-    BestResultsExcel::BestResultsExcel(const string& score, const vector<string>& models, const vector<string>& datasets, const json& table, const map<string, map<string, float>>& ranksModels, bool friedman, double significance) :
-        score(score), models(models), datasets(datasets), table(table), ranksModels(ranksModels), friedman(friedman), significance(significance)
+    json loadResultData(const std::string& fileName)
+    {
+        json data;
+        std::ifstream resultData(fileName);
+        if (resultData.is_open()) {
+            data = json::parse(resultData);
+        } else {
+            throw std::invalid_argument("Unable to open result file. [" + fileName + "]");
+        }
+        return data;
+    }
+    std::string getColumnName(int colNum)
+    {
+        std::string columnName = "";
+        if (colNum == 0)
+            return "A";
+        while (colNum > 0) {
+            int modulo = colNum % 26;
+            columnName = char(65 + modulo) + columnName;
+            colNum = (int)((colNum - modulo) / 26);
+        }
+        return columnName;
+    }
+    BestResultsExcel::BestResultsExcel(const std::string& score, const std::vector<std::string>& datasets) : score(score), datasets(datasets)
    {
        workbook = workbook_new((Paths::excel() + fileName).c_str());
-        worksheet = workbook_add_worksheet(workbook, "Best Results");
        setProperties("Best Results");
+        int maxDatasetName = (*max_element(datasets.begin(), datasets.end(), [](const std::string& a, const std::string& b) { return a.size() < b.size(); })).size();
+        datasetNameSize = std::max(datasetNameSize, maxDatasetName);
        createFormats();
-        int maxModelName = (*max_element(models.begin(), models.end(), [](const string& a, const string& b) { return a.size() < b.size(); })).size();
-        modelNameSize = max(modelNameSize, maxModelName);
-        int maxDatasetName = (*max_element(datasets.begin(), datasets.end(), [](const string& a, const string& b) { return a.size() < b.size(); })).size();
-        datasetNameSize = max(datasetNameSize, maxDatasetName);
+    }
+    void BestResultsExcel::reportAll(const std::vector<std::string>& models, const json& table, const std::map<std::string, std::map<std::string, float>>& ranks, bool friedman, double significance)
+    {
+        this->table = table;
+        this->models = models;
+        ranksModels = ranks;
+        this->friedman = friedman;
+        this->significance = significance;
+        worksheet = workbook_add_worksheet(workbook, "Best Results");
+        int maxModelName = (*std::max_element(models.begin(), models.end(), [](const std::string& a, const std::string& b) { return a.size() < b.size(); })).size();
+        modelNameSize = std::max(modelNameSize, maxModelName);
        formatColumns();
+        build();
+    }
+    void BestResultsExcel::reportSingle(const std::string& model, const std::string& fileName)
+    {
+        worksheet = workbook_add_worksheet(workbook, "Report");
+        if (FILE* fileTest = fopen(fileName.c_str(), "r")) {
+            fclose(fileTest);
+        } else {
+            std::cerr << "File " << fileName << " doesn't exist." << std::endl;
+            exit(1);
+        }
+        json data = loadResultData(fileName);
+
+        std::string title = "Best results for " + model;
+        worksheet_merge_range(worksheet, 0, 0, 0, 4, title.c_str(), styles["headerFirst"]);
+        // Body header
+        row = 3;
+        int col = 1;
+        writeString(row, 0, "Nº", "bodyHeader");
+        writeString(row, 1, "Dataset", "bodyHeader");
+        writeString(row, 2, "Score", "bodyHeader");
+        writeString(row, 3, "File", "bodyHeader");
+        writeString(row, 4, "Hyperparameters", "bodyHeader");
+        auto i = 0;
+        std::string hyperparameters;
+        int hypSize = 22;
+        std::map<std::string, std::string> files; // map of files imported and their tabs
+        for (auto const& item : data.items()) {
+            row++;
+            writeInt(row, 0, i++, "ints");
+            writeString(row, 1, item.key().c_str(), "text");
+            writeDouble(row, 2, item.value().at(0).get<double>(), "result");
+            auto fileName = item.value().at(2).get<std::string>();
+            std::string hyperlink = "";
+            try {
+                hyperlink = files.at(fileName);
+            }
+            catch (const std::out_of_range& oor) {
+                auto tabName = "table_" + std::to_string(i);
+                auto worksheetNew = workbook_add_worksheet(workbook, tabName.c_str());
+                json data = loadResultData(Paths::results() + fileName);
+                auto report = ReportExcel(data, false, workbook, worksheetNew);
+                report.show();
+                hyperlink = "#table_" + std::to_string(i);
+                files[fileName] = hyperlink;
+            }
+            hyperlink += "!H" + std::to_string(i + 6);
+            std::string fileNameText = "=HYPERLINK(\"" + hyperlink + "\",\"" + fileName + "\")";
+            worksheet_write_formula(worksheet, row, 3, fileNameText.c_str(), efectiveStyle("text"));
+            hyperparameters = item.value().at(1).dump();
+            if (hyperparameters.size() > hypSize) {
+                hypSize = hyperparameters.size();
+            }
+            writeString(row, 4, hyperparameters, "text");
+        }
+        row++;
+        // Set Totals
+        writeString(row, 1, "Total", "bodyHeader");
+        std::stringstream oss;
+        auto colName = getColumnName(2);
+        oss << "=sum(" << colName << "5:" << colName << row << ")";
+        worksheet_write_formula(worksheet, row, 2, oss.str().c_str(), styles["bodyHeader_odd"]);
+        // Set format
+        worksheet_freeze_panes(worksheet, 4, 2);
+        std::vector<int> columns_sizes = { 5, datasetNameSize, modelNameSize, 66, hypSize + 1 };
+        for (int i = 0; i < columns_sizes.size(); ++i) {
+            worksheet_set_column(worksheet, i, i, columns_sizes.at(i), NULL);
+        }
    }
    BestResultsExcel::~BestResultsExcel()
    {
@@ -24,7 +125,7 @@ namespace platform {
    void BestResultsExcel::formatColumns()
    {
        worksheet_freeze_panes(worksheet, 4, 2);
-        vector<int> columns_sizes = { 5, datasetNameSize };
+        std::vector<int> columns_sizes = { 5, datasetNameSize };
        for (int i = 0; i < models.size(); ++i) {
            columns_sizes.push_back(modelNameSize);
        }
@@ -32,11 +133,30 @@ namespace platform {
            worksheet_set_column(worksheet, i, i, columns_sizes.at(i), NULL);
        }
    }
+    void BestResultsExcel::addConditionalFormat(std::string formula)
+    {
+        // Add conditional format for max/min values in scores/ranks sheets
+        lxw_format* custom_format = workbook_add_format(workbook);
+        format_set_bg_color(custom_format, 0xFFC7CE);
+        format_set_font_color(custom_format, 0x9C0006);
+        // Create a conditional format object. A static object would also work.
+        lxw_conditional_format* conditional_format = (lxw_conditional_format*)calloc(1, sizeof(lxw_conditional_format));
+        conditional_format->type = LXW_CONDITIONAL_TYPE_FORMULA;
+        std::string col = getColumnName(models.size() + 1);
+        std::stringstream oss;
+        oss << "=C5=" << formula << "($C5:$" << col << "5)";
+        auto formulaValue = oss.str();
+        conditional_format->value_string = formulaValue.c_str();
+        conditional_format->format = custom_format;
+        worksheet_conditional_format_range(worksheet, 4, 2, datasets.size() + 3, models.size() + 1, conditional_format);
+    }
    void BestResultsExcel::build()
    {
        // Create Sheet with scores
        header(false);
        body(false);
+        // Add conditional format for max values
+        addConditionalFormat("max");
        footer(false);
        if (friedman) {
            // Create Sheet with ranks
@@ -44,19 +164,20 @@ namespace platform {
            formatColumns();
            header(true);
            body(true);
+            addConditionalFormat("min");
            footer(true);
            // Create Sheet with Friedman Test
            doFriedman();
        }
    }
-    string BestResultsExcel::getFileName()
+    std::string BestResultsExcel::getFileName()
    {
        return Paths::excel() + fileName;
    }
    void BestResultsExcel::header(bool ranks)
    {
        row = 0;
-        string message = ranks ? "Ranks for score " + score : "Best results for " + score;
+        std::string message = ranks ? "Ranks for score " + score : "Best results for " + score;
        worksheet_merge_range(worksheet, 0, 0, 0, 1 + models.size(), message.c_str(), styles["headerFirst"]);
        // Body header
        row = 3;
@@ -89,8 +210,9 @@ namespace platform {
        writeString(row, 1, "Total", "bodyHeader");
        int col = 1;
        for (const auto& model : models) {
-            stringstream oss;
-            oss << "=sum(indirect(address(" << 5 << "," << col + 2 << ")):indirect(address(" << row << "," << col + 2 << ")))";
+            std::stringstream oss;
+            auto colName = getColumnName(col + 1);
+            oss << "=SUM(" << colName << "5:" << colName << row << ")";
            worksheet_write_formula(worksheet, row, ++col, oss.str().c_str(), styles["bodyHeader_odd"]);
        }
        if (ranks) {
@@ -98,8 +220,9 @@ namespace platform {
            writeString(row, 1, "Average ranks", "bodyHeader");
            int col = 1;
            for (const auto& model : models) {
-                stringstream oss;
-                oss << "=sum(indirect(address(" << 5 << "," << col + 2 << ")):indirect(address(" << row - 1 << "," << col + 2 << ")))/" << datasets.size();
+                auto colName = getColumnName(col + 1);
+                std::stringstream oss;
+                oss << "=SUM(" << colName << "5:" << colName << row - 1 << ")/" << datasets.size();
                worksheet_write_formula(worksheet, row, ++col, oss.str().c_str(), styles["bodyHeader_odd"]);
            }
        }
@@ -107,7 +230,7 @@ namespace platform {
    void BestResultsExcel::doFriedman()
    {
        worksheet = workbook_add_worksheet(workbook, "Friedman");
-        vector<int> columns_sizes = { 5, datasetNameSize };
+        std::vector<int> columns_sizes = { 5, datasetNameSize };
        for (int i = 0; i < models.size(); ++i) {
            columns_sizes.push_back(modelNameSize);
        }
@@ -139,7 +262,7 @@ namespace platform {
        row += 2;
        worksheet_merge_range(worksheet, row, 0, row, 1 + models.size(), "Null hypothesis: H0 'There is no significant differences between the control model and the other models.'", styles["headerSmall"]);
        row += 2;
-        string controlModel = "Control Model: " + holmResult.model;
+        std::string controlModel = "Control Model: " + holmResult.model;
        worksheet_merge_range(worksheet, row, 1, row, 7, controlModel.c_str(), styles["bodyHeader_odd"]);
        row++;
        writeString(row, 1, "Model", "bodyHeader");
--- a/src/Platform/BestResultsExcel.h
+++ b/src/Platform/BestResultsExcel.h
@@ -5,29 +5,31 @@
 #include <map>
 #include <nlohmann/json.hpp>

-using namespace std;
 using json = nlohmann::json;

 namespace platform {

    class BestResultsExcel : ExcelFile {
    public:
-        BestResultsExcel(const string& score, const vector<string>& models, const vector<string>& datasets, const json& table, const map<string, map<string, float>>& ranks, bool friedman, double significance);
+        BestResultsExcel(const std::string& score, const std::vector<std::string>& datasets);
        ~BestResultsExcel();
-        void build();
-        string getFileName();
+        void reportAll(const std::vector<std::string>& models, const json& table, const std::map<std::string, std::map<std::string, float>>& ranks, bool friedman, double significance);
+        void reportSingle(const std::string& model, const std::string& fileName);
+        std::string getFileName();
    private:
+        void build();
        void header(bool ranks);
        void body(bool ranks);
        void footer(bool ranks);
        void formatColumns();
        void doFriedman();
-        const string fileName = "BestResults.xlsx";
-        string score;
-        vector<string> models;
-        vector<string> datasets;
+        void addConditionalFormat(std::string formula);
+        const std::string fileName = "BestResults.xlsx";
+        std::string score;
+        std::vector<std::string> models;
+        std::vector<std::string> datasets;
        json table;
-        map<string, map<string, float>> ranksModels;
+        std::map<std::string, std::map<std::string, float>> ranksModels;
        bool friedman;
        double significance;
        int modelNameSize = 12; // Min size of the column
--- a/src/Platform/BestScore.h
+++ b/src/Platform/BestScore.h
@@ -1,10 +1,28 @@
 #ifndef BESTSCORE_H
 #define BESTSCORE_H
 #include <string>
+#include <map>
+#include <utility>
+#include "DotEnv.h"
+namespace platform {
    class BestScore {
    public:
-    static std::string title() { return "STree_default (linear-ovo)"; }
-    static double score() { return 22.109799; }
-    static std::string scoreName() { return "accuracy"; }
+        static std::pair<std::string, double> getScore(const std::string& metric)
+        {
+            static std::map<std::pair<std::string, std::string>, std::pair<std::string, double>> data = {
+               {{"discretiz", "accuracy"}, {"STree_default (linear-ovo)",  22.109799}},
+               {{"odte", "accuracy"}, {"STree_default (linear-ovo)",  22.109799}},
            };
+            auto env = platform::DotEnv();
+            std::string experiment = env.get("experiment");
+            try {
+                return data[{experiment, metric}];
+            }
+            catch (...) {
+                return { "", 0.0 };
+            }
+        }
+    };
+}
+
 #endif
--- a/src/Platform/CLocale.h
+++ b/src/Platform/CLocale.h
@@ -2,22 +2,20 @@
 #define LOCALE_H
 #include <locale>
 #include <iostream>
-#include <sstream>
 #include <string>
-using namespace std;
 namespace platform {
-    struct separation : numpunct<char> {
+    struct separation : std::numpunct<char> {
        char do_decimal_point() const { return ','; }
        char do_thousands_sep() const { return '.'; }
-        string do_grouping() const { return "\03"; }
+        std::string do_grouping() const { return "\03"; }
    };
    class ConfigLocale {
    public:
        explicit ConfigLocale()
        {
-            locale mylocale(cout.getloc(), new separation);
-            locale::global(mylocale);
-            cout.imbue(mylocale);
+            std::locale mylocale(std::cout.getloc(), new separation);
+            std::locale::global(mylocale);
+            std::cout.imbue(mylocale);
        }
    };
 }
--- a/src/Platform/CMakeLists.txt
+++ b/src/Platform/CMakeLists.txt
@@ -1,17 +1,22 @@
 include_directories(${BayesNet_SOURCE_DIR}/src/BayesNet)
 include_directories(${BayesNet_SOURCE_DIR}/src/Platform)
+include_directories(${BayesNet_SOURCE_DIR}/src/PyClassifiers)
 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)
 include_directories(${BayesNet_SOURCE_DIR}/lib/libxlsxwriter/include)
-add_executable(b_main main.cc Folding.cc Experiment.cc Datasets.cc Dataset.cc Models.cc ReportConsole.cc ReportBase.cc)
-add_executable(b_manage manage.cc Results.cc Result.cc ReportConsole.cc ReportExcel.cc ReportBase.cc Datasets.cc Dataset.cc ExcelFile.cc)
-add_executable(b_list list.cc Datasets.cc Dataset.cc)
-add_executable(b_best best.cc BestResults.cc Result.cc Statistics.cc BestResultsExcel.cc ExcelFile.cc)
-add_executable(testx testx.cpp Datasets.cc Dataset.cc Folding.cc )
-target_link_libraries(b_main BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}")
-target_link_libraries(b_manage "${TORCH_LIBRARIES}" "${XLSXWRITER_LIB}" ArffFiles mdlp)
-target_link_libraries(b_best Boost::boost "${XLSXWRITER_LIB}")
+include_directories(${Python3_INCLUDE_DIRS})
+include_directories(${MPI_CXX_INCLUDE_DIRS})
+
+add_executable(b_best b_best.cc BestResults.cc Result.cc Statistics.cc BestResultsExcel.cc ReportExcel.cc ReportBase.cc Datasets.cc Dataset.cc ExcelFile.cc)
+add_executable(b_grid b_grid.cc GridSearch.cc GridData.cc HyperParameters.cc Folding.cc Datasets.cc Dataset.cc)
+add_executable(b_list b_list.cc Datasets.cc Dataset.cc)
+add_executable(b_main b_main.cc Folding.cc Experiment.cc Datasets.cc Dataset.cc Models.cc HyperParameters.cc ReportConsole.cc ReportBase.cc)
+add_executable(b_manage b_manage.cc Results.cc ManageResults.cc CommandParser.cc Result.cc ReportConsole.cc ReportExcel.cc ReportBase.cc Datasets.cc Dataset.cc ExcelFile.cc)
+
+target_link_libraries(b_best Boost::boost "${XLSXWRITER_LIB}" "${TORCH_LIBRARIES}" ArffFiles mdlp)
+target_link_libraries(b_grid BayesNet PyWrap ${MPI_CXX_LIBRARIES})
 target_link_libraries(b_list ArffFiles mdlp "${TORCH_LIBRARIES}")
-target_link_libraries(testx ArffFiles BayesNet "${TORCH_LIBRARIES}")
+target_link_libraries(b_main BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}" PyWrap)
+target_link_libraries(b_manage "${TORCH_LIBRARIES}" "${XLSXWRITER_LIB}" ArffFiles mdlp)
--- a/src/Platform/Colors.h
+++ b/src/Platform/Colors.h
@@ -9,6 +9,7 @@ public:
    static std::string YELLOW() { return "\033[1;33m"; }
    static std::string RED() { return "\033[1;31m"; }
    static std::string WHITE() { return "\033[1;37m"; }
+    static std::string IBLUE() { return "\033[0;94m"; }
    static std::string RESET() { return "\033[0m"; }
 };
 #endif // COLORS_H
--- a/src/Platform/CommandParser.cc
+++ b/src/Platform/CommandParser.cc
@@ -0,0 +1,87 @@
+#include "CommandParser.h"
+#include <iostream>
+#include <sstream>
+#include <algorithm>
+#include "Colors.h"
+#include "Utils.h"
+
+namespace platform {
+    void CommandParser::messageError(const std::string& message)
+    {
+        std::cout << Colors::RED() << message << Colors::RESET() << std::endl;
+    }
+    std::pair<char, int> CommandParser::parse(const std::string& color, const std::vector<std::tuple<std::string, char, bool>>& options, const char defaultCommand, const int maxIndex)
+    {
+        bool finished = false;
+        while (!finished) {
+            std::stringstream oss;
+            std::string line;
+            oss << color << "Choose option (";
+            bool first = true;
+            for (auto& option : options) {
+                if (first) {
+                    first = false;
+                } else {
+                    oss << ", ";
+                }
+                oss << std::get<char>(option) << "=" << std::get<std::string>(option);
+            }
+            oss << "): ";
+            std::cout << oss.str();
+            getline(std::cin, line);
+            std::cout << Colors::RESET();
+            line = trim(line);
+            if (line.size() == 0)
+                continue;
+            if (all_of(line.begin(), line.end(), ::isdigit)) {
+                command = defaultCommand;
+                index = stoi(line);
+                if (index > maxIndex || index < 0) {
+                    messageError("Index out of range");
+                    continue;
+                }
+                finished = true;
+                break;
+            }
+            bool found = false;
+            for (auto& option : options) {
+                if (line[0] == std::get<char>(option)) {
+                    found = true;
+                    // it's a match
+                    line.erase(line.begin());
+                    line = trim(line);
+                    if (std::get<bool>(option)) {
+                        // The option requires a value
+                        if (line.size() == 0) {
+                            messageError("Option " + std::get<std::string>(option) + " requires a value");
+                            break;
+                        }
+                        try {
+                            index = stoi(line);
+                            if (index > maxIndex || index < 0) {
+                                messageError("Index out of range");
+                                break;
+                            }
+                        }
+                        catch (const std::invalid_argument& ia) {
+                            messageError("Invalid value: " + line);
+                            break;
+                        }
+                    } else {
+                        if (line.size() > 0) {
+                            messageError("option " + std::get<std::string>(option) + " doesn't accept values");
+                            break;
+                        }
+                    }
+                    command = std::get<char>(option);
+                    finished = true;
+                    break;
+                }
+            }
+            if (!found) {
+                messageError("I don't know " + line);
+            }
+        }
+        return { command, index };
+    }
+} /* namespace platform */
--- a/src/Platform/CommandParser.h
+++ b/src/Platform/CommandParser.h
@@ -0,0 +1,20 @@
+#ifndef COMMAND_PARSER_H
+#define COMMAND_PARSER_H
+#include <string>
+#include <vector>
+#include <tuple>
+
+namespace platform {
+    class CommandParser {
+    public:
+        CommandParser() = default;
+        std::pair<char, int> parse(const std::string& color, const std::vector<std::tuple<std::string, char, bool>>& options, const char defaultCommand, const int maxIndex);
+        char getCommand() const { return command; };
+        int getIndex() const { return index; };
+    private:
+        void messageError(const std::string& message);
+        char command;
+        int index;
+    };
+} /* namespace platform */
+#endif /* COMMAND_PARSER_H */
--- a/src/Platform/Dataset.cc
+++ b/src/Platform/Dataset.cc
@@ -5,20 +5,20 @@ namespace platform {
    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() const
+    std::string Dataset::getName() const
    {
        return name;
    }
-    string Dataset::getClassName() const
+    std::string Dataset::getClassName() const
    {
        return className;
    }
-    vector<string> Dataset::getFeatures() const
+    std::vector<std::string> Dataset::getFeatures() const
    {
        if (loaded) {
            return features;
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
    int Dataset::getNFeatures() const
@@ -26,7 +26,7 @@ namespace platform {
        if (loaded) {
            return n_features;
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
    int Dataset::getNSamples() const
@@ -34,31 +34,31 @@ namespace platform {
        if (loaded) {
            return n_samples;
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
-    map<string, vector<int>> Dataset::getStates() const
+    std::map<std::string, std::vector<int>> Dataset::getStates() const
    {
        if (loaded) {
            return states;
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
-    pair<vector<vector<float>>&, vector<int>&> Dataset::getVectors()
+    pair<std::vector<std::vector<float>>&, std::vector<int>&> Dataset::getVectors()
    {
        if (loaded) {
            return { Xv, yv };
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
-    pair<vector<vector<int>>&, vector<int>&> Dataset::getVectorsDiscretized()
+    pair<std::vector<std::vector<int>>&, std::vector<int>&> Dataset::getVectorsDiscretized()
    {
        if (loaded) {
            return { Xd, yv };
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
    pair<torch::Tensor&, torch::Tensor&> Dataset::getTensors()
@@ -67,22 +67,22 @@ namespace platform {
            buildTensors();
            return { X, y };
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
    void Dataset::load_csv()
    {
        ifstream file(path + "/" + name + ".csv");
        if (file.is_open()) {
-            string line;
+            std::string line;
            getline(file, line);
-            vector<string> tokens = split(line, ',');
-            features = vector<string>(tokens.begin(), tokens.end() - 1);
+            std::vector<std::string> tokens = split(line, ',');
+            features = std::vector<std::string>(tokens.begin(), tokens.end() - 1);
            if (className == "-1") {
                className = tokens.back();
            }
            for (auto i = 0; i < features.size(); ++i) {
-                Xv.push_back(vector<float>());
+                Xv.push_back(std::vector<float>());
            }
            while (getline(file, line)) {
                tokens = split(line, ',');
@@ -93,17 +93,17 @@ namespace platform {
            }
            file.close();
        } else {
-            throw invalid_argument("Unable to open dataset file.");
+            throw std::invalid_argument("Unable to open dataset file.");
        }
    }
    void Dataset::computeStates()
    {
        for (int i = 0; i < features.size(); ++i) {
-            states[features[i]] = vector<int>(*max_element(Xd[i].begin(), Xd[i].end()) + 1);
+            states[features[i]] = std::vector<int>(*max_element(Xd[i].begin(), Xd[i].end()) + 1);
            auto item = states.at(features[i]);
            iota(begin(item), end(item), 0);
        }
-        states[className] = vector<int>(*max_element(yv.begin(), yv.end()) + 1);
+        states[className] = std::vector<int>(*max_element(yv.begin(), yv.end()) + 1);
        iota(begin(states.at(className)), end(states.at(className)), 0);
    }
    void Dataset::load_arff()
@@ -118,12 +118,12 @@ namespace platform {
        auto attributes = arff.getAttributes();
        transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& attribute) { return attribute.first; });
    }
-    vector<string> tokenize(string line)
+    std::vector<std::string> tokenize(std::string line)
    {
-        vector<string> tokens;
+        std::vector<std::string> tokens;
        for (auto i = 0; i < line.size(); ++i) {
            if (line[i] == ' ' || line[i] == '\t' || line[i] == '\n') {
-                string token = line.substr(0, i);
+                std::string token = line.substr(0, i);
                tokens.push_back(token);
                line.erase(line.begin(), line.begin() + i + 1);
                i = 0;
@@ -140,16 +140,16 @@ namespace platform {
    {
        ifstream file(path + "/" + name + "_R.dat");
        if (file.is_open()) {
-            string line;
+            std::string line;
            getline(file, line);
            line = ArffFiles::trim(line);
-            vector<string> tokens = tokenize(line);
+            std::vector<std::string> tokens = tokenize(line);
            transform(tokens.begin(), tokens.end() - 1, back_inserter(features), [](const auto& attribute) { return ArffFiles::trim(attribute); });
            if (className == "-1") {
                className = ArffFiles::trim(tokens.back());
            }
            for (auto i = 0; i < features.size(); ++i) {
-                Xv.push_back(vector<float>());
+                Xv.push_back(std::vector<float>());
            }
            while (getline(file, line)) {
                tokens = tokenize(line);
@@ -162,7 +162,7 @@ namespace platform {
            }
            file.close();
        } else {
-            throw invalid_argument("Unable to open dataset file.");
+            throw std::invalid_argument("Unable to open dataset file.");
        }
    }
    void Dataset::load()
@@ -201,9 +201,9 @@ namespace platform {
        }
        y = torch::tensor(yv, torch::kInt32);
    }
-    vector<mdlp::labels_t> Dataset::discretizeDataset(vector<mdlp::samples_t>& X, mdlp::labels_t& y)
+    std::vector<mdlp::labels_t> Dataset::discretizeDataset(std::vector<mdlp::samples_t>& X, mdlp::labels_t& y)
    {
-        vector<mdlp::labels_t> Xd;
+        std::vector<mdlp::labels_t> Xd;
        auto fimdlp = mdlp::CPPFImdlp();
        for (int i = 0; i < X.size(); i++) {
            fimdlp.fit(X[i], y);
--- a/src/Platform/Dataset.h
+++ b/src/Platform/Dataset.h
@@ -7,12 +7,10 @@
 #include "CPPFImdlp.h"
 #include "Utils.h"
 namespace platform {
-    using namespace std;
-
    enum fileType_t { CSV, ARFF, RDATA };
    class SourceData {
    public:
-        SourceData(string source)
+        SourceData(std::string source)
        {
            if (source == "Surcov") {
                path = "datasets/";
@@ -24,10 +22,10 @@ namespace platform {
                path = "data/";
                fileType = RDATA;
            } else {
-                throw invalid_argument("Unknown source.");
+                throw std::invalid_argument("Unknown source.");
            }
        }
-        string getPath()
+        std::string getPath()
        {
            return path;
        }
@@ -36,40 +34,40 @@ namespace platform {
            return fileType;
        }
    private:
-        string path;
+        std::string path;
        fileType_t fileType;
    };
    class Dataset {
    private:
-        string path;
-        string name;
+        std::string path;
+        std::string name;
        fileType_t fileType;
-        string className;
+        std::string className;
        int n_samples{ 0 }, n_features{ 0 };
-        vector<string> features;
-        map<string, vector<int>> states;
+        std::vector<std::string> features;
+        std::map<std::string, std::vector<int>> states;
        bool loaded;
        bool discretize;
        torch::Tensor X, y;
-        vector<vector<float>> Xv;
-        vector<vector<int>> Xd;
-        vector<int> yv;
+        std::vector<std::vector<float>> Xv;
+        std::vector<std::vector<int>> Xd;
+        std::vector<int> yv;
        void buildTensors();
        void load_csv();
        void load_arff();
        void load_rdata();
        void computeStates();
-        vector<mdlp::labels_t> discretizeDataset(vector<mdlp::samples_t>& X, mdlp::labels_t& y);
+        std::vector<mdlp::labels_t> discretizeDataset(std::vector<mdlp::samples_t>& X, mdlp::labels_t& y);
    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) {};
+        Dataset(const std::string& path, const std::string& name, const std::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() const;
-        string getClassName() const;
-        vector<string> getFeatures() const;
-        map<string, vector<int>> getStates() const;
-        pair<vector<vector<float>>&, vector<int>&> getVectors();
-        pair<vector<vector<int>>&, vector<int>&> getVectorsDiscretized();
-        pair<torch::Tensor&, torch::Tensor&> getTensors();
+        std::string getName() const;
+        std::string getClassName() const;
+        std::vector<string> getFeatures() const;
+        std::map<std::string, std::vector<int>> getStates() const;
+        std::pair<vector<std::vector<float>>&, std::vector<int>&> getVectors();
+        std::pair<vector<std::vector<int>>&, std::vector<int>&> getVectorsDiscretized();
+        std::pair<torch::Tensor&, torch::Tensor&> getTensors();
        int getNFeatures() const;
        int getNSamples() const;
        void load();
--- a/src/Platform/Datasets.cc
+++ b/src/Platform/Datasets.cc
@@ -8,14 +8,14 @@ namespace platform {
        path = sd.getPath();
        ifstream catalog(path + "all.txt");
        if (catalog.is_open()) {
-            string line;
+            std::string line;
            while (getline(catalog, line)) {
                if (line.empty() || line[0] == '#') {
                    continue;
                }
-                vector<string> tokens = split(line, ',');
-                string name = tokens[0];
-                string className;
+                std::vector<std::string> tokens = split(line, ',');
+                std::string name = tokens[0];
+                std::string className;
                if (tokens.size() == 1) {
                    className = "-1";
                } else {
@@ -25,32 +25,32 @@ namespace platform {
            }
            catalog.close();
        } else {
-            throw invalid_argument("Unable to open catalog file. [" + path + "all.txt" + "]");
+            throw std::invalid_argument("Unable to open catalog file. [" + path + "all.txt" + "]");
        }
    }
-    vector<string> Datasets::getNames()
+    std::vector<std::string> Datasets::getNames()
    {
-        vector<string> result;
+        std::vector<std::string> result;
        transform(datasets.begin(), datasets.end(), back_inserter(result), [](const auto& d) { return d.first; });
        return result;
    }
-    vector<string> Datasets::getFeatures(const string& name) const
+    std::vector<std::string> Datasets::getFeatures(const std::string& name) const
    {
        if (datasets.at(name)->isLoaded()) {
            return datasets.at(name)->getFeatures();
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
-    map<string, vector<int>> Datasets::getStates(const string& name) const
+    map<std::string, std::vector<int>> Datasets::getStates(const std::string& name) const
    {
        if (datasets.at(name)->isLoaded()) {
            return datasets.at(name)->getStates();
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
-    void Datasets::loadDataset(const string& name) const
+    void Datasets::loadDataset(const std::string& name) const
    {
        if (datasets.at(name)->isLoaded()) {
            return;
@@ -58,23 +58,23 @@ namespace platform {
            datasets.at(name)->load();
        }
    }
-    string Datasets::getClassName(const string& name) const
+    std::string Datasets::getClassName(const std::string& name) const
    {
        if (datasets.at(name)->isLoaded()) {
            return datasets.at(name)->getClassName();
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
-    int Datasets::getNSamples(const string& name) const
+    int Datasets::getNSamples(const std::string& name) const
    {
        if (datasets.at(name)->isLoaded()) {
            return datasets.at(name)->getNSamples();
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
-    int Datasets::getNClasses(const string& name)
+    int Datasets::getNClasses(const std::string& name)
    {
        if (datasets.at(name)->isLoaded()) {
            auto className = datasets.at(name)->getClassName();
@@ -83,46 +83,46 @@ namespace platform {
                return states.at(className).size();
            }
            auto [Xv, yv] = getVectors(name);
-            return *max_element(yv.begin(), yv.end()) + 1;
+            return *std::max_element(yv.begin(), yv.end()) + 1;
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
-    vector<int> Datasets::getClassesCounts(const string& name) const
+    std::vector<int> Datasets::getClassesCounts(const std::string& name) const
    {
        if (datasets.at(name)->isLoaded()) {
            auto [Xv, yv] = datasets.at(name)->getVectors();
-            vector<int> counts(*max_element(yv.begin(), yv.end()) + 1);
+            std::vector<int> counts(*std::max_element(yv.begin(), yv.end()) + 1);
            for (auto y : yv) {
                counts[y]++;
            }
            return counts;
        } else {
-            throw invalid_argument("Dataset not loaded.");
+            throw std::invalid_argument("Dataset not loaded.");
        }
    }
-    pair<vector<vector<float>>&, vector<int>&> Datasets::getVectors(const string& name)
+    pair<std::vector<std::vector<float>>&, std::vector<int>&> Datasets::getVectors(const std::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<std::vector<std::vector<int>>&, std::vector<int>&> Datasets::getVectorsDiscretized(const std::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(const std::string& name)
    {
        if (!datasets[name]->isLoaded()) {
            datasets[name]->load();
        }
        return datasets[name]->getTensors();
    }
-    bool Datasets::isDataset(const string& name) const
+    bool Datasets::isDataset(const std::string& name) const
    {
        return datasets.find(name) != datasets.end();
    }
--- a/src/Platform/Datasets.h
+++ b/src/Platform/Datasets.h
@@ -2,29 +2,28 @@
 #define DATASETS_H
 #include "Dataset.h"
 namespace platform {
-    using namespace std;
    class Datasets {
    private:
-        string path;
+        std::string path;
        fileType_t fileType;
-        string sfileType;
-        map<string, unique_ptr<Dataset>> datasets;
+        std::string sfileType;
+        std::map<std::string, std::unique_ptr<Dataset>> datasets;
        bool discretize;
        void load(); // Loads the list of datasets
    public:
-        explicit Datasets(bool discretize, string sfileType) : discretize(discretize), sfileType(sfileType) { load(); };
-        vector<string> getNames();
-        vector<string> getFeatures(const string& name) const;
-        int getNSamples(const string& name) const;
-        string getClassName(const string& name) const;
-        int getNClasses(const string& name);
-        vector<int> getClassesCounts(const string& name) const;
-        map<string, vector<int>> getStates(const string& name) const;
-        pair<vector<vector<float>>&, vector<int>&> getVectors(const string& name);
-        pair<vector<vector<int>>&, vector<int>&> getVectorsDiscretized(const string& name);
-        pair<torch::Tensor&, torch::Tensor&> getTensors(const string& name);
-        bool isDataset(const string& name) const;
-        void loadDataset(const string& name) const;
+        explicit Datasets(bool discretize, std::string sfileType) : discretize(discretize), sfileType(sfileType) { load(); };
+        std::vector<string> getNames();
+        std::vector<string> getFeatures(const std::string& name) const;
+        int getNSamples(const std::string& name) const;
+        std::string getClassName(const std::string& name) const;
+        int getNClasses(const std::string& name);
+        std::vector<int> getClassesCounts(const std::string& name) const;
+        std::map<std::string, std::vector<int>> getStates(const std::string& name) const;
+        std::pair<std::vector<std::vector<float>>&, std::vector<int>&> getVectors(const std::string& name);
+        std::pair<std::vector<std::vector<int>>&, std::vector<int>&> getVectorsDiscretized(const std::string& name);
+        std::pair<torch::Tensor&, torch::Tensor&> getTensors(const std::string& name);
+        bool isDataset(const std::string& name) const;
+        void loadDataset(const std::string& name) const;
    };
 };

--- a/src/Platform/DotEnv.h
+++ b/src/Platform/DotEnv.h
@@ -13,17 +13,6 @@ 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()
        {
--- a/src/Platform/ExcelFile.cc
+++ b/src/Platform/ExcelFile.cc
@@ -9,6 +9,10 @@ namespace platform {
    {
        setDefault();
    }
+    ExcelFile::ExcelFile(lxw_workbook* workbook, lxw_worksheet* worksheet) : workbook(workbook), worksheet(worksheet)
+    {
+        setDefault();
+    }
    void ExcelFile::setDefault()
    {
        normalSize = 14; //font size for report body
@@ -22,7 +26,7 @@ namespace platform {
    {
        return workbook;
    }
-    void ExcelFile::setProperties(string title)
+    void ExcelFile::setProperties(std::string title)
    {
        char line[title.size() + 1];
        strcpy(line, title.c_str());
@@ -36,34 +40,34 @@ namespace platform {
        };
        workbook_set_properties(workbook, &properties);
    }
-    lxw_format* ExcelFile::efectiveStyle(const string& style)
+    lxw_format* ExcelFile::efectiveStyle(const std::string& style)
    {
        lxw_format* efectiveStyle = NULL;
        if (style != "") {
-            string suffix = row % 2 ? "_odd" : "_even";
+            std::string suffix = row % 2 ? "_odd" : "_even";
            try {
                efectiveStyle = styles.at(style + suffix);
            }
-            catch (const out_of_range& oor) {
+            catch (const std::out_of_range& oor) {
                try {
                    efectiveStyle = styles.at(style);
                }
-                catch (const out_of_range& oor) {
-                    throw invalid_argument("Style " + style + " not found");
+                catch (const std::out_of_range& oor) {
+                    throw std::invalid_argument("Style " + style + " not found");
                }
            }
        }
        return efectiveStyle;
    }
-    void ExcelFile::writeString(int row, int col, const string& text, const string& style)
+    void ExcelFile::writeString(int row, int col, const std::string& text, const std::string& style)
    {
        worksheet_write_string(worksheet, row, col, text.c_str(), efectiveStyle(style));
    }
-    void ExcelFile::writeInt(int row, int col, const int number, const string& style)
+    void ExcelFile::writeInt(int row, int col, const int number, const std::string& style)
    {
        worksheet_write_number(worksheet, row, col, number, efectiveStyle(style));
    }
-    void ExcelFile::writeDouble(int row, int col, const double number, const string& style)
+    void ExcelFile::writeDouble(int row, int col, const double number, const std::string& style)
    {
        worksheet_write_number(worksheet, row, col, number, efectiveStyle(style));
    }
@@ -72,7 +76,7 @@ namespace platform {
        uint32_t efectiveColor = odd ? colorEven : colorOdd;
        format_set_bg_color(style, lxw_color_t(efectiveColor));
    }
-    void ExcelFile::createStyle(const string& name, lxw_format* style, bool odd)
+    void ExcelFile::createStyle(const std::string& name, lxw_format* style, bool odd)
    {
        addColor(style, odd);
        if (name == "textCentered") {
@@ -112,7 +116,7 @@ namespace platform {
    {
        auto styleNames = { "text", "textCentered", "bodyHeader", "result", "time", "ints", "floats" };
        lxw_format* style;
-        for (string name : styleNames) {
+        for (std::string name : styleNames) {
            lxw_format* style = workbook_add_format(workbook);
            style = workbook_add_format(workbook);
            createStyle(name, style, true);
--- a/src/Platform/ExcelFile.h
+++ b/src/Platform/ExcelFile.h
@@ -5,32 +5,32 @@
 #include <map>
 #include "xlsxwriter.h"

-using namespace std;
 namespace platform {
-    struct separated : numpunct<char> {
+    struct separated : std::numpunct<char> {
        char do_decimal_point() const { return ','; }

        char do_thousands_sep() const { return '.'; }

-        string do_grouping() const { return "\03"; }
+        std::string do_grouping() const { return "\03"; }
    };
    class ExcelFile {
    public:
        ExcelFile();
        ExcelFile(lxw_workbook* workbook);
+        ExcelFile(lxw_workbook* workbook, lxw_worksheet* worksheet);
        lxw_workbook* getWorkbook();
    protected:
-        void setProperties(string title);
-        void writeString(int row, int col, const string& text, const string& style = "");
-        void writeInt(int row, int col, const int number, const string& style = "");
-        void writeDouble(int row, int col, const double number, const string& style = "");
+        void setProperties(std::string title);
+        void writeString(int row, int col, const std::string& text, const std::string& style = "");
+        void writeInt(int row, int col, const int number, const std::string& style = "");
+        void writeDouble(int row, int col, const double number, const std::string& style = "");
        void createFormats();
-        void createStyle(const string& name, lxw_format* style, bool odd);
+        void createStyle(const std::string& name, lxw_format* style, bool odd);
        void addColor(lxw_format* style, bool odd);
-        lxw_format* efectiveStyle(const string& name);
+        lxw_format* efectiveStyle(const std::string& name);
        lxw_workbook* workbook;
        lxw_worksheet* worksheet;
-        map<string, lxw_format*> styles;
+        std::map<std::string, lxw_format*> styles;
        int row;
        int normalSize; //font size for report body
        uint32_t colorTitle;
--- a/src/Platform/Experiment.cc
+++ b/src/Platform/Experiment.cc
@@ -6,7 +6,7 @@
 #include "Paths.h"
 namespace platform {
    using json = nlohmann::json;
-    string get_date()
+    std::string get_date()
    {
        time_t rawtime;
        tm* timeinfo;
@@ -16,7 +16,7 @@ namespace platform {
        oss << std::put_time(timeinfo, "%Y-%m-%d");
        return oss.str();
    }
-    string get_time()
+    std::string get_time()
    {
        time_t rawtime;
        tm* timeinfo;
@@ -26,10 +26,9 @@ namespace platform {
        oss << std::put_time(timeinfo, "%H:%M:%S");
        return oss.str();
    }
-    Experiment::Experiment() : hyperparameters(json::parse("{}")) {}
-    string Experiment::get_file_name()
+    std::string Experiment::get_file_name()
    {
-        string result = "results_" + score_name + "_" + model + "_" + platform + "_" + get_date() + "_" + get_time() + "_" + (stratified ? "1" : "0") + ".json";
+        std::string result = "results_" + score_name + "_" + model + "_" + platform + "_" + get_date() + "_" + get_time() + "_" + (stratified ? "1" : "0") + ".json";
        return result;
    }

@@ -81,7 +80,7 @@ namespace platform {
        }
        return result;
    }
-    void Experiment::save(const string& path)
+    void Experiment::save(const std::string& path)
    {
        json data = build_json();
        ofstream file(path + "/" + get_file_name());
@@ -99,20 +98,20 @@ namespace platform {
    void Experiment::show()
    {
        json data = build_json();
-        cout << data.dump(4) << endl;
+        std::cout << data.dump(4) << std::endl;
    }

-    void Experiment::go(vector<string> filesToProcess)
+    void Experiment::go(std::vector<std::string> filesToProcess, bool quiet)
    {
-        cout << "*** Starting experiment: " << title << " ***" << endl;
+        std::cout << "*** Starting experiment: " << title << " ***" << std::endl;
        for (auto fileName : filesToProcess) {
-            cout << "- " << setw(20) << left << fileName << " " << right << flush;
-            cross_validation(fileName);
-            cout << endl;
+            std::cout << "- " << setw(20) << left << fileName << " " << right << flush;
+            cross_validation(fileName, quiet);
+            std::cout << std::endl;
        }
    }

-    string getColor(bayesnet::status_t status)
+    std::string getColor(bayesnet::status_t status)
    {
        switch (status) {
            case bayesnet::NORMAL:
@@ -126,28 +125,30 @@ namespace platform {
        }
    }

-    void showProgress(int fold, const string& color, const string& phase)
+    void showProgress(int fold, const std::string& color, const std::string& phase)
    {
-        string prefix = phase == "a" ? "" : "\b\b\b\b";
-        cout << prefix << color << fold << Colors::RESET() << "(" << color << phase << Colors::RESET() << ")" << flush;
+        std::string prefix = phase == "a" ? "" : "\b\b\b\b";
+        std::cout << prefix << color << fold << Colors::RESET() << "(" << color << phase << Colors::RESET() << ")" << flush;

    }
-    void Experiment::cross_validation(const string& fileName)
+    void Experiment::cross_validation(const std::string& fileName, bool quiet)
    {
-        auto datasets = platform::Datasets(discretized, Paths::datasets());
+        auto datasets = Datasets(discretized, Paths::datasets());
        // 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;
+        if (!quiet) {
+            std::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));
-        result.setHyperparameters(hyperparameters);
-        // Initialize results vectors
+        result.setHyperparameters(hyperparameters.get(fileName));
+        // Initialize results std::vectors
        int nResults = nfolds * static_cast<int>(randomSeeds.size());
        auto accuracy_test = torch::zeros({ nResults }, torch::kFloat64);
        auto accuracy_train = torch::zeros({ nResults }, torch::kFloat64);
@@ -159,7 +160,8 @@ namespace platform {
        Timer train_timer, test_timer;
        int item = 0;
        for (auto seed : randomSeeds) {
-            cout << "(" << seed << ") doing Fold: " << flush;
+            if (!quiet)
+                std::cout << "(" << seed << ") doing Fold: " << flush;
            Fold* fold;
            if (stratified)
                fold = new StratifiedKFold(nfolds, y, seed);
@@ -168,9 +170,9 @@ namespace platform {
            for (int nfold = 0; nfold < nfolds; nfold++) {
                auto clf = Models::instance()->create(model);
                setModelVersion(clf->getVersion());
-                if (hyperparameters.size() != 0) {
-                    clf->setHyperparameters(hyperparameters);
-                }
+                auto valid = clf->getValidHyperparameters();
+                hyperparameters.check(valid, fileName);
+                clf->setHyperparameters(hyperparameters.get(fileName));
                // Split train - test dataset
                train_timer.start();
                auto [train, test] = fold->getFold(nfold);
@@ -180,9 +182,11 @@ namespace platform {
                auto y_train = y.index({ train_t });
                auto X_test = X.index({ "...", test_t });
                auto y_test = y.index({ test_t });
+                if (!quiet)
                    showProgress(nfold + 1, getColor(clf->getStatus()), "a");
                // Train model
                clf->fit(X_train, y_train, features, className, states);
+                if (!quiet)
                    showProgress(nfold + 1, getColor(clf->getStatus()), "b");
                nodes[item] = clf->getNumberOfNodes();
                edges[item] = clf->getNumberOfEdges();
@@ -191,22 +195,24 @@ namespace platform {
                // Score train
                auto accuracy_train_value = clf->score(X_train, y_train);
                // Test model
+                if (!quiet)
                    showProgress(nfold + 1, getColor(clf->getStatus()), "c");
                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;
-                cout << "\b\b\b, " << flush;
-                // Store results and times in vector
+                if (!quiet)
+                    std::cout << "\b\b\b, " << flush;
+                // Store results and times in std::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++;
-                clf.reset();
            }
-            cout << "end. " << flush;
+            if (!quiet)
+                std::cout << "end. " << flush;
            delete fold;
        }
        result.setScoreTest(torch::mean(accuracy_test).item<double>()).setScoreTrain(torch::mean(accuracy_train).item<double>());
--- a/src/Platform/Experiment.h
+++ b/src/Platform/Experiment.h
@@ -3,41 +3,27 @@
 #include <torch/torch.h>
 #include <nlohmann/json.hpp>
 #include <string>
-#include <chrono>
 #include "Folding.h"
 #include "BaseClassifier.h"
+#include "HyperParameters.h"
 #include "TAN.h"
 #include "KDB.h"
 #include "AODE.h"
+#include "Timer.h"

-using namespace std;
 namespace platform {
    using json = nlohmann::json;
-    class Timer {
-    private:
-        chrono::high_resolution_clock::time_point begin;
-    public:
-        Timer() = default;
-        ~Timer() = default;
-        void start() { begin = chrono::high_resolution_clock::now(); }
-        double getDuration()
-        {
-            chrono::high_resolution_clock::time_point end = chrono::high_resolution_clock::now();
-            chrono::duration<double> time_span = chrono::duration_cast<chrono::duration<double>>(end - begin);
-            return time_span.count();
-        }
-    };
    class Result {
    private:
-        string dataset, model_version;
+        std::string dataset, model_version;
        json hyperparameters;
        int samples{ 0 }, features{ 0 }, classes{ 0 };
        double score_train{ 0 }, score_test{ 0 }, score_train_std{ 0 }, score_test_std{ 0 }, train_time{ 0 }, train_time_std{ 0 }, test_time{ 0 }, test_time_std{ 0 };
        float nodes{ 0 }, leaves{ 0 }, depth{ 0 };
-        vector<double> scores_train, scores_test, times_train, times_test;
+        std::vector<double> scores_train, scores_test, times_train, times_test;
    public:
        Result() = default;
-        Result& setDataset(const string& dataset) { this->dataset = dataset; return *this; }
+        Result& setDataset(const std::string& dataset) { this->dataset = dataset; return *this; }
        Result& setHyperparameters(const json& hyperparameters) { this->hyperparameters = hyperparameters; return *this; }
        Result& setSamples(int samples) { this->samples = samples; return *this; }
        Result& setFeatures(int features) { this->features = features; return *this; }
@@ -59,7 +45,7 @@ namespace platform {
        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; }
+        const std::string& getDataset() const { return dataset; }
        const json& getHyperparameters() const { return hyperparameters; }
        const int getSamples() const { return samples; }
        const int getFeatures() const { return features; }
@@ -75,43 +61,43 @@ namespace platform {
        const float getNodes() const { return nodes; }
        const float getLeaves() const { return leaves; }
        const float getDepth() const { return depth; }
-        const vector<double>& getScoresTrain() const { return scores_train; }
-        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 std::vector<double>& getScoresTrain() const { return scores_train; }
+        const std::vector<double>& getScoresTest() const { return scores_test; }
+        const std::vector<double>& getTimesTrain() const { return times_train; }
+        const std::vector<double>& getTimesTest() const { return times_test; }
    };
    class Experiment {
-    private:
-        string title, model, platform, score_name, model_version, language_version, language;
-        bool discretized{ false }, stratified{ false };
-        vector<Result> results;
-        vector<int> randomSeeds;
-        json hyperparameters = "{}";
-        int nfolds{ 0 };
-        float duration{ 0 };
-        json build_json();
    public:
-        Experiment();
-        Experiment& setTitle(const string& title) { this->title = title; return *this; }
-        Experiment& setModel(const string& model) { this->model = model; return *this; }
-        Experiment& setPlatform(const string& platform) { this->platform = platform; return *this; }
-        Experiment& setScoreName(const string& score_name) { this->score_name = score_name; return *this; }
-        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() = default;
+        Experiment& setTitle(const std::string& title) { this->title = title; return *this; }
+        Experiment& setModel(const std::string& model) { this->model = model; return *this; }
+        Experiment& setPlatform(const std::string& platform) { this->platform = platform; return *this; }
+        Experiment& setScoreName(const std::string& score_name) { this->score_name = score_name; return *this; }
+        Experiment& setModelVersion(const std::string& model_version) { this->model_version = model_version; return *this; }
+        Experiment& setLanguage(const std::string& language) { this->language = language; return *this; }
+        Experiment& setLanguageVersion(const std::string& language_version) { this->language_version = language_version; 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(int randomSeed) { randomSeeds.push_back(randomSeed); return *this; }
        Experiment& setDuration(float duration) { this->duration = duration; return *this; }
-        Experiment& setHyperparameters(const json& hyperparameters) { this->hyperparameters = hyperparameters; return *this; }
-        string get_file_name();
-        void save(const string& path);
-        void cross_validation(const string& fileName);
-        void go(vector<string> filesToProcess);
+        Experiment& setHyperparameters(const HyperParameters& hyperparameters_) { this->hyperparameters = hyperparameters_; return *this; }
+        std::string get_file_name();
+        void save(const std::string& path);
+        void cross_validation(const std::string& fileName, bool quiet);
+        void go(std::vector<std::string> filesToProcess, bool quiet);
        void show();
        void report();
+    private:
+        std::string title, model, platform, score_name, model_version, language_version, language;
+        bool discretized{ false }, stratified{ false };
+        std::vector<Result> results;
+        std::vector<int> randomSeeds;
+        HyperParameters hyperparameters;
+        int nfolds{ 0 };
+        float duration{ 0 };
+        json build_json();
    };
 }
 #endif
--- a/src/Platform/Folding.cc
+++ b/src/Platform/Folding.cc
@@ -4,23 +4,23 @@
 namespace platform {
    Fold::Fold(int k, int n, int seed) : k(k), n(n), seed(seed)
    {
-        random_device rd;
-        random_seed = default_random_engine(seed == -1 ? rd() : seed);
-        srand(seed == -1 ? time(0) : seed);
+        std::random_device rd;
+        random_seed = std::default_random_engine(seed == -1 ? rd() : seed);
+        std::srand(seed == -1 ? time(0) : seed);
    }
-    KFold::KFold(int k, int n, int seed) : Fold(k, n, seed), indices(vector<int>(n))
+    KFold::KFold(int k, int n, int seed) : Fold(k, n, seed), indices(std::vector<int>(n))
    {
-        iota(begin(indices), end(indices), 0); // fill with 0, 1, ..., n - 1
+        std::iota(begin(indices), end(indices), 0); // fill with 0, 1, ..., n - 1
        shuffle(indices.begin(), indices.end(), random_seed);
    }
-    pair<vector<int>, vector<int>> KFold::getFold(int nFold)
+    std::pair<std::vector<int>, std::vector<int>> KFold::getFold(int nFold)
    {
        if (nFold >= k || nFold < 0) {
-            throw out_of_range("nFold (" + to_string(nFold) + ") must be less than k (" + to_string(k) + ")");
+            throw std::out_of_range("nFold (" + std::to_string(nFold) + ") must be less than k (" + std::to_string(k) + ")");
        }
        int nTest = n / k;
-        auto train = vector<int>();
-        auto test = vector<int>();
+        auto train = std::vector<int>();
+        auto test = std::vector<int>();
        for (int i = 0; i < n; i++) {
            if (i >= nTest * nFold && i < nTest * (nFold + 1)) {
                test.push_back(indices[i]);
@@ -33,10 +33,10 @@ namespace platform {
    StratifiedKFold::StratifiedKFold(int k, torch::Tensor& y, int seed) : Fold(k, y.numel(), seed)
    {
        n = y.numel();
-        this->y = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + n);
+        this->y = std::vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + n);
        build();
    }
-    StratifiedKFold::StratifiedKFold(int k, const vector<int>& y, int seed)
+    StratifiedKFold::StratifiedKFold(int k, const std::vector<int>& y, int seed)
        : Fold(k, y.size(), seed)
    {
        this->y = y;
@@ -45,12 +45,12 @@ namespace platform {
    }
    void StratifiedKFold::build()
    {
-        stratified_indices = vector<vector<int>>(k);
+        stratified_indices = std::vector<std::vector<int>>(k);
        int fold_size = n / k;

        // Compute class counts and indices
-        auto class_indices = map<int, vector<int>>();
-        vector<int> class_counts(*max_element(y.begin(), y.end()) + 1, 0);
+        auto class_indices = std::map<int, std::vector<int>>();
+        std::vector<int> class_counts(*max_element(y.begin(), y.end()) + 1, 0);
        for (auto i = 0; i < n; ++i) {
            class_counts[y[i]]++;
            class_indices[y[i]].push_back(i);
@@ -63,8 +63,8 @@ namespace platform {
        for (auto label = 0; label < class_counts.size(); ++label) {
            auto num_samples_to_take = class_counts.at(label) / k;
            if (num_samples_to_take == 0) {
-                cerr << "Warning! The number of samples in class " << label << " (" << class_counts.at(label)
-                    << ") is less than the number of folds (" << k << ")." << endl;
+                std::cerr << "Warning! The number of samples in class " << label << " (" << class_counts.at(label)
+                    << ") is less than the number of folds (" << k << ")." << std::endl;
                faulty = true;
                continue;
            }
@@ -74,7 +74,7 @@ namespace platform {
                move(class_indices[label].begin(), it, back_inserter(stratified_indices[fold]));  // ##
                class_indices[label].erase(class_indices[label].begin(), it);
            }
-            auto chosen = vector<bool>(k, false);
+            auto chosen = std::vector<bool>(k, false);
            while (remainder_samples_to_take > 0) {
                int fold = (rand() % static_cast<int>(k));
                if (chosen.at(fold)) {
@@ -88,13 +88,13 @@ namespace platform {
            }
        }
    }
-    pair<vector<int>, vector<int>> StratifiedKFold::getFold(int nFold)
+    std::pair<std::vector<int>, std::vector<int>> StratifiedKFold::getFold(int nFold)
    {
        if (nFold >= k || nFold < 0) {
-            throw out_of_range("nFold (" + to_string(nFold) + ") must be less than k (" + to_string(k) + ")");
+            throw std::out_of_range("nFold (" + std::to_string(nFold) + ") must be less than k (" + std::to_string(k) + ")");
        }
-        vector<int> test_indices = stratified_indices[nFold];
-        vector<int> train_indices;
+        std::vector<int> test_indices = stratified_indices[nFold];
+        std::vector<int> train_indices;
        for (int i = 0; i < k; ++i) {
            if (i == nFold) continue;
            train_indices.insert(train_indices.end(), stratified_indices[i].begin(), stratified_indices[i].end());
--- a/src/Platform/Folding.h
+++ b/src/Platform/Folding.h
@@ -3,37 +3,36 @@
 #include <torch/torch.h>
 #include <vector>
 #include <random> 
-using namespace std;
 namespace platform {
    class Fold {
    protected:
        int k;
        int n;
        int seed;
-        default_random_engine random_seed;
+        std::default_random_engine random_seed;
    public:
        Fold(int k, int n, int seed = -1);
-        virtual pair<vector<int>, vector<int>> getFold(int nFold) = 0;
+        virtual std::pair<std::vector<int>, std::vector<int>> getFold(int nFold) = 0;
        virtual ~Fold() = default;
        int getNumberOfFolds() { return k; }
    };
    class KFold : public Fold {
    private:
-        vector<int> indices;
+        std::vector<int> indices;
    public:
        KFold(int k, int n, int seed = -1);
-        pair<vector<int>, vector<int>> getFold(int nFold) override;
+        std::pair<std::vector<int>, std::vector<int>> getFold(int nFold) override;
    };
    class StratifiedKFold : public Fold {
    private:
-        vector<int> y;
-        vector<vector<int>> stratified_indices;
+        std::vector<int> y;
+        std::vector<std::vector<int>> stratified_indices;
        void build();
        bool faulty = false; // Only true if the number of samples of any class is less than the number of folds.
    public:
-        StratifiedKFold(int k, const vector<int>& y, int seed = -1);
+        StratifiedKFold(int k, const std::vector<int>& y, int seed = -1);
        StratifiedKFold(int k, torch::Tensor& y, int seed = -1);
-        pair<vector<int>, vector<int>> getFold(int nFold) override;
+        std::pair<std::vector<int>, std::vector<int>> getFold(int nFold) override;
        bool isFaulty() { return faulty; }
    };
 }
--- a/src/Platform/GridData.cc
+++ b/src/Platform/GridData.cc
@@ -0,0 +1,75 @@
+#include "GridData.h"
+#include <fstream>
+
+namespace platform {
+    GridData::GridData(const std::string& fileName)
+    {
+        json grid_file;
+        std::ifstream resultData(fileName);
+        if (resultData.is_open()) {
+            grid_file = json::parse(resultData);
+        } else {
+            throw std::invalid_argument("Unable to open input file. [" + fileName + "]");
+        }
+        for (const auto& item : grid_file.items()) {
+            auto key = item.key();
+            auto value = item.value();
+            grid[key] = value;
+        }
+
+    }
+    int GridData::computeNumCombinations(const json& line)
+    {
+        int numCombinations = 1;
+        for (const auto& item : line.items()) {
+            numCombinations *= item.value().size();
+        }
+        return numCombinations;
+    }
+    int GridData::getNumCombinations(const std::string& dataset)
+    {
+        int numCombinations = 0;
+        auto selected = decide_dataset(dataset);
+        for (const auto& line : grid.at(selected)) {
+            numCombinations += computeNumCombinations(line);
+        }
+        return numCombinations;
+    }
+    json GridData::generateCombinations(json::iterator index, const json::iterator last, std::vector<json>& output, json currentCombination)
+    {
+        if (index == last) {
+            // If we reached the end of input, store the current combination
+            output.push_back(currentCombination);
+            return  currentCombination;
+        }
+        const auto& key = index.key();
+        const auto& values = index.value();
+        for (const auto& value : values) {
+            auto combination = currentCombination;
+            combination[key] = value;
+            json::iterator nextIndex = index;
+            generateCombinations(++nextIndex, last, output, combination);
+        }
+        return currentCombination;
+    }
+    std::vector<json> GridData::getGrid(const std::string& dataset)
+    {
+        auto selected = decide_dataset(dataset);
+        auto result = std::vector<json>();
+        for (json line : grid.at(selected)) {
+            generateCombinations(line.begin(), line.end(), result, json({}));
+        }
+        return result;
+    }
+    json& GridData::getInputGrid(const std::string& dataset)
+    {
+        auto selected = decide_dataset(dataset);
+        return grid.at(selected);
+    }
+    std::string GridData::decide_dataset(const std::string& dataset)
+    {
+        if (grid.find(dataset) != grid.end())
+            return dataset;
+        return ALL_DATASETS;
+    }
+} /* namespace platform */
--- a/src/Platform/GridData.h
+++ b/src/Platform/GridData.h
@@ -0,0 +1,26 @@
+#ifndef GRIDDATA_H
+#define GRIDDATA_H
+#include <string>
+#include <vector>
+#include <map>
+#include <nlohmann/json.hpp>
+
+namespace platform {
+    using json = nlohmann::json;
+    const std::string ALL_DATASETS = "all";
+    class GridData {
+    public:
+        explicit GridData(const std::string& fileName);
+        ~GridData() = default;
+        std::vector<json> getGrid(const std::string& dataset = ALL_DATASETS);
+        int getNumCombinations(const std::string& dataset = ALL_DATASETS);
+        json& getInputGrid(const std::string& dataset = ALL_DATASETS);
+        std::map<std::string, json>& getGridFile() { return grid; }
+    private:
+        std::string decide_dataset(const std::string& dataset);
+        json generateCombinations(json::iterator index, const json::iterator last, std::vector<json>& output, json currentCombination);
+        int computeNumCombinations(const json& line);
+        std::map<std::string, json> grid;
+    };
+} /* namespace platform */
+#endif /* GRIDDATA_H */
--- a/src/Platform/GridSearch.cc
+++ b/src/Platform/GridSearch.cc
@@ -0,0 +1,599 @@
+#include <iostream>
+#include <torch/torch.h>
+#include "GridSearch.h"
+#include "Models.h"
+#include "Paths.h"
+#include "Folding.h"
+#include "Colors.h"
+
+namespace platform {
+    std::string get_date()
+    {
+        time_t rawtime;
+        tm* timeinfo;
+        time(&rawtime);
+        timeinfo = std::localtime(&rawtime);
+        std::ostringstream oss;
+        oss << std::put_time(timeinfo, "%Y-%m-%d");
+        return oss.str();
+    }
+    std::string get_time()
+    {
+        time_t rawtime;
+        tm* timeinfo;
+        time(&rawtime);
+        timeinfo = std::localtime(&rawtime);
+        std::ostringstream oss;
+        oss << std::put_time(timeinfo, "%H:%M:%S");
+        return oss.str();
+    }
+    GridSearch::GridSearch(struct ConfigGrid& config) : config(config)
+    {
+    }
+    json GridSearch::getResults()
+    {
+        std::ifstream file(Paths::grid_output(config.model));
+        if (file.is_open()) {
+            return json::parse(file);
+        }
+        return json();
+    }
+    vector<std::string> GridSearch::processDatasets(Datasets& datasets)
+    {
+        // Load datasets
+        auto datasets_names = datasets.getNames();
+        if (config.continue_from != NO_CONTINUE()) {
+            // Continue previous execution:
+            if (std::find(datasets_names.begin(), datasets_names.end(), config.continue_from) == datasets_names.end()) {
+                throw std::invalid_argument("Dataset " + config.continue_from + " not found");
+            }
+            // Remove datasets already processed
+            vector< string >::iterator it = datasets_names.begin();
+            while (it != datasets_names.end()) {
+                if (*it != config.continue_from) {
+                    it = datasets_names.erase(it);
+                } else {
+                    if (config.only)
+                        ++it;
+                    else
+                        break;
+                }
+            }
+        }
+        // Exclude datasets
+        for (const auto& name : config.excluded) {
+            auto dataset = name.get<std::string>();
+            auto it = std::find(datasets_names.begin(), datasets_names.end(), dataset);
+            if (it == datasets_names.end()) {
+                throw std::invalid_argument("Dataset " + dataset + " already excluded or doesn't exist!");
+            }
+            datasets_names.erase(it);
+        }
+        return datasets_names;
+    }
+    void showProgressComb(const int num, const int n_folds, const int total, const std::string& color)
+    {
+        int spaces = int(log(total) / log(10)) + 1;
+        int magic = n_folds * 3 + 22 + 2 * spaces;
+        std::string prefix = num == 1 ? "" : string(magic, '\b') + string(magic + 1, ' ') + string(magic + 1, '\b');
+        std::cout << prefix << color << "(" << setw(spaces) << num << "/" << setw(spaces) << total << ") " << Colors::RESET() << flush;
+    }
+    void showProgressFold(int fold, const std::string& color, const std::string& phase)
+    {
+        std::string prefix = phase == "a" ? "" : "\b\b\b\b";
+        std::cout << prefix << color << fold << Colors::RESET() << "(" << color << phase << Colors::RESET() << ")" << flush;
+    }
+    std::string getColor(bayesnet::status_t status)
+    {
+        switch (status) {
+            case bayesnet::NORMAL:
+                return Colors::GREEN();
+            case bayesnet::WARNING:
+                return Colors::YELLOW();
+            case bayesnet::ERROR:
+                return Colors::RED();
+            default:
+                return Colors::RESET();
+        }
+    }
+    json GridSearch::build_tasks_mpi()
+    {
+        auto tasks = json::array();
+        auto grid = GridData(Paths::grid_input(config.model));
+        auto datasets = Datasets(false, Paths::datasets());
+        auto datasets_names = processDatasets(datasets);
+        for (const auto& dataset : datasets_names) {
+            for (const auto& seed : config.seeds) {
+                auto combinations = grid.getGrid(dataset);
+                for (int n_fold = 0; n_fold < config.n_folds; n_fold++) {
+                    json task = {
+                        { "dataset", dataset },
+                        { "seed", seed },
+                        { "fold", n_fold}
+                    };
+                    tasks.push_back(task);
+                }
+            }
+        }
+        // It's important to shuffle the array so heavy datasets are spread across the Workers
+        std::mt19937 g{ 271 }; // Use fixed seed to obtain the same shuffle
+        std::shuffle(tasks.begin(), tasks.end(), g);
+        std::cout << "Tasks size: " << tasks.size() << std::endl;
+        std::cout << "|";
+        for (int i = 0; i < tasks.size(); ++i) {
+            std::cout << (i + 1) % 10;
+        }
+        std::cout << "|" << std::endl << "|" << std::flush;
+        return tasks;
+    }
+    std::pair<int, int> GridSearch::part_range_mpi(int n_tasks, int nprocs, int rank)
+    {
+        int assigned = 0;
+        int remainder = n_tasks % nprocs;
+        int start = 0;
+        if (rank < remainder) {
+            assigned = n_tasks / nprocs + 1;
+        } else {
+            assigned = n_tasks / nprocs;
+            start = remainder;
+        }
+        start += rank * assigned;
+        int end = start + assigned;
+        if (rank == nprocs - 1) {
+            end = n_tasks;
+        }
+        return { start, end };
+    }
+    std::string get_color_rank(int rank)
+    {
+        auto colors = { Colors::RED(), Colors::GREEN(),  Colors::BLUE(), Colors::MAGENTA(), Colors::CYAN() };
+        return *(colors.begin() + rank % colors.size());
+    }
+    void GridSearch::process_task_mpi(struct ConfigMPI& config_mpi, json& task, Datasets& datasets, json& results)
+    {
+        // Process the task and store the result in the results json
+        Timer timer;
+        timer.start();
+        auto grid = GridData(Paths::grid_input(config.model));
+        auto dataset = task["dataset"].get<std::string>();
+        auto seed = task["seed"].get<int>();
+        auto n_fold = task["fold"].get<int>();
+        // Generate the hyperparamters combinations
+        auto combinations = grid.getGrid(dataset);
+        auto [X, y] = datasets.getTensors(dataset);
+        auto states = datasets.getStates(dataset);
+        auto features = datasets.getFeatures(dataset);
+        auto className = datasets.getClassName(dataset);
+        //
+        // Start working on task
+        //
+        Fold* fold;
+        if (config.stratified)
+            fold = new StratifiedKFold(config.n_folds, y, seed);
+        else
+            fold = new KFold(config.n_folds, y.size(0), seed);
+        auto [train, test] = fold->getFold(n_fold);
+        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 });
+        auto num = 0;
+        double best_fold_score = 0.0;
+        json best_fold_hyper;
+        for (const auto& hyperparam_line : combinations) {
+            auto hyperparameters = platform::HyperParameters(datasets.getNames(), hyperparam_line);
+            Fold* nested_fold;
+            if (config.stratified)
+                nested_fold = new StratifiedKFold(config.nested, y_train, seed);
+            else
+                nested_fold = new KFold(config.nested, y_train.size(0), seed);
+            double score = 0.0;
+            for (int n_nested_fold = 0; n_nested_fold < config.nested; n_nested_fold++) {
+                // Nested level fold
+                auto [train_nested, test_nested] = nested_fold->getFold(n_nested_fold);
+                auto train_nested_t = torch::tensor(train_nested);
+                auto test_nested_t = torch::tensor(test_nested);
+                auto X_nested_train = X_train.index({ "...", train_nested_t });
+                auto y_nested_train = y_train.index({ train_nested_t });
+                auto X_nested_test = X_train.index({ "...", test_nested_t });
+                auto y_nested_test = y_train.index({ test_nested_t });
+                // Build Classifier with selected hyperparameters
+                auto clf = Models::instance()->create(config.model);
+                auto valid = clf->getValidHyperparameters();
+                hyperparameters.check(valid, dataset);
+                clf->setHyperparameters(hyperparameters.get(dataset));
+                // Train model
+                clf->fit(X_nested_train, y_nested_train, features, className, states);
+                // Test model
+                score += clf->score(X_nested_test, y_nested_test);
+            }
+            delete nested_fold;
+            score /= config.nested;
+            if (score > best_fold_score) {
+                best_fold_score = score;
+                best_fold_hyper = hyperparam_line;
+            }
+        }
+        delete fold;
+        // Build Classifier with the best hyperparameters to obtain the best score
+        auto hyperparameters = platform::HyperParameters(datasets.getNames(), best_fold_hyper);
+        auto clf = Models::instance()->create(config.model);
+        auto valid = clf->getValidHyperparameters();
+        hyperparameters.check(valid, dataset);
+        clf->setHyperparameters(best_fold_hyper);
+        clf->fit(X_train, y_train, features, className, states);
+        best_fold_score = clf->score(X_test, y_test);
+        // Save results
+        results[dataset][std::to_string(n_fold)]["score"] = best_fold_score;
+        results[dataset][std::to_string(n_fold)]["hyperparameters"] = best_fold_hyper;
+        results[dataset][std::to_string(n_fold)]["seed"] = seed;
+        results[dataset][std::to_string(n_fold)]["duration"] = timer.getDuration();
+        std::cout << get_color_rank(config_mpi.rank) << "*" << std::flush;
+    }
+    void GridSearch::go_mpi(struct ConfigMPI& config_mpi)
+    {
+        /*
+         * Each task is a json object with the following structure:
+         * {
+         *   "dataset": "dataset_name",
+         *   "seed": # of seed to use,
+         *   "model": "model_name",
+         *   "Fold": # of fold to process
+         * }
+         *
+         * The overall process consists in these steps:
+            * 1. Manager will broadcast the tasks to all the processes
+            * 1.1 Broadcast the number of tasks
+            * 1.2 Broadcast the length of the following string
+            * 1.2 Broadcast the tasks as a char* string
+            * 2. Workers will receive the tasks and start the process
+            * 2.1 A method will tell each worker the range of tasks to process
+            * 2.2 Each worker will process the tasks and generate the best score for each task
+            * 3. Manager gather the scores from all the workers and find out the best hyperparameters for each dataset
+            * 3.1 Obtain the maximum size of the results message of all the workers
+            * 3.2 Gather all the results from the workers into the manager
+            * 3.3 Compile the results from all the workers
+            * 3.4 Filter the best hyperparameters for each dataset
+         */
+        char* msg;
+        int tasks_size;
+        if (config_mpi.rank == config_mpi.manager) {
+            timer.start();
+            auto tasks = build_tasks_mpi();
+            auto tasks_str = tasks.dump();
+            tasks_size = tasks_str.size();
+            msg = new char[tasks_size + 1];
+            strcpy(msg, tasks_str.c_str());
+        }
+        //
+        // 1. Manager will broadcast the tasks to all the processes
+        //
+        MPI_Bcast(&tasks_size, 1, MPI_INT, config_mpi.manager, MPI_COMM_WORLD);
+        if (config_mpi.rank != config_mpi.manager) {
+            msg = new char[tasks_size + 1];
+        }
+        MPI_Bcast(msg, tasks_size + 1, MPI_CHAR, config_mpi.manager, MPI_COMM_WORLD);
+        json tasks = json::parse(msg);
+        delete[] msg;
+        //
+        // 2. All Workers will receive the tasks and start the process
+        //
+        int num_tasks = tasks.size();
+        // 2.1 A method will tell each worker the range of tasks to process
+        auto [start, end] = part_range_mpi(num_tasks, config_mpi.n_procs, config_mpi.rank);
+        // 2.2 Each worker will process the tasks and return the best scores obtained
+        auto datasets = Datasets(config.discretize, Paths::datasets());
+        json results;
+        for (int i = start; i < end; ++i) {
+            // Process task
+            process_task_mpi(config_mpi, tasks[i], datasets, results);
+        }
+        int size = results.dump().size() + 1;
+        int max_size = 0;
+        //
+        // 3. Manager gather the scores from all the workers and find out the best hyperparameters for each dataset
+        //
+        //3.1 Obtain the maximum size of the results message of all the workers
+        MPI_Allreduce(&size, &max_size, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
+        // Assign the memory to the message and initialize it to 0s
+        char* total = NULL;
+        msg = new char[max_size];
+        strncpy(msg, results.dump().c_str(), size);
+        if (config_mpi.rank == config_mpi.manager) {
+            total = new char[max_size * config_mpi.n_procs];
+        }
+        // 3.2 Gather all the results from the workers into the manager
+        MPI_Gather(msg, max_size, MPI_CHAR, total, max_size, MPI_CHAR, config_mpi.manager, MPI_COMM_WORLD);
+        delete[] msg;
+        if (config_mpi.rank == config_mpi.manager) {
+            std::cout << Colors::RESET() << "|" << std::endl;
+            json total_results;
+            json best_results;
+            // 3.3 Compile the results from all the workers
+            for (int i = 0; i < config_mpi.n_procs; ++i) {
+                json partial_results = json::parse(total + i * max_size);
+                for (auto& [dataset, folds] : partial_results.items()) {
+                    for (auto& [fold, result] : folds.items()) {
+                        total_results[dataset][fold] = result;
+                    }
+                }
+            }
+            delete[] total;
+            // 3.4 Filter the best hyperparameters for each dataset
+            auto grid = GridData(Paths::grid_input(config.model));
+            for (auto& [dataset, folds] : total_results.items()) {
+                double best_score = 0.0;
+                double duration = 0.0;
+                json best_hyper;
+                for (auto& [fold, result] : folds.items()) {
+                    duration += result["duration"].get<double>();
+                    if (result["score"] > best_score) {
+                        best_score = result["score"];
+                        best_hyper = result["hyperparameters"];
+                    }
+                }
+                auto timer = Timer();
+                json result = {
+                    { "score", best_score },
+                    { "hyperparameters", best_hyper },
+                    { "date", get_date() + " " + get_time() },
+                    { "grid", grid.getInputGrid(dataset) },
+                    { "duration", timer.translate2String(duration) }
+                };
+                best_results[dataset] = result;
+            }
+            save(best_results);
+        }
+    }
+    void GridSearch::go()
+    {
+        timer.start();
+        auto grid_type = config.nested == 0 ? "Single" : "Nested";
+        auto datasets = Datasets(config.discretize, Paths::datasets());
+        auto datasets_names = processDatasets(datasets);
+        json results = initializeResults();
+        std::cout << "***************** Starting " << grid_type << " Gridsearch *****************" << std::endl;
+        std::cout << "input file=" << Paths::grid_input(config.model) << std::endl;
+        auto grid = GridData(Paths::grid_input(config.model));
+        Timer timer_dataset;
+        double bestScore = 0;
+        json bestHyperparameters;
+        for (const auto& dataset : datasets_names) {
+            if (!config.quiet)
+                std::cout << "- " << setw(20) << left << dataset << " " << right << flush;
+            auto combinations = grid.getGrid(dataset);
+            timer_dataset.start();
+            if (config.nested == 0)
+                // for dataset // for hyperparameters // for seed // for fold
+                tie(bestScore, bestHyperparameters) = processFileSingle(dataset, datasets, combinations);
+            else
+                // for dataset // for seed // for fold // for hyperparameters // for nested fold
+                tie(bestScore, bestHyperparameters) = processFileNested(dataset, datasets, combinations);
+            if (!config.quiet) {
+                std::cout << "end." << " Score: " << Colors::IBLUE() << setw(9) << setprecision(7) << fixed
+                    << bestScore << Colors::BLUE() << " [" << bestHyperparameters.dump() << "]"
+                    << Colors::RESET() << ::endl;
+            }
+            json result = {
+                { "score", bestScore },
+                { "hyperparameters", bestHyperparameters },
+                { "date", get_date() + " " + get_time() },
+                { "grid", grid.getInputGrid(dataset) },
+                { "duration", timer_dataset.getDurationString() }
+            };
+            results[dataset] = result;
+            // Save partial results
+            save(results);
+        }
+        // Save final results
+        save(results);
+        std::cout << "***************** Ending " << grid_type << " Gridsearch *******************" << std::endl;
+    }
+    pair<double, json> GridSearch::processFileSingle(std::string fileName, Datasets& datasets, vector<json>& combinations)
+    {
+        int num = 0;
+        double bestScore = 0.0;
+        json bestHyperparameters;
+        auto totalComb = combinations.size();
+        for (const auto& hyperparam_line : combinations) {
+            if (!config.quiet)
+                showProgressComb(++num, config.n_folds, totalComb, Colors::CYAN());
+            auto hyperparameters = platform::HyperParameters(datasets.getNames(), hyperparam_line);
+            // Get dataset
+            auto [X, y] = datasets.getTensors(fileName);
+            auto states = datasets.getStates(fileName);
+            auto features = datasets.getFeatures(fileName);
+            auto className = datasets.getClassName(fileName);
+            double totalScore = 0.0;
+            int numItems = 0;
+            for (const auto& seed : config.seeds) {
+                if (!config.quiet)
+                    std::cout << "(" << seed << ") doing Fold: " << flush;
+                Fold* fold;
+                if (config.stratified)
+                    fold = new StratifiedKFold(config.n_folds, y, seed);
+                else
+                    fold = new KFold(config.n_folds, y.size(0), seed);
+                for (int nfold = 0; nfold < config.n_folds; nfold++) {
+                    auto clf = Models::instance()->create(config.model);
+                    auto valid = clf->getValidHyperparameters();
+                    hyperparameters.check(valid, fileName);
+                    clf->setHyperparameters(hyperparameters.get(fileName));
+                    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 });
+                    // Train model
+                    if (!config.quiet)
+                        showProgressFold(nfold + 1, getColor(clf->getStatus()), "a");
+                    clf->fit(X_train, y_train, features, className, states);
+                    // Test model
+                    if (!config.quiet)
+                        showProgressFold(nfold + 1, getColor(clf->getStatus()), "b");
+                    totalScore += clf->score(X_test, y_test);
+                    numItems++;
+                    if (!config.quiet)
+                        std::cout << "\b\b\b,  \b" << flush;
+                }
+                delete fold;
+            }
+            double score = numItems == 0 ? 0.0 : totalScore / numItems;
+            if (score > bestScore) {
+                bestScore = score;
+                bestHyperparameters = hyperparam_line;
+            }
+        }
+        return { bestScore, bestHyperparameters };
+    }
+    pair<double, json> GridSearch::processFileNested(std::string fileName, Datasets& datasets, vector<json>& combinations)
+    {
+        // Get dataset
+        auto [X, y] = datasets.getTensors(fileName);
+        auto states = datasets.getStates(fileName);
+        auto features = datasets.getFeatures(fileName);
+        auto className = datasets.getClassName(fileName);
+        int spcs_combinations = int(log(combinations.size()) / log(10)) + 1;
+        double goatScore = 0.0;
+        json goatHyperparameters;
+        // for dataset // for seed // for fold // for hyperparameters // for nested fold
+        for (const auto& seed : config.seeds) {
+            Fold* fold;
+            if (config.stratified)
+                fold = new StratifiedKFold(config.n_folds, y, seed);
+            else
+                fold = new KFold(config.n_folds, y.size(0), seed);
+            double bestScore = 0.0;
+            json bestHyperparameters;
+            std::cout << "(" << seed << ") doing Fold: " << flush;
+            for (int nfold = 0; nfold < config.n_folds; nfold++) {
+                if (!config.quiet)
+                    std::cout << Colors::GREEN() << nfold + 1 << " " << flush;
+                // First level fold
+                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 });
+                auto num = 0;
+                json result_fold;
+                double hypScore = 0.0;
+                double bestHypScore = 0.0;
+                json bestHypHyperparameters;
+                for (const auto& hyperparam_line : combinations) {
+                    std::cout << "[" << setw(spcs_combinations) << ++num << "/" << setw(spcs_combinations)
+                        << combinations.size() << "] " << std::flush;
+                    Fold* nested_fold;
+                    if (config.stratified)
+                        nested_fold = new StratifiedKFold(config.nested, y_train, seed);
+                    else
+                        nested_fold = new KFold(config.nested, y_train.size(0), seed);
+                    for (int n_nested_fold = 0; n_nested_fold < config.nested; n_nested_fold++) {
+                        // Nested level fold
+                        auto [train_nested, test_nested] = nested_fold->getFold(n_nested_fold);
+                        auto train_nested_t = torch::tensor(train_nested);
+                        auto test_nested_t = torch::tensor(test_nested);
+                        auto X_nexted_train = X_train.index({ "...", train_nested_t });
+                        auto y_nested_train = y_train.index({ train_nested_t });
+                        auto X_nested_test = X_train.index({ "...", test_nested_t });
+                        auto y_nested_test = y_train.index({ test_nested_t });
+                        // Build Classifier with selected hyperparameters
+                        auto hyperparameters = platform::HyperParameters(datasets.getNames(), hyperparam_line);
+                        auto clf = Models::instance()->create(config.model);
+                        auto valid = clf->getValidHyperparameters();
+                        hyperparameters.check(valid, fileName);
+                        clf->setHyperparameters(hyperparameters.get(fileName));
+                        // Train model
+                        if (!config.quiet)
+                            showProgressFold(n_nested_fold + 1, getColor(clf->getStatus()), "a");
+                        clf->fit(X_nexted_train, y_nested_train, features, className, states);
+                        // Test model
+                        if (!config.quiet)
+                            showProgressFold(n_nested_fold + 1, getColor(clf->getStatus()), "b");
+                        hypScore += clf->score(X_nested_test, y_nested_test);
+                        if (!config.quiet)
+                            std::cout << "\b\b\b,  \b" << flush;
+                    }
+                    int magic = 3 * config.nested + 2 * spcs_combinations + 4;
+                    std::cout << string(magic, '\b') << string(magic, ' ') << string(magic, '\b') << flush;
+                    delete nested_fold;
+                    hypScore /= config.nested;
+                    if (hypScore > bestHypScore) {
+                        bestHypScore = hypScore;
+                        bestHypHyperparameters = hyperparam_line;
+                    }
+                }
+                // Build Classifier with selected hyperparameters
+                auto clf = Models::instance()->create(config.model);
+                clf->setHyperparameters(bestHypHyperparameters);
+                // Train model
+                if (!config.quiet)
+                    showProgressFold(nfold + 1, getColor(clf->getStatus()), "a");
+                clf->fit(X_train, y_train, features, className, states);
+                // Test model
+                if (!config.quiet)
+                    showProgressFold(nfold + 1, getColor(clf->getStatus()), "b");
+                double score = clf->score(X_test, y_test);
+                if (!config.quiet)
+                    std::cout << string(2 * config.nested - 1, '\b') << "," << string(2 * config.nested, ' ') << string(2 * config.nested - 1, '\b') << flush;
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestHyperparameters = bestHypHyperparameters;
+                }
+            }
+            if (bestScore > goatScore) {
+                goatScore = bestScore;
+                goatHyperparameters = bestHyperparameters;
+            }
+            delete fold;
+        }
+        return { goatScore, goatHyperparameters };
+    }
+    json GridSearch::initializeResults()
+    {
+        // Load previous results
+        json results;
+        if (config.continue_from != NO_CONTINUE()) {
+            if (!config.quiet)
+                std::cout << "* Loading previous results" << std::endl;
+            try {
+                std::ifstream file(Paths::grid_output(config.model));
+                if (file.is_open()) {
+                    results = json::parse(file);
+                    results = results["results"];
+                }
+            }
+            catch (const std::exception& e) {
+                std::cerr << "* There were no previous results" << std::endl;
+                std::cerr << "* Initizalizing new results" << std::endl;
+                results = json();
+            }
+        }
+        return results;
+    }
+    void GridSearch::save(json& results)
+    {
+        std::ofstream file(Paths::grid_output(config.model));
+        json output = {
+            { "model", config.model },
+            { "score", config.score },
+            { "discretize", config.discretize },
+            { "stratified", config.stratified },
+            { "n_folds", config.n_folds },
+            { "seeds", config.seeds },
+            { "date", get_date() + " " + get_time()},
+            { "nested", config.nested},
+            { "platform", config.platform },
+            { "duration", timer.getDurationString(true)},
+            { "results", results }
+
+        };
+        file << output.dump(4);
+    }
+} /* namespace platform */
--- a/src/Platform/GridSearch.h
+++ b/src/Platform/GridSearch.h
@@ -0,0 +1,54 @@
+#ifndef GRIDSEARCH_H
+#define GRIDSEARCH_H
+#include <string>
+#include <map>
+#include <mpi.h>
+#include <nlohmann/json.hpp>
+#include "Datasets.h"
+#include "HyperParameters.h"
+#include "GridData.h"
+#include "Timer.h"
+
+namespace platform {
+    using json = nlohmann::json;
+    struct ConfigGrid {
+        std::string model;
+        std::string score;
+        std::string continue_from;
+        std::string platform;
+        bool quiet;
+        bool only; // used with continue_from to only compute that dataset
+        bool discretize;
+        bool stratified;
+        int nested;
+        int n_folds;
+        json excluded;
+        std::vector<int> seeds;
+    };
+    struct ConfigMPI {
+        int rank;
+        int n_procs;
+        int manager;
+    };
+    class GridSearch {
+    public:
+        explicit GridSearch(struct ConfigGrid& config);
+        void go();
+        void go_mpi(struct ConfigMPI& config_mpi);
+        ~GridSearch() = default;
+        json getResults();
+        static inline std::string NO_CONTINUE() { return "NO_CONTINUE"; }
+    private:
+        void save(json& results);
+        json initializeResults();
+        vector<std::string> processDatasets(Datasets& datasets);
+        pair<double, json> processFileSingle(std::string fileName, Datasets& datasets, std::vector<json>& combinations);
+        pair<double, json> processFileNested(std::string fileName, Datasets& datasets, std::vector<json>& combinations);
+        struct ConfigGrid config;
+        pair<int, int> part_range_mpi(int n_tasks, int nprocs, int rank);
+        json build_tasks_mpi();
+        void process_task_mpi(struct ConfigMPI& config_mpi, json& task, Datasets& datasets, json& results);
+        Timer timer; // used to measure the time of the whole process
+    };
+} /* namespace platform */
+#endif /* GRIDSEARCH_H */
--- a/src/Platform/HyperParameters.cc
+++ b/src/Platform/HyperParameters.cc
@@ -0,0 +1,55 @@
+#include "HyperParameters.h"
+#include <fstream>
+#include <sstream>
+#include <iostream>
+
+namespace platform {
+    HyperParameters::HyperParameters(const std::vector<std::string>& datasets, const json& hyperparameters_)
+    {
+        // Initialize all datasets with the given hyperparameters
+        for (const auto& item : datasets) {
+            hyperparameters[item] = hyperparameters_;
+        }
+    }
+    // https://www.techiedelight.com/implode-a-vector-of-strings-into-a-comma-separated-string-in-cpp/
+    std::string join(std::vector<std::string> const& strings, std::string delim)
+    {
+        std::stringstream ss;
+        std::copy(strings.begin(), strings.end(),
+            std::ostream_iterator<std::string>(ss, delim.c_str()));
+        return ss.str();
+    }
+    HyperParameters::HyperParameters(const std::vector<std::string>& datasets, const std::string& hyperparameters_file)
+    {
+        // Check if file exists
+        std::ifstream file(hyperparameters_file);
+        if (!file.is_open()) {
+            throw std::runtime_error("File " + hyperparameters_file + " not found");
+        }
+        // Check if file is a json
+        json input_hyperparameters = json::parse(file);
+        // Check if hyperparameters are valid
+        for (const auto& dataset : datasets) {
+            if (!input_hyperparameters.contains(dataset)) {
+                std::cerr << "*Warning: Dataset " << dataset << " not found in hyperparameters file" << " assuming default hyperparameters" << std::endl;
+                hyperparameters[dataset] = json({});
+                continue;
+            }
+            hyperparameters[dataset] = input_hyperparameters[dataset]["hyperparameters"].get<json>();
+        }
+    }
+    void HyperParameters::check(const std::vector<std::string>& valid, const std::string& fileName)
+    {
+        json result = hyperparameters.at(fileName);
+        for (const auto& item : result.items()) {
+            if (find(valid.begin(), valid.end(), item.key()) == valid.end()) {
+                throw std::invalid_argument("Hyperparameter " + item.key() + " is not valid. Passed Hyperparameters are: "
+                    + result.dump(4) + "\n Valid hyperparameters are: {" + join(valid, ",") + "}");
+            }
+        }
+    }
+    json HyperParameters::get(const std::string& fileName)
+    {
+        return hyperparameters.at(fileName);
+    }
+} /* namespace platform */
--- a/src/Platform/HyperParameters.h
+++ b/src/Platform/HyperParameters.h
@@ -0,0 +1,23 @@
+#ifndef HYPERPARAMETERS_H
+#define HYPERPARAMETERS_H
+#include <string>
+#include <map>
+#include <vector>
+#include <nlohmann/json.hpp>
+
+namespace platform {
+    using json = nlohmann::json;
+    class HyperParameters {
+    public:
+        HyperParameters() = default;
+        explicit HyperParameters(const std::vector<std::string>& datasets, const json& hyperparameters_);
+        explicit HyperParameters(const std::vector<std::string>& datasets, const std::string& hyperparameters_file);
+        ~HyperParameters() = default;
+        bool notEmpty(const std::string& key) const { return !hyperparameters.at(key).empty(); }
+        void check(const std::vector<std::string>& valid, const std::string& fileName);
+        json get(const std::string& fileName);
+    private:
+        std::map<std::string, json> hyperparameters;
+    };
+} /* namespace platform */
+#endif /* HYPERPARAMETERS_H */
--- a/src/Platform/ManageResults.cc
+++ b/src/Platform/ManageResults.cc
@@ -0,0 +1,213 @@
+#include "ManageResults.h"
+#include "CommandParser.h"
+#include <filesystem>
+#include <tuple>
+#include "Colors.h"
+#include "CLocale.h"
+#include "Paths.h"
+#include "ReportConsole.h"
+#include "ReportExcel.h"
+
+namespace platform {
+
+    ManageResults::ManageResults(int numFiles, const std::string& model, const std::string& score, bool complete, bool partial, bool compare) :
+        numFiles{ numFiles }, complete{ complete }, partial{ partial }, compare{ compare }, results(Results(Paths::results(), model, score, complete, partial))
+    {
+        indexList = true;
+        openExcel = false;
+        workbook = NULL;
+        if (numFiles == 0) {
+            this->numFiles = results.size();
+        }
+    }
+    void ManageResults::doMenu()
+    {
+        if (results.empty()) {
+            std::cout << Colors::MAGENTA() << "No results found!" << Colors::RESET() << std::endl;
+            return;
+        }
+        results.sortDate();
+        list();
+        menu();
+        if (openExcel) {
+            workbook_close(workbook);
+        }
+        std::cout << Colors::RESET() << "Done!" << std::endl;
+    }
+    void ManageResults::list()
+    {
+        auto temp = ConfigLocale();
+        std::string suffix = numFiles != results.size() ? " of " + std::to_string(results.size()) : "";
+        std::stringstream oss;
+        oss << "Results on screen: " << numFiles << suffix;
+        std::cout << Colors::GREEN() << oss.str() << std::endl;
+        std::cout << std::string(oss.str().size(), '-') << std::endl;
+        if (complete) {
+            std::cout << Colors::MAGENTA() << "Only listing complete results" << std::endl;
+        }
+        if (partial) {
+            std::cout << Colors::MAGENTA() << "Only listing partial results" << std::endl;
+        }
+        auto i = 0;
+        int maxModel = results.maxModelSize();
+        std::cout << Colors::GREEN() << " #  Date       " << std::setw(maxModel) << std::left << "Model" << " Score Name  Score       C/P Duration  Title" << std::endl;
+        std::cout << "=== ========== " << std::string(maxModel, '=') << " =========== =========== === ========= =============================================================" << std::endl;
+        bool odd = true;
+        for (auto& result : results) {
+            auto color = odd ? Colors::BLUE() : Colors::CYAN();
+            std::cout << color << std::setw(3) << std::fixed << std::right << i++ << " ";
+            std::cout << result.to_string(maxModel) << std::endl;
+            if (i == numFiles) {
+                break;
+            }
+            odd = !odd;
+        }
+    }
+    bool ManageResults::confirmAction(const std::string& intent, const std::string& fileName) const
+    {
+        std::string color;
+        if (intent == "delete") {
+            color = Colors::RED();
+        } else {
+            color = Colors::YELLOW();
+        }
+        std::string line;
+        bool finished = false;
+        while (!finished) {
+            std::cout << color << "Really want to " << intent << " " << fileName << "? (y/n): ";
+            getline(std::cin, line);
+            finished = line.size() == 1 && (tolower(line[0]) == 'y' || tolower(line[0] == 'n'));
+        }
+        if (tolower(line[0]) == 'y') {
+            return true;
+        }
+        std::cout << "Not done!" << std::endl;
+        return false;
+    }
+    void ManageResults::report(const int index, const bool excelReport)
+    {
+        std::cout << Colors::YELLOW() << "Reporting " << results.at(index).getFilename() << std::endl;
+        auto data = results.at(index).load();
+        if (excelReport) {
+            ReportExcel reporter(data, compare, workbook);
+            reporter.show();
+            openExcel = true;
+            workbook = reporter.getWorkbook();
+            std::cout << "Adding sheet to " << Paths::excel() + Paths::excelResults() << std::endl;
+        } else {
+            ReportConsole reporter(data, compare);
+            reporter.show();
+        }
+    }
+    void ManageResults::showIndex(const int index, const int idx)
+    {
+        // Show a dataset result inside a report
+        auto data = results.at(index).load();
+        std::cout << Colors::YELLOW() << "Showing " << results.at(index).getFilename() << std::endl;
+        ReportConsole reporter(data, compare, idx);
+        reporter.show();
+    }
+    void ManageResults::sortList()
+    {
+        std::cout << Colors::YELLOW() << "Choose sorting field (date='d', score='s', duration='u', model='m'): ";
+        std::string line;
+        char option;
+        getline(std::cin, line);
+        if (line.size() == 0)
+            return;
+        if (line.size() > 1) {
+            std::cout << "Invalid option" << std::endl;
+            return;
+        }
+        option = line[0];
+        switch (option) {
+            case 'd':
+                results.sortDate();
+                break;
+            case 's':
+                results.sortScore();
+                break;
+            case 'u':
+                results.sortDuration();
+                break;
+            case 'm':
+                results.sortModel();
+                break;
+            default:
+                std::cout << "Invalid option" << std::endl;
+        }
+    }
+    void ManageResults::menu()
+    {
+        char option;
+        int index, subIndex;
+        bool finished = false;
+        std::string filename;
+        // tuple<Option, digit, requires value>
+        std::vector<std::tuple<std::string, char, bool>>  mainOptions = {
+            {"quit", 'q', false},
+            {"list", 'l', false},
+            {"delete", 'd', true},
+            {"hide", 'h', true},
+            {"sort", 's', false},
+            {"report", 'r', true},
+            {"excel", 'e', true}
+        };
+        std::vector<std::tuple<std::string, char, bool>> listOptions = {
+            {"report", 'r', true},
+            {"list", 'l', false},
+            {"quit", 'q', false}
+        };
+        auto parser = CommandParser();
+        while (!finished) {
+            if (indexList) {
+                std::tie(option, index) = parser.parse(Colors::GREEN(), mainOptions, 'r', numFiles - 1);
+            } else {
+                std::tie(option, subIndex) = parser.parse(Colors::MAGENTA(), listOptions, 'r', results.at(index).load()["results"].size() - 1);
+            }
+            switch (option) {
+                case 'q':
+                    finished = true;
+                    break;
+                case 'l':
+                    list();
+                    indexList = true;
+                    break;
+                case 'd':
+                    filename = results.at(index).getFilename();
+                    if (!confirmAction("delete", filename))
+                        break;
+                    std::cout << "Deleting " << filename << std::endl;
+                    results.deleteResult(index);
+                    std::cout << "File: " + filename + " deleted!" << std::endl;
+                    list();
+                    break;
+                case 'h':
+                    filename = results.at(index).getFilename();
+                    if (!confirmAction("hide", filename))
+                        break;
+                    filename = results.at(index).getFilename();
+                    std::cout << "Hiding " << filename << std::endl;
+                    results.hideResult(index, Paths::hiddenResults());
+                    std::cout << "File: " + filename + " hidden! (moved to " << Paths::hiddenResults() << ")" << std::endl;
+                    list();
+                    break;
+                case 's':
+                    sortList();
+                    list();
+                    break;
+                case 'r':
+                    if (indexList) {
+                        report(index, false);
+                        indexList = false;
+                    } else {
+                        showIndex(index, subIndex);
+                    }
+                    break;
+                case 'e':
+                    report(index, true);
+                    break;
+            }
+        }
+    }
+} /* namespace platform */
--- a/src/Platform/ManageResults.h
+++ b/src/Platform/ManageResults.h
@@ -0,0 +1,31 @@
+#ifndef MANAGE_RESULTS_H
+#define MANAGE_RESULTS_H
+#include "Results.h"
+#include "xlsxwriter.h"
+
+namespace platform {
+    class ManageResults {
+    public:
+        ManageResults(int numFiles, const std::string& model, const std::string& score, bool complete, bool partial, bool compare);
+        ~ManageResults() = default;
+        void doMenu();
+    private:
+        void list();
+        bool confirmAction(const std::string& intent, const std::string& fileName) const;
+        void report(const int index, const bool excelReport);
+        void showIndex(const int index, const int idx);
+        void sortList();
+        void menu();
+        int numFiles;
+        bool indexList;
+        bool openExcel;
+        bool complete;
+        bool partial;
+        bool compare;
+        Results results;
+        lxw_workbook* workbook;
+    };
+
+}
+
+#endif /* MANAGE_RESULTS_H */
--- a/src/Platform/Models.cc
+++ b/src/Platform/Models.cc
@@ -1,6 +1,5 @@
 #include "Models.h"
 namespace platform {
-    using namespace std;
    // Idea from: https://www.codeproject.com/Articles/567242/AplusC-2b-2bplusObjectplusFactory
    Models* Models::factory = nullptr;;
    Models* Models::instance()
@@ -10,13 +9,13 @@ namespace platform {
            factory = new Models();
        return factory;
    }
-    void Models::registerFactoryFunction(const string& name,
+    void Models::registerFactoryFunction(const std::string& name,
        function<bayesnet::BaseClassifier* (void)> classFactoryFunction)
    {
        // register the class factory function
        functionRegistry[name] = classFactoryFunction;
    }
-    shared_ptr<bayesnet::BaseClassifier> Models::create(const string& name)
+    shared_ptr<bayesnet::BaseClassifier> Models::create(const std::string& name)
    {
        bayesnet::BaseClassifier* instance = nullptr;

@@ -30,23 +29,22 @@ namespace platform {
        else
            return nullptr;
    }
-    vector<string> Models::getNames()
+    std::vector<std::string> Models::getNames()
    {
-        vector<string> names;
+        std::vector<std::string> names;
        transform(functionRegistry.begin(), functionRegistry.end(), back_inserter(names),
-            [](const pair<string, function<bayesnet::BaseClassifier* (void)>>& pair) { return pair.first; });
+            [](const pair<std::string, function<bayesnet::BaseClassifier* (void)>>& pair) { return pair.first; });
        return names;
    }
-    string Models::toString()
+    std::string Models::tostring()
    {
-        string result = "";
+        std::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)
+    Registrar::Registrar(const std::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
@@ -11,10 +11,14 @@
 #include "SPODELd.h"
 #include "AODELd.h"
 #include "BoostAODE.h"
+#include "STree.h"
+#include "ODTE.h"
+#include "SVC.h"
+#include "RandomForest.h"
 namespace platform {
    class Models {
    private:
-        map<string, function<bayesnet::BaseClassifier* (void)>> functionRegistry;
+        map<std::string, function<bayesnet::BaseClassifier* (void)>> functionRegistry;
        static Models* factory; //singleton
        Models() {};
    public:
@@ -22,16 +26,16 @@ namespace platform {
        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,
+        shared_ptr<bayesnet::BaseClassifier> create(const std::string& name);
+        void registerFactoryFunction(const std::string& name,
            function<bayesnet::BaseClassifier* (void)> classFactoryFunction);
-        vector<string> getNames();
-        string toString();
+        std::vector<string> getNames();
+        std::string tostring();

    };
    class Registrar {
    public:
-        Registrar(const string& className, function<bayesnet::BaseClassifier* (void)> classFactoryFunction);
+        Registrar(const std::string& className, function<bayesnet::BaseClassifier* (void)> classFactoryFunction);
    };
 }
 #endif
--- a/src/Platform/Paths.h
+++ b/src/Platform/Paths.h
@@ -1,18 +1,39 @@
 #ifndef PATHS_H
 #define PATHS_H
 #include <string>
+#include <filesystem>
 #include "DotEnv.h"
 namespace platform {
    class Paths {
    public:
        static std::string results() { return "results/"; }
+        static std::string hiddenResults() { return "hidden_results/"; }
        static std::string excel() { return "excel/"; }
-        static std::string cfs() { return "cfs/"; }
+        static std::string grid() { return "grid/"; }
        static std::string datasets()
        {
            auto env = platform::DotEnv();
            return env.get("source_data");
        }
+        static void createPath(const std::string& path)
+        {
+            // Create directory if it does not exist
+            try {
+                std::filesystem::create_directory(path);
+            }
+            catch (std::exception& e) {
+                throw std::runtime_error("Could not create directory " + path);
+            }
+        }
+        static std::string excelResults() { return "some_results.xlsx"; }
+        static std::string grid_input(const std::string& model)
+        {
+            return grid() + "grid_" + model + "_input.json";
+        }
+        static std::string grid_output(const std::string& model)
+        {
+            return grid() + "grid_" + model + "_output.json";
+        }
    };
 }
 #endif
--- a/src/Platform/ReportBase.cc
+++ b/src/Platform/ReportBase.cc
@@ -2,14 +2,13 @@
 #include <locale>
 #include "Datasets.h"
 #include "ReportBase.h"
-#include "BestScore.h"
 #include "DotEnv.h"

 namespace platform {
    ReportBase::ReportBase(json data_, bool compare) : data(data_), compare(compare), margin(0.1)
    {
-        stringstream oss;
-        oss << "Better than ZeroR + " << setprecision(1) << fixed << margin * 100 << "%";
+        std::stringstream oss;
+        oss << "Better than ZeroR + " << std::setprecision(1) << fixed << margin * 100 << "%";
        meaning = {
            {Symbols::equal_best, "Equal to best"},
            {Symbols::better_best, "Better than best"},
@@ -17,10 +16,10 @@ namespace platform {
            {Symbols::upward_arrow, oss.str()}
        };
    }
-    string ReportBase::fromVector(const string& key)
+    std::string ReportBase::fromVector(const std::string& key)
    {
-        stringstream oss;
-        string sep = "";
+        std::stringstream oss;
+        std::string sep = "";
        oss << "[";
        for (auto& item : data[key]) {
            oss << sep << item.get<double>();
@@ -29,13 +28,13 @@ namespace platform {
        oss << "]";
        return oss.str();
    }
-    string ReportBase::fVector(const string& title, const json& data, const int width, const int precision)
+    std::string ReportBase::fVector(const std::string& title, const json& data, const int width, const int precision)
    {
-        stringstream oss;
-        string sep = "";
+        std::stringstream oss;
+        std::string sep = "";
        oss << title << "[";
        for (const auto& item : data) {
-            oss << sep << fixed << setw(width) << setprecision(precision) << item.get<double>();
+            oss << sep << fixed << setw(width) << std::setprecision(precision) << item.get<double>();
            sep = ", ";
        }
        oss << "]";
@@ -46,25 +45,25 @@ namespace platform {
        header();
        body();
    }
-    string ReportBase::compareResult(const string& dataset, double result)
+    std::string ReportBase::compareResult(const std::string& dataset, double result)
    {
-        string status = " ";
+        std::string status = " ";
        if (compare) {
-            double best = bestResult(dataset, data["model"].get<string>());
+            double best = bestResult(dataset, data["model"].get<std::string>());
            if (result == best) {
                status = Symbols::equal_best;
            } else if (result > best) {
                status = Symbols::better_best;
            }
        } else {
-            if (data["score_name"].get<string>() == "accuracy") {
+            if (data["score_name"].get<std::string>() == "accuracy") {
                auto dt = Datasets(false, Paths::datasets());
                dt.loadDataset(dataset);
                auto numClasses = dt.getNClasses(dataset);
                if (numClasses == 2) {
-                    vector<int> distribution = dt.getClassesCounts(dataset);
+                    std::vector<int> distribution = dt.getClassesCounts(dataset);
                    double nSamples = dt.getNSamples(dataset);
-                    vector<int>::iterator maxValue = max_element(distribution.begin(), distribution.end());
+                    std::vector<int>::iterator maxValue = max_element(distribution.begin(), distribution.end());
                    double mark = *maxValue / nSamples * (1 + margin);
                    if (mark > 1) {
                        mark = 0.9995;
@@ -83,14 +82,14 @@ namespace platform {
        }
        return status;
    }
-    double ReportBase::bestResult(const string& dataset, const string& model)
+    double ReportBase::bestResult(const std::string& dataset, const std::string& model)
    {
        double value = 0.0;
        if (bestResults.size() == 0) {
            // try to load the best results
-            string score = data["score_name"];
+            std::string score = data["score_name"];
            replace(score.begin(), score.end(), '_', '-');
-            string fileName = "best_results_" + score + "_" + model + ".json";
+            std::string fileName = "best_results_" + score + "_" + model + ".json";
            ifstream resultData(Paths::results() + "/" + fileName);
            if (resultData.is_open()) {
                bestResults = json::parse(resultData);
--- a/src/Platform/ReportBase.h
+++ b/src/Platform/ReportBase.h
@@ -8,7 +8,6 @@

 using json = nlohmann::json;
 namespace platform {
-    using namespace std;

    class ReportBase {
    public:
@@ -17,19 +16,19 @@ namespace platform {
        void show();
    protected:
        json data;
-        string fromVector(const string& key);
-        string fVector(const string& title, const json& data, const int width, const int precision);
+        std::string fromVector(const std::string& key);
+        std::string fVector(const std::string& title, const json& data, const int width, const int precision);
        bool getExistBestFile();
        virtual void header() = 0;
        virtual void body() = 0;
        virtual void showSummary() = 0;
-        string compareResult(const string& dataset, double result);
-        map<string, int> summary;
+        std::string compareResult(const std::string& dataset, double result);
+        std::map<std::string, int> summary;
        double margin;
-        map<string, string> meaning;
+        std::map<std::string, std::string> meaning;
        bool compare;
    private:
-        double bestResult(const string& dataset, const string& model);
+        double bestResult(const std::string& dataset, const std::string& model);
        json bestResults;
        bool existBestFile = true;
    };
--- a/src/Platform/ReportConsole.cc
+++ b/src/Platform/ReportConsole.cc
@@ -1,3 +1,4 @@
+#include <iostream>
 #include <sstream>
 #include <locale>
 #include "ReportConsole.h"
@@ -5,31 +6,43 @@
 #include "CLocale.h"

 namespace platform {
-    string ReportConsole::headerLine(const string& text, int utf = 0)
+    std::string ReportConsole::headerLine(const std::string& text, int utf = 0)
    {
        int n = MAXL - text.length() - 3;
        n = n < 0 ? 0 : n;
-        return "* " + text + string(n + utf, ' ') + "*\n";
+        return "* " + text + std::string(n + utf, ' ') + "*\n";
    }

    void ReportConsole::header()
    {
-        stringstream oss;
-        cout << Colors::MAGENTA() << string(MAXL, '*') << endl;
-        cout << headerLine("Report " + data["model"].get<string>() + " ver. " + data["version"].get<string>() + " with " + to_string(data["folds"].get<int>()) + " Folds cross validation and " + to_string(data["seeds"].size()) + " random seeds. " + data["date"].get<string>() + " " + data["time"].get<string>());
-        cout << headerLine(data["title"].get<string>());
-        cout << headerLine("Random seeds: " + fromVector("seeds") + " Stratified: " + (data["stratified"].get<bool>() ? "True" : "False"));
-        oss << "Execution took  " << setprecision(2) << fixed << data["duration"].get<float>() << " seconds,   " << data["duration"].get<float>() / 3600 << " hours, on " << data["platform"].get<string>();
-        cout << headerLine(oss.str());
-        cout << headerLine("Score is " + data["score_name"].get<string>());
-        cout << string(MAXL, '*') << endl;
-        cout << endl;
+        std::stringstream oss;
+        std::cout << Colors::MAGENTA() << std::string(MAXL, '*') << std::endl;
+        std::cout << headerLine(
+            "Report " + data["model"].get<std::string>() + " ver. " + data["version"].get<std::string>()
+            + " with " + std::to_string(data["folds"].get<int>()) + " Folds cross validation and " + std::to_string(data["seeds"].size())
+            + " random seeds. " + data["date"].get<std::string>() + " " + data["time"].get<std::string>()
+        );
+        std::cout << headerLine(data["title"].get<std::string>());
+        std::cout << headerLine("Random seeds: " + fromVector("seeds") + " Stratified: " + (data["stratified"].get<bool>() ? "True" : "False"));
+        oss << "Execution took  " << std::setprecision(2) << std::fixed << data["duration"].get<float>()
+            << " seconds,   " << data["duration"].get<float>() / 3600 << " hours, on " << data["platform"].get<std::string>();
+        std::cout << headerLine(oss.str());
+        std::cout << headerLine("Score is " + data["score_name"].get<std::string>());
+        std::cout << std::string(MAXL, '*') << std::endl;
+        std::cout << std::endl;
    }
    void ReportConsole::body()
    {
        auto tmp = ConfigLocale();
-        cout << Colors::GREEN() << " #  Dataset                   Sampl. Feat. Cls Nodes     Edges     States    Score           Time                Hyperparameters" << endl;
-        cout << "=== ========================= ====== ===== === ========= ========= ========= =============== =================== ====================" << endl;
+        int maxHyper = 15;
+        int maxDataset = 7;
+        for (const auto& r : data["results"]) {
+            maxHyper = std::max(maxHyper, (int)r["hyperparameters"].dump().size());
+            maxDataset = std::max(maxDataset, (int)r["dataset"].get<std::string>().size());
+
+        }
+        std::cout << Colors::GREEN() << " #  " << std::setw(maxDataset) << std::left << "Dataset" << " Sampl. Feat. Cls Nodes     Edges     States    Score           Time                Hyperparameters" << std::endl;
+        std::cout << "=== " << std::string(maxDataset, '=') << " ====== ===== === ========= ========= ========= =============== =================== " << std::string(maxHyper, '=') << std::endl;
        json lastResult;
        double totalScore = 0.0;
        bool odd = true;
@@ -40,33 +53,33 @@ namespace platform {
                continue;
            }
            auto color = odd ? Colors::CYAN() : Colors::BLUE();
-            cout << color;
-            cout << setw(3) << index++ << " ";
-            cout << setw(25) << 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(9) << setprecision(2) << fixed << r["nodes"].get<float>() << " ";
-            cout << setw(9) << setprecision(2) << fixed << r["leaves"].get<float>() << " ";
-            cout << setw(9) << setprecision(2) << fixed << r["depth"].get<float>() << " ";
-            cout << setw(8) << right << setprecision(6) << fixed << r["score"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["score_std"].get<double>();
-            const string status = compareResult(r["dataset"].get<string>(), r["score"].get<double>());
-            cout << status;
-            cout << setw(12) << right << setprecision(6) << fixed << r["time"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["time_std"].get<double>() << " ";
-            cout << r["hyperparameters"].dump();
-            cout << endl;
-            cout << flush;
+            std::cout << color;
+            std::cout << std::setw(3) << std::right << index++ << " ";
+            std::cout << std::setw(maxDataset) << std::left << r["dataset"].get<std::string>() << " ";
+            std::cout << std::setw(6) << std::right << r["samples"].get<int>() << " ";
+            std::cout << std::setw(5) << std::right << r["features"].get<int>() << " ";
+            std::cout << std::setw(3) << std::right << r["classes"].get<int>() << " ";
+            std::cout << std::setw(9) << std::setprecision(2) << std::fixed << r["nodes"].get<float>() << " ";
+            std::cout << std::setw(9) << std::setprecision(2) << std::fixed << r["leaves"].get<float>() << " ";
+            std::cout << std::setw(9) << std::setprecision(2) << std::fixed << r["depth"].get<float>() << " ";
+            std::cout << std::setw(8) << std::right << std::setprecision(6) << std::fixed << r["score"].get<double>() << "±" << std::setw(6) << std::setprecision(4) << std::fixed << r["score_std"].get<double>();
+            const std::string status = compareResult(r["dataset"].get<std::string>(), r["score"].get<double>());
+            std::cout << status;
+            std::cout << std::setw(12) << std::right << std::setprecision(6) << std::fixed << r["time"].get<double>() << "±" << std::setw(6) << std::setprecision(4) << std::fixed << r["time_std"].get<double>() << " ";
+            std::cout << r["hyperparameters"].dump();
+            std::cout << std::endl;
+            std::cout << std::flush;
            lastResult = r;
            totalScore += r["score"].get<double>();
            odd = !odd;
        }
        if (data["results"].size() == 1 || selectedIndex != -1) {
-            cout << string(MAXL, '*') << endl;
-            cout << headerLine(fVector("Train scores: ", lastResult["scores_train"], 14, 12));
-            cout << headerLine(fVector("Test  scores: ", lastResult["scores_test"], 14, 12));
-            cout << headerLine(fVector("Train  times: ", lastResult["times_train"], 10, 3));
-            cout << headerLine(fVector("Test   times: ", lastResult["times_test"], 10, 3));
-            cout << string(MAXL, '*') << endl;
+            std::cout << std::string(MAXL, '*') << std::endl;
+            std::cout << headerLine(fVector("Train scores: ", lastResult["scores_train"], 14, 12));
+            std::cout << headerLine(fVector("Test  scores: ", lastResult["scores_test"], 14, 12));
+            std::cout << headerLine(fVector("Train  times: ", lastResult["times_train"], 10, 3));
+            std::cout << headerLine(fVector("Test   times: ", lastResult["times_test"], 10, 3));
+            std::cout << std::string(MAXL, '*') << std::endl;
        } else {
            footer(totalScore);
        }
@@ -74,27 +87,28 @@ namespace platform {
    void ReportConsole::showSummary()
    {
        for (const auto& item : summary) {
-            stringstream oss;
-            oss << setw(3) << left << item.first;
-            oss << setw(3) << right << item.second << " ";
-            oss << left << meaning.at(item.first);
-            cout << headerLine(oss.str(), 2);
+            std::stringstream oss;
+            oss << std::setw(3) << std::left << item.first;
+            oss << std::setw(3) << std::right << item.second << " ";
+            oss << std::left << meaning.at(item.first);
+            std::cout << headerLine(oss.str(), 2);
        }
    }

    void ReportConsole::footer(double totalScore)
    {
-        cout << Colors::MAGENTA() << string(MAXL, '*') << endl;
+        std::cout << Colors::MAGENTA() << std::string(MAXL, '*') << std::endl;
        showSummary();
-        auto score = data["score_name"].get<string>();
-        if (score == BestScore::scoreName()) {
-            stringstream oss;
-            oss << score << " compared to " << BestScore::title() << " .:  " << totalScore / BestScore::score();
-            cout << headerLine(oss.str());
+        auto score = data["score_name"].get<std::string>();
+        auto best = BestScore::getScore(score);
+        if (best.first != "") {
+            std::stringstream oss;
+            oss << score << " compared to " << best.first << " .:  " << totalScore / best.second;
+            std::cout << headerLine(oss.str());
        }
        if (!getExistBestFile() && compare) {
-            cout << headerLine("*** Best Results File not found. Couldn't compare any result!");
+            std::cout << headerLine("*** Best Results File not found. Couldn't compare any result!");
        }
-        cout << string(MAXL, '*') << endl << Colors::RESET();
+        std::cout << std::string(MAXL, '*') << std::endl << Colors::RESET();
    }
 }
--- a/src/Platform/ReportConsole.h
+++ b/src/Platform/ReportConsole.h
@@ -1,12 +1,10 @@
 #ifndef REPORTCONSOLE_H
 #define REPORTCONSOLE_H
 #include <string>
-#include <iostream>
 #include "ReportBase.h"
 #include "Colors.h"

 namespace platform {
-    using namespace std;
    const int MAXL = 133;
    class ReportConsole : public ReportBase {
    public:
@@ -14,7 +12,7 @@ namespace platform {
        virtual ~ReportConsole() = default;
    private:
        int selectedIndex;
-        string headerLine(const string& text, int utf);
+        std::string headerLine(const std::string& text, int utf);
        void header() override;
        void body() override;
        void footer(double totalScore);
--- a/src/Platform/ReportExcel.cc
+++ b/src/Platform/ReportExcel.cc
@@ -6,7 +6,7 @@

 namespace platform {

-    ReportExcel::ReportExcel(json data_, bool compare, lxw_workbook* workbook) : ReportBase(data_, compare), ExcelFile(workbook)
+    ReportExcel::ReportExcel(json data_, bool compare, lxw_workbook* workbook, lxw_worksheet* worksheet) : ReportBase(data_, compare), ExcelFile(workbook, worksheet)
    {
        createFile();
    }
@@ -14,36 +14,41 @@ namespace platform {
    void ReportExcel::formatColumns()
    {
        worksheet_freeze_panes(worksheet, 6, 1);
-        vector<int> columns_sizes = { 22, 10, 9, 7, 12, 12, 12, 12, 12, 3, 15, 12, 23 };
+        std::vector<int> columns_sizes = { 22, 10, 9, 7, 12, 12, 12, 12, 12, 3, 15, 12, 23 };
        for (int i = 0; i < columns_sizes.size(); ++i) {
            worksheet_set_column(worksheet, i, i, columns_sizes.at(i), NULL);
        }
    }
+    void ReportExcel::createWorksheet()
+    {
+        const std::string name = data["model"].get<std::string>();
+        std::string suffix = "";
+        std::string efectiveName;
+        int num = 1;
+        // Create a sheet with the name of the model
+        while (true) {
+            efectiveName = name + suffix;
+            if (workbook_get_worksheet_by_name(workbook, efectiveName.c_str())) {
+                suffix = std::to_string(++num);
+            } else {
+                worksheet = workbook_add_worksheet(workbook, efectiveName.c_str());
+                break;
+            }
+            if (num > 100) {
+                throw std::invalid_argument("Couldn't create sheet " + efectiveName);
+            }
+        }
+    }

    void ReportExcel::createFile()
    {
        if (workbook == NULL) {
-            workbook = workbook_new((Paths::excel() + fileName).c_str());
+            workbook = workbook_new((Paths::excel() + Paths::excelResults()).c_str());
        }
-        const string name = data["model"].get<string>();
-        string suffix = "";
-        string efectiveName;
-        int num = 1;
-        // Create a sheet with the name of the model
-        while (true) {
-            efectiveName = name + suffix;
-            if (workbook_get_worksheet_by_name(workbook, efectiveName.c_str())) {
-                suffix = to_string(++num);
-            } else {
-                worksheet = workbook_add_worksheet(workbook, efectiveName.c_str());
-                break;
+        if (worksheet == NULL) {
+            createWorksheet();
        }
-            if (num > 100) {
-                throw invalid_argument("Couldn't create sheet " + efectiveName);
-            }
-        }
-        cout << "Adding sheet " << efectiveName << " to " << Paths::excel() + fileName << endl;
-        setProperties(data["title"].get<string>());
+        setProperties(data["title"].get<std::string>());
        createFormats();
        formatColumns();
    }
@@ -55,26 +60,26 @@ namespace platform {

    void ReportExcel::header()
    {
-        locale mylocale(cout.getloc(), new separated);
-        locale::global(mylocale);
-        cout.imbue(mylocale);
-        stringstream oss;
-        string message = data["model"].get<string>() + " ver. " + data["version"].get<string>() + " " +
-            data["language"].get<string>() + " ver. " + data["language_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>();
+        std::locale mylocale(std::cout.getloc(), new separated);
+        std::locale::global(mylocale);
+        std::cout.imbue(mylocale);
+        std::stringstream oss;
+        std::string message = data["model"].get<std::string>() + " ver. " + data["version"].get<std::string>() + " " +
+            data["language"].get<std::string>() + " ver. " + data["language_version"].get<std::string>() +
+            " with " + std::to_string(data["folds"].get<int>()) + " Folds cross validation and " + std::to_string(data["seeds"].size()) +
+            " random seeds. " + data["date"].get<std::string>() + " " + data["time"].get<std::string>();
        worksheet_merge_range(worksheet, 0, 0, 0, 12, message.c_str(), styles["headerFirst"]);
-        worksheet_merge_range(worksheet, 1, 0, 1, 12, data["title"].get<string>().c_str(), styles["headerRest"]);
-        worksheet_merge_range(worksheet, 2, 0, 3, 0, ("Score is " + data["score_name"].get<string>()).c_str(), styles["headerRest"]);
+        worksheet_merge_range(worksheet, 1, 0, 1, 12, data["title"].get<std::string>().c_str(), styles["headerRest"]);
+        worksheet_merge_range(worksheet, 2, 0, 3, 0, ("Score is " + data["score_name"].get<std::string>()).c_str(), styles["headerRest"]);
        worksheet_merge_range(worksheet, 2, 1, 3, 3, "Execution time", styles["headerRest"]);
-        oss << setprecision(2) << fixed << data["duration"].get<float>() << " s";
+        oss << std::setprecision(2) << std::fixed << data["duration"].get<float>() << " s";
        worksheet_merge_range(worksheet, 2, 4, 2, 5, oss.str().c_str(), styles["headerRest"]);
        oss.str("");
        oss.clear();
-        oss << setprecision(2) << fixed << data["duration"].get<float>() / 3600 << " h";
+        oss << std::setprecision(2) << std::fixed << data["duration"].get<float>() / 3600 << " h";
        worksheet_merge_range(worksheet, 3, 4, 3, 5, oss.str().c_str(), styles["headerRest"]);
        worksheet_merge_range(worksheet, 2, 6, 3, 7, "Platform", styles["headerRest"]);
-        worksheet_merge_range(worksheet, 2, 8, 3, 9, data["platform"].get<string>().c_str(), styles["headerRest"]);
+        worksheet_merge_range(worksheet, 2, 8, 3, 9, data["platform"].get<std::string>().c_str(), styles["headerRest"]);
        worksheet_merge_range(worksheet, 2, 10, 2, 12, ("Random seeds: " + fromVector("seeds")).c_str(), styles["headerSmall"]);
        oss.str("");
        oss.clear();
@@ -88,7 +93,7 @@ namespace platform {

    void ReportExcel::body()
    {
-        auto head = vector<string>(
+        auto head = std::vector<std::string>(
            { "Dataset", "Samples", "Features", "Classes", "Nodes", "Edges", "States", "Score", "Score Std.", "St.", "Time",
             "Time Std.", "Hyperparameters" });
        int col = 0;
@@ -100,9 +105,9 @@ namespace platform {
        int hypSize = 22;
        json lastResult;
        double totalScore = 0.0;
-        string hyperparameters;
+        std::string hyperparameters;
        for (const auto& r : data["results"]) {
-            writeString(row, col, r["dataset"].get<string>(), "text");
+            writeString(row, col, r["dataset"].get<std::string>(), "text");
            writeInt(row, col + 1, r["samples"].get<int>(), "ints");
            writeInt(row, col + 2, r["features"].get<int>(), "ints");
            writeInt(row, col + 3, r["classes"].get<int>(), "ints");
@@ -111,18 +116,11 @@ namespace platform {
            writeDouble(row, col + 6, r["depth"].get<double>(), "floats");
            writeDouble(row, col + 7, r["score"].get<double>(), "result");
            writeDouble(row, col + 8, r["score_std"].get<double>(), "result");
-            const string status = compareResult(r["dataset"].get<string>(), r["score"].get<double>());
+            const std::string status = compareResult(r["dataset"].get<std::string>(), r["score"].get<double>());
            writeString(row, col + 9, status, "textCentered");
            writeDouble(row, col + 10, r["time"].get<double>(), "time");
            writeDouble(row, col + 11, r["time_std"].get<double>(), "time");
-            try {
-                hyperparameters = r["hyperparameters"].get<string>();
-            }
-            catch (const exception& err) {
-                stringstream oss;
-                oss << r["hyperparameters"];
-                hyperparameters = oss.str();
-            }
+            hyperparameters = r["hyperparameters"].dump();
            if (hyperparameters.size() > hypSize) {
                hypSize = hyperparameters.size();
            }
@@ -130,18 +128,17 @@ namespace platform {
            lastResult = r;
            totalScore += r["score"].get<double>();
            row++;
-
        }
        // Set the right column width of hyperparameters with the maximum length
        worksheet_set_column(worksheet, 12, 12, hypSize + 5, NULL);
        // Show totals if only one dataset is present in the result
        if (data["results"].size() == 1) {
-            for (const string& group : { "scores_train", "scores_test", "times_train", "times_test" }) {
+            for (const std::string& group : { "scores_train", "scores_test", "times_train", "times_test" }) {
                row++;
                col = 1;
                writeString(row, col, group, "text");
                for (double item : lastResult[group]) {
-                    string style = group.find("scores") != string::npos ? "result" : "time";
+                    std::string style = group.find("scores") != std::string::npos ? "result" : "time";
                    writeDouble(row, ++col, item, style);
                }
            }
@@ -170,10 +167,11 @@ namespace platform {
    {
        showSummary();
        row += 4 + summary.size();
-        auto score = data["score_name"].get<string>();
-        if (score == BestScore::scoreName()) {
-            worksheet_merge_range(worksheet, row, 1, row, 5, (score + " compared to " + BestScore::title() + " .:").c_str(), efectiveStyle("text"));
-            writeDouble(row, 6, totalScore / BestScore::score(), "result");
+        auto score = data["score_name"].get<std::string>();
+        auto best = BestScore::getScore(score);
+        if (best.first != "") {
+            worksheet_merge_range(worksheet, row, 1, row, 5, (score + " compared to " + best.first + " .:").c_str(), efectiveStyle("text"));
+            writeDouble(row, 6, totalScore / best.second, "result");
        }
        if (!getExistBestFile() && compare) {
            worksheet_write_string(worksheet, row + 1, 0, "*** Best Results File not found. Couldn't compare any result!", styles["summaryStyle"]);
--- a/src/Platform/ReportExcel.h
+++ b/src/Platform/ReportExcel.h
@@ -6,14 +6,13 @@
 #include "ExcelFile.h"
 #include "Colors.h"
 namespace platform {
-    using namespace std;
    class ReportExcel : public ReportBase, public ExcelFile {
    public:
-        explicit ReportExcel(json data_, bool compare, lxw_workbook* workbook);
+        explicit ReportExcel(json data_, bool compare, lxw_workbook* workbook, lxw_worksheet* worksheet = NULL);
    private:
-        const string fileName = "some_results.xlsx";
        void formatColumns();
        void createFile();
+        void createWorksheet();
        void closeFile();
        void header() override;
        void body() override;
--- a/src/Platform/Result.cc
+++ b/src/Platform/Result.cc
@@ -1,13 +1,14 @@
+#include "Result.h"
+#include "BestScore.h"
 #include <filesystem>
 #include <fstream>
 #include <sstream>
-#include "Result.h"
 #include "Colors.h"
-#include "BestScore.h"
+#include "DotEnv.h"
 #include "CLocale.h"

 namespace platform {
-    Result::Result(const string& path, const string& filename)
+    Result::Result(const std::string& path, const std::string& filename)
        : path(path)
        , filename(filename)
    {
@@ -18,8 +19,9 @@ namespace platform {
            score += result["score"].get<double>();
        }
        scoreName = data["score_name"];
-        if (scoreName == BestScore::scoreName()) {
-            score /= BestScore::score();
+        auto best = BestScore::getScore(scoreName);
+        if (best.first != "") {
+            score /= best.second;
        }
        title = data["title"];
        duration = data["duration"];
@@ -29,28 +31,28 @@ namespace platform {

    json Result::load() const
    {
-        ifstream resultData(path + "/" + filename);
+        std::ifstream resultData(path + "/" + filename);
        if (resultData.is_open()) {
            json data = json::parse(resultData);
            return data;
        }
-        throw invalid_argument("Unable to open result file. [" + path + "/" + filename + "]");
+        throw std::invalid_argument("Unable to open result file. [" + path + "/" + filename + "]");
    }

-    string Result::to_string() const
+    std::string Result::to_string(int maxModel) const
    {
        auto tmp = ConfigLocale();
-        stringstream oss;
+        std::stringstream oss;
        double durationShow = duration > 3600 ? duration / 3600 : duration > 60 ? duration / 60 : duration;
-        string durationUnit = duration > 3600 ? "h" : duration > 60 ? "m" : "s";
+        std::string durationUnit = duration > 3600 ? "h" : duration > 60 ? "m" : "s";
        oss << date << " ";
-        oss << setw(12) << left << model << " ";
-        oss << setw(11) << left << scoreName << " ";
-        oss << right << setw(11) << setprecision(7) << fixed << score << " ";
+        oss << std::setw(maxModel) << std::left << model << " ";
+        oss << std::setw(11) << std::left << scoreName << " ";
+        oss << std::right << std::setw(11) << std::setprecision(7) << std::fixed << score << " ";
        auto completeString = isComplete() ? "C" : "P";
-        oss << setw(1) << " " << completeString << "  ";
-        oss << setw(7) << setprecision(2) << fixed << durationShow << " " << durationUnit << " ";
-        oss << setw(50) << left << title << " ";
+        oss << std::setw(1) << " " << completeString << "  ";
+        oss << std::setw(7) << std::setprecision(2) << std::fixed << durationShow << " " << durationUnit << " ";
+        oss << std::setw(50) << std::left << title << " ";
        return  oss.str();
    }
 }
--- a/src/Platform/Result.h
+++ b/src/Platform/Result.h
@@ -5,33 +5,31 @@
 #include <string>
 #include <nlohmann/json.hpp>
 namespace platform {
-    using namespace std;
    using json = nlohmann::json;

    class Result {
    public:
-        Result(const string& path, const string& filename);
+        Result(const std::string& path, const std::string& filename);
        json load() const;
-        string to_string() const;
-        string getFilename() const { return filename; };
-        string getDate() const { return date; };
+        std::string to_string(int maxModel) const;
+        std::string getFilename() const { return filename; };
+        std::string getDate() const { return date; };
        double getScore() const { return score; };
-        string getTitle() const { return title; };
+        std::string getTitle() const { return title; };
        double getDuration() const { return duration; };
-        string getModel() const { return model; };
-        string getScoreName() const { return scoreName; };
+        std::string getModel() const { return model; };
+        std::string getScoreName() const { return scoreName; };
        bool isComplete() const { return complete; };
    private:
-        string path;
-        string filename;
-        string date;
+        std::string path;
+        std::string filename;
+        std::string date;
        double score;
-        string title;
+        std::string title;
        double duration;
-        string model;
-        string scoreName;
+        std::string model;
+        std::string scoreName;
        bool complete;
    };
 };
-
 #endif
--- a/src/Platform/Results.cc
+++ b/src/Platform/Results.cc
@@ -1,17 +1,23 @@
-#include <filesystem>
 #include "Results.h"
-#include "ReportConsole.h"
-#include "ReportExcel.h"
-#include "BestScore.h"
-#include "Colors.h"
-#include "CLocale.h"
+#include <algorithm>
+
 namespace platform {
+    Results::Results(const std::string& path, const std::string& model, const std::string& score, bool complete, bool partial) :
+        path(path), model(model), scoreName(score), complete(complete), partial(partial)
+    {
+        load();
+        if (!files.empty()) {
+            maxModel = (*max_element(files.begin(), files.end(), [](const Result& a, const Result& b) { return a.getModel().size() < b.getModel().size(); })).getModel().size();
+        } else {
+            maxModel = 0;
+        }
+    };
    void Results::load()
    {
        using std::filesystem::directory_iterator;
        for (const auto& file : directory_iterator(path)) {
            auto filename = file.path().filename().string();
-            if (filename.find(".json") != string::npos && filename.find("results_") == 0) {
+            if (filename.find(".json") != std::string::npos && filename.find("results_") == 0) {
                auto result = Result(path, filename);
                bool addResult = true;
                if (model != "any" && result.getModel() != model || scoreName != "any" && scoreName != result.getScoreName() || complete && !result.isComplete() || partial && result.isComplete())
@@ -20,212 +26,22 @@ namespace platform {
                    files.push_back(result);
            }
        }
-        if (max == 0) {
-            max = files.size();
    }
-    }
-    void Results::show() const
+    void Results::hideResult(int index, const std::string& pathHidden)
    {
-        auto temp = ConfigLocale();
-        cout << Colors::GREEN() << "Results found: " << files.size() << endl;
-        cout << "-------------------" << endl;
-        if (complete) {
-            cout << Colors::MAGENTA() << "Only listing complete results" << endl;
+        auto filename = files.at(index).getFilename();
+        rename((path + "/" + filename).c_str(), (pathHidden + "/" + filename).c_str());
+        files.erase(files.begin() + index);
    }
-        if (partial) {
-            cout << Colors::MAGENTA() << "Only listing partial results" << endl;
-        }
-        auto i = 0;
-        cout << Colors::GREEN() << " #  Date       Model        Score Name  Score       C/P Duration  Title" << endl;
-        cout << "=== ========== ============ =========== =========== === ========= =============================================================" << endl;
-        bool odd = true;
-        for (const auto& result : files) {
-            auto color = odd ? Colors::BLUE() : Colors::CYAN();
-            cout << color << setw(3) << fixed << right << i++ << " ";
-            cout << result.to_string() << endl;
-            if (i == max && max != 0) {
-                break;
-            }
-            odd = !odd;
-        }
-    }
-    int Results::getIndex(const string& intent) const
+    void Results::deleteResult(int index)
    {
-        string color;
-        if (intent == "delete") {
-            color = Colors::RED();
-        } else {
-            color = Colors::YELLOW();
-        }
-        cout << color << "Choose result to " << intent << " (cancel=-1): ";
-        string line;
-        getline(cin, line);
-        int index = stoi(line);
-        if (index >= -1 && index < static_cast<int>(files.size())) {
-            return index;
-        }
-        cout << "Invalid index" << endl;
-        return -1;
-    }
-    void Results::report(const int index, const bool excelReport)
-    {
-        cout << Colors::YELLOW() << "Reporting " << files.at(index).getFilename() << endl;
-        auto data = files.at(index).load();
-        if (excelReport) {
-            ReportExcel reporter(data, compare, workbook);
-            reporter.show();
-            openExcel = true;
-            workbook = reporter.getWorkbook();
-        } else {
-            ReportConsole reporter(data, compare);
-            reporter.show();
-        }
-    }
-    void Results::showIndex(const int index, const int idx) const
-    {
-        auto data = files.at(index).load();
-        if (idx < 0 or idx >= static_cast<int>(data["results"].size())) {
-            cout << "Invalid index" << endl;
-            return;
-        }
-        cout << Colors::YELLOW() << "Showing " << files.at(index).getFilename() << endl;
-        ReportConsole reporter(data, compare, idx);
-        reporter.show();
-    }
-    void Results::menu()
-    {
-        char option;
-        int index;
-        bool finished = false;
-        string color, context;
-        string filename, line, options = "qldhsre";
-        while (!finished) {
-            if (indexList) {
-                color = Colors::GREEN();
-                context = " (quit='q', list='l', delete='d', hide='h', sort='s', report='r', excel='e'): ";
-                options = "qldhsre";
-            } else {
-                color = Colors::MAGENTA();
-                context = " (quit='q', list='l'): ";
-                options = "ql";
-            }
-            cout << Colors::RESET() << color;
-
-            cout << "Choose option " << context;
-            getline(cin, line);
-            if (line.size() == 0)
-                continue;
-            if (options.find(line[0]) != string::npos) {
-                if (line.size() > 1) {
-                    cout << "Invalid option" << endl;
-                    continue;
-                }
-                option = line[0];
-            } else {
-                if (all_of(line.begin(), line.end(), ::isdigit)) {
-                    int idx = stoi(line);
-                    if (indexList) {
-                        // The value is about the files list
-                        index = idx;
-                        if (index >= 0 && index < max) {
-                            report(index, false);
-                            indexList = false;
-                            continue;
-                        }
-                    } else {
-                        // The value is about the result showed on screen
-                        showIndex(index, idx);
-                        continue;
-                    }
-                }
-                cout << "Invalid option" << endl;
-                continue;
-            }
-            switch (option) {
-                case 'q':
-                    finished = true;
-                    break;
-                case 'l':
-                    show();
-                    indexList = true;
-                    break;
-                case 'd':
-                    index = getIndex("delete");
-                    if (index == -1)
-                        break;
-                    filename = files[index].getFilename();
-                    cout << "Deleting " << filename << endl;
+        auto filename = files.at(index).getFilename();
        remove((path + "/" + filename).c_str());
        files.erase(files.begin() + index);
-                    cout << "File: " + filename + " deleted!" << endl;
-                    show();
-                    indexList = true;
-                    break;
-                case 'h':
-                    index = getIndex("hide");
-                    if (index == -1)
-                        break;
-                    filename = files[index].getFilename();
-                    cout << "Hiding " << filename << endl;
-                    rename((path + "/" + filename).c_str(), (path + "/." + filename).c_str());
-                    files.erase(files.begin() + index);
-                    show();
-                    menu();
-                    indexList = true;
-                    break;
-                case 's':
-                    sortList();
-                    indexList = true;
-                    show();
-                    break;
-                case 'r':
-                    index = getIndex("report");
-                    if (index == -1)
-                        break;
-                    indexList = false;
-                    report(index, false);
-                    break;
-                case 'e':
-                    index = getIndex("excel");
-                    if (index == -1)
-                        break;
-                    indexList = true;
-                    report(index, true);
-                    break;
-                default:
-                    cout << "Invalid option" << endl;
    }
-        }
-    }
-    void Results::sortList()
+    int Results::size() const
    {
-        cout << Colors::YELLOW() << "Choose sorting field (date='d', score='s', duration='u', model='m'): ";
-        string line;
-        char option;
-        getline(cin, line);
-        if (line.size() == 0)
-            return;
-        if (line.size() > 1) {
-            cout << "Invalid option" << endl;
-            return;
-        }
-        option = line[0];
-        switch (option) {
-            case 'd':
-                sortDate();
-                break;
-            case 's':
-                sortScore();
-                break;
-            case 'u':
-                sortDuration();
-                break;
-            case 'm':
-                sortModel();
-                break;
-            default:
-                cout << "Invalid option" << endl;
-        }
+        return files.size();
    }
    void Results::sortDate()
    {
@@ -251,19 +67,8 @@ namespace platform {
            return a.getScore() > b.getScore();
            });
    }
-    void Results::manage()
+    bool Results::empty() const
    {
-        if (files.size() == 0) {
-            cout << "No results found!" << endl;
-            exit(0);
+        return files.empty();
    }
-        sortDate();
-        show();
-        menu();
-        if (openExcel) {
-            workbook_close(workbook);
-        }
-        cout << Colors::RESET() << "Done!" << endl;
-    }
-
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ricardo Montañana	18e8e84284	Add openmpi instructions for Oracle Linux	2023-12-17 12:19:50 +01:00
Ricardo Montañana Gómez	7de11b0e6d	Fix format of duration	2023-12-17 01:45:04 +01:00
Ricardo Montañana Gómez	9b8db37a4b	Fix duration of task not set	2023-12-16 19:31:45 +01:00
Ricardo Montañana Gómez	49b26bd04b	fix duration output	2023-12-16 12:53:25 +01:00
Ricardo Montañana Gómez	b5b5b48864	Update grid progress bar output	2023-12-15 18:09:17 +01:00
Ricardo Montañana Gómez	19586a3a5a	Fix pesky error allocating memory in workers	2023-12-15 01:54:13 +01:00
Ricardo Montañana	ffe6d37436	Add messages to control trace	2023-12-14 21:06:43 +01:00
Ricardo Montañana Gómez	b73f4be146	First try with complete algorithm	2023-12-14 15:55:08 +01:00
Ricardo Montañana	dbf2f35502	First compiling version	2023-12-12 18:57:57 +01:00
Ricardo Montañana Gómez	db9e80a70e	Create build tasks	2023-12-12 12:15:22 +01:00
Ricardo Montañana	40ae4ad7f9	Include mpi in CMakeLists	2023-12-11 09:06:05 +01:00
Ricardo Montañana Gómez	234342f2de	Add mpi parameter to b_grid	2023-12-10 22:33:17 +01:00
Ricardo Montañana Gómez	aa0936abd1	Add --exclude parameter to b_grid to exclude datasets	2023-12-08 12:09:08 +01:00
Ricardo Montañana	f0d6f0cc38	Fix sample building	2023-12-04 19:12:44 +01:00
Ricardo Montañana	cc316bb8d3	Add colors to results of gridsearch	2023-12-04 17:34:00 +01:00
Ricardo Montañana Gómez	0723564e66	Fix some output in gridsearch	2023-12-03 17:55:44 +01:00
Ricardo Montañana Gómez	2e95e8999d	Complete nested gridsearch	2023-12-03 12:37:25 +01:00
Ricardo Montañana Gómez	fb9b395748	Begin output nested grid	2023-12-02 13:19:12 +01:00
Ricardo Montañana Gómez	03e4437fea	refactor gridsearch to have only one go method	2023-12-02 10:59:05 +01:00
Ricardo Montañana Gómez	33cd32c639	Add header to grid output and report	2023-12-01 10:30:53 +01:00
Ricardo Montañana Gómez	c460ef46ed	Refactor gridsearch method	2023-11-30 11:01:37 +01:00
Ricardo Montañana Gómez	dee9c674da	Refactor grid input hyperparameter file	2023-11-29 18:24:34 +01:00
Ricardo Montañana Gómez	e3f6dc1e0b	Fix tolerance hyperp error & gridsearch	2023-11-29 12:33:50 +01:00
Ricardo Montañana Gómez	460d20a402	Add reports to gridsearch	2023-11-29 00:26:48 +01:00
Ricardo Montañana	8dbbb65a2f	Add only parameter to gridsearch	2023-11-28 10:08:40 +01:00
Ricardo Montañana Gómez	d06bf187b2	Implement Random Forest nodes/leaves/depth	2023-11-28 00:35:38 +01:00
Ricardo Montañana Gómez	4addaefb47	Implement sklearn version in PyWrap	2023-11-27 22:34:34 +01:00
Ricardo Montañana Gómez	82964190f6	Add nodes/leaves/depth to STree & ODTE	2023-11-27 10:57:57 +01:00
Ricardo Montañana Gómez	4fefe9a1d2	Add grid input info to grid output	2023-11-26 16:07:32 +01:00
Ricardo Montañana Gómez	7c12dd25e5	Fix upper case typo	2023-11-26 10:55:32 +01:00
Ricardo Montañana Gómez	c713c0b1df	Add continue from parameter to gridsearch	2023-11-26 10:36:09 +01:00
Ricardo Montañana Gómez	64069a6cb7	Adapt b_main to the new hyperparam file format	2023-11-25 16:52:25 +01:00
Ricardo Montañana Gómez	ba2a3f9523	Merge pull request 'gridsearch' (#13 ) from gridsearch into main Reviewed-on: #13	2023-11-25 11:16:13 +00:00
Ricardo Montañana Gómez	f94e2d6a27	Add quiet parameter	2023-11-24 21:16:20 +01:00
Ricardo Montañana	2121ba9b98	Refactor input grid parameters to json file	2023-11-24 09:57:29 +01:00
Ricardo Montañana Gómez	8b7b59d42b	Complete first step	2023-11-23 12:59:21 +01:00
Ricardo Montañana Gómez	bbe5302ab1	Add info to output	2023-11-22 16:38:50 +01:00
Ricardo Montañana Gómez	c2eb727fc7	Complete output interface of gridsearch	2023-11-22 16:30:04 +01:00
Ricardo Montañana Gómez	fb347ed5b9	Begin gridsearch implementation	2023-11-22 12:22:30 +01:00
Ricardo Montañana	b657762c0c	Generate combinations sample	2023-11-22 00:18:24 +01:00
Ricardo Montañana	495d8a8528	Begin implementing grid combinations	2023-11-21 13:11:14 +01:00
Ricardo Montañana Gómez	4628e48d3c	Build gridsearch structure	2023-11-20 23:32:34 +01:00
Ricardo Montañana	5876be4b24	Add more install instructions of Boost to README	2023-11-20 20:39:22 +01:00
Ricardo Montañana	dc3400197f	Add coment todo impelemt number of nodes	2023-11-20 01:14:13 +01:00
Ricardo Montañana Gómez	26d3a57782	Add info to invalid hyperparameter exception	2023-11-19 23:02:28 +01:00
Ricardo Montañana Gómez	4f3a04058f	Refactor Hyperparameters management	2023-11-19 22:36:27 +01:00
Ricardo Montañana Gómez	89c4613591	Implement hyperparameters with json file	2023-11-18 11:56:10 +01:00
Ricardo Montañana Gómez	28f3d87e32	Add Python Classifiers Add STree, Odte, SVC & RandomForest Classifiers Remove using namespace ... in project	2023-11-17 11:11:05 +01:00
Ricardo Montañana Gómez	e8d2c9fc0b	Set intolerant convergence	2023-11-17 10:26:25 +01:00
Ricardo Montañana Gómez	d3cb580387	Remove n_jobs from STree	2023-11-17 10:10:31 +01:00
Ricardo Montañana Gómez	f088df14fd	Restore the Creation model position in experiment	2023-11-17 01:10:46 +01:00
Ricardo Montañana Gómez	e2249eace7	Disable Warning messages in python clfs Disable removing Python env	2023-11-16 22:38:46 +01:00
Ricardo Montañana Gómez	64f5a7f14a	Fix header in example	2023-11-16 17:03:40 +01:00
Ricardo Montañana	408db2aad5	Mark override fit funtcion	2023-11-14 18:59:41 +01:00
Ricardo Montañana Gómez	e03efb5f63	set tolerance=0 if feature selection in BoostAODE	2023-11-14 10:12:02 +01:00
Ricardo Montañana Gómez	f617886133	Add new models to example	2023-11-14 09:12:25 +01:00
Ricardo Montañana Gómez	69ad660040	Refactor version method in PyClassifier	2023-11-13 13:59:06 +01:00
Ricardo Montañana Gómez	431b3a3aa5	Fit PyWrap into BayesNet	2023-11-13 11:13:32 +01:00
Ricardo Montañana Gómez	6a23e2cc26	Add CMakelist integration	2023-11-12 22:14:29 +01:00
Ricardo Montañana Gómez	f6e00530be	Add Pywrap sources	2023-11-12 21:43:07 +01:00
Ricardo Montañana Gómez	f9258e43b9	Remove using namespace from Library	2023-11-08 18:45:35 +01:00
Ricardo Montañana Gómez	92820555da	Simple fix	2023-10-28 10:56:47 +02:00
Ricardo Montañana	5a3af51826	Activate best score in odte	2023-10-25 10:23:42 +02:00
Ricardo Montañana	a8f9800631	Fix mistake when no results in manage	2023-10-24 19:44:23 +02:00
Ricardo Montañana Gómez	84cec0c1e0	Add results files affected in best results excel	2023-10-24 16:18:52 +02:00
Ricardo Montañana Gómez	130139f644	Update formulas to use letters in ranges in excel	2023-10-24 13:06:31 +02:00
Ricardo Montañana	651f84b562	Fix mistake in conditional format in bestresults	2023-10-24 11:18:19 +02:00
Ricardo Montañana Gómez	553ab0fa22	Add conditional format to BestResults Excel	2023-10-24 10:56:41 +02:00
Ricardo Montañana	4975feabff	Fix mistake in node count	2023-10-23 22:46:10 +02:00
Ricardo Montañana	32293af69f	Fix header in manage	2023-10-23 17:04:59 +02:00
Ricardo Montañana Gómez	858664be2d	Add total number of results in manage	2023-10-23 16:22:15 +02:00
Ricardo Montañana Gómez	1f705f6018	Refactor BestScore and add experiment to .env	2023-10-23 16:12:52 +02:00
Ricardo Montañana Gómez	7bcd2eed06	Add variable width of dataset name in reports	2023-10-22 22:58:52 +02:00
Ricardo Montañana Gómez	833acefbb3	Fix index limits mistake in manage	2023-10-22 20:21:50 +02:00
Ricardo Montañana Gómez	26b649ebae	Refactor ManageResults and CommandParser	2023-10-22 20:03:34 +02:00
Ricardo Montañana Gómez	080eddf9cd	Fix hyperparameters output in b_best	2023-10-20 22:52:48 +02:00
Ricardo Montañana	04e754b2f5	Adjust filename and hyperparameters in reports	2023-10-20 11:12:46 +02:00
Ricardo Montañana Gómez	38423048bd	Add excel to best report of model	2023-10-19 18:12:55 +02:00
Ricardo Montañana Gómez	64fc97b892	Rename utilities sources to match final names	2023-10-19 09:57:04 +02:00
Ricardo Montañana Gómez	2c2159f192	Add quiet mode to b_main Reduce output when --quiet is set, not showing fold info	2023-10-17 21:51:53 +02:00
Ricardo Montañana Gómez	6765552a7c	Update submodule versions	2023-10-16 19:21:57 +02:00
Ricardo Montañana Gómez	f72aa5b9a6	Merge pull request 'Create Boost_CFS' (#11 ) from Boost_CFS into main Add hyper parameter to BoostAODE. This hyper parameter decides if we select features with cfs/fcbf/iwss before start building models and build a Spode with the selected features. The hyperparameter is select_features	2023-10-15 09:22:14 +00:00