Fix linter warnings

Add Models class
Add dotenv and possible multiple seeds
2023-07-29 01:16:19 +02:00 · 2023-07-28 12:11:52 +02:00 · 2023-07-28 00:53:16 +02:00
105 changed files with 4661 additions and 2643 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -13,4 +13,5 @@ HeaderFilterRegex: 'src/*'
 AnalyzeTemporaryDtors: false
 WarningsAsErrors: ''
 FormatStyle: file
+FormatStyleOptions: ''
 ...
--- a/.gitignore
+++ b/.gitignore
@@ -31,10 +31,7 @@
 *.exe
 *.out
 *.app
-build/**
-build_*/**
+build/
 *.dSYM/**
 cmake-build*/**
 .idea
-puml/**
-.vscode/settings.json
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,18 +1,12 @@
 [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
 [submodule "lib/json"]
 	path = lib/json
 	url = https://github.com/nlohmann/json.git
-        master = master
-	update = merge
-[submodule "lib/folding"]
-	path = lib/folding
-	url = https://github.com/rmontanana/folding
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@@ -1,18 +0,0 @@
-{
-    "configurations": [
-        {
-            "name": "Mac",
-            "includePath": [
-                "${workspaceFolder}/**"
-            ],
-            "defines": [],
-            "macFrameworkPath": [
-                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
-            ],
-            "cStandard": "c17",
-            "cppStandard": "c++17",
-            "compileCommands": "${workspaceFolder}/cmake-build-release/compile_commands.json"
-        }
-    ],
-    "version": 4
-}
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -5,119 +5,44 @@
            "type": "lldb",
            "request": "launch",
            "name": "sample",
-            "program": "${workspaceFolder}/build_debug/sample/BayesNetSample",
+            "program": "${workspaceFolder}/build/sample/BayesNetSample",
            "args": [
                "-d",
                "iris",
                "-m",
-                "TANLd",
-                "-s",
-                "271",
+                "TAN",
                "-p",
-                "/Users/rmontanana/Code/discretizbench/datasets/",
+                "../../data/",
+                "--tensors"
            ],
-            //"cwd": "${workspaceFolder}/build/sample/",
+            "cwd": "${workspaceFolder}/build/sample/",
        },
        {
            "type": "lldb",
            "request": "launch",
-            "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",
+            "name": "experiment",
+            "program": "${workspaceFolder}/build/src/Platform/main",
            "args": [
                "-m",
                "TAN",
-                "--stratified",
+                "-p",
+                "/Users/rmontanana/Code/discretizbench/datasets",
                "--discretize",
+                "--stratified",
+                "--title",
+                "Debug test",
+                "--seeds",
+                "1",
                "-d",
-                "iris",
-                "--hyperparameters",
-                "{\"repeatSparent\": true, \"maxModels\": 12}"
+                "ionosphere"
            ],
-            "cwd": "/home/rmontanana/Code/discretizbench",
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "best",
-            "program": "${workspaceFolder}/build_debug/src/Platform/b_best",
-            "args": [
-                "-m",
-                "BoostAODE",
-                "-s",
-                "accuracy",
-                "--build",
-            ],
-            "cwd": "${workspaceFolder}/../discretizbench",
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "manage",
-            "program": "${workspaceFolder}/build_debug/src/Platform/b_manage",
-            "args": [
-                "-n",
-                "20"
-            ],
-            "cwd": "${workspaceFolder}/../discretizbench",
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "list",
-            "program": "${workspaceFolder}/build_debug/src/Platform/b_list",
-            "args": [],
-            //"cwd": "/Users/rmontanana/Code/discretizbench",
-            "cwd": "${workspaceFolder}/../discretizbench",
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "test",
-            "program": "${workspaceFolder}/build_debug/tests/unit_tests",
-            "args": [
-                "-c=\"Metrics Test\"",
-                // "-s",
-            ],
-            "cwd": "${workspaceFolder}/build/tests",
+            "cwd": "${workspaceFolder}/build/src/Platform",
        },
        {
            "name": "Build & debug active file",
            "type": "cppdbg",
            "request": "launch",
-            "program": "${workspaceFolder}/build_debug/bayesnet",
+            "program": "${workspaceFolder}/build/bayesnet",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -0,0 +1,109 @@
+{
+    "files.associations": {
+        "*.rmd": "markdown",
+        "*.py": "python",
+        "vector": "cpp",
+        "__bit_reference": "cpp",
+        "__bits": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tuple": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "exception": "cpp",
+        "initializer_list": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "variant": "cpp",
+        "algorithm": "cpp",
+        "iostream": "cpp",
+        "iomanip": "cpp",
+        "numeric": "cpp",
+        "set": "cpp",
+        "__tree": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "map": "cpp",
+        "unordered_set": "cpp",
+        "any": "cpp",
+        "condition_variable": "cpp",
+        "forward_list": "cpp",
+        "fstream": "cpp",
+        "stack": "cpp",
+        "thread": "cpp",
+        "__memory": "cpp",
+        "filesystem": "cpp",
+        "*.toml": "toml",
+        "utility": "cpp",
+        "__verbose_abort": "cpp",
+        "bit": "cpp",
+        "random": "cpp",
+        "*.tcc": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory_resource": "cpp",
+        "format": "cpp",
+        "valarray": "cpp",
+        "regex": "cpp",
+        "span": "cpp",
+        "cfenv": "cpp",
+        "cinttypes": "cpp",
+        "csetjmp": "cpp",
+        "future": "cpp",
+        "queue": "cpp",
+        "typeindex": "cpp",
+        "shared_mutex": "cpp",
+        "*.ipp": "cpp",
+        "cassert": "cpp",
+        "charconv": "cpp",
+        "source_location": "cpp",
+        "ranges": "cpp"
+    },
+    "cmake.configureOnOpen": false,
+    "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools"
+}
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -32,29 +32,6 @@
            ],
            "group": "build",
            "detail": "Task generated by Debugger."
-        },
-        {
-            "type": "cppbuild",
-            "label": "C/C++: g++ build active file",
-            "command": "/usr/bin/g++",
-            "args": [
-                "-fdiagnostics-color=always",
-                "-g",
-                "${file}",
-                "-o",
-                "${fileDirname}/${fileBasenameNoExtension}"
-            ],
-            "options": {
-                "cwd": "${fileDirname}"
-            },
-            "problemMatcher": [
-                "$gcc"
-            ],
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "detail": "Task generated by Debugger."
        }
    ]
 }
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,23 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [1.0.1] - 2024-02-12
-
-### Added
-
- Notes in Classifier class
- BoostAODE: Add note with used features in initialization with feature selection
- BoostAODE: Add note with the number of models
- BoostAODE: Add note with the number of features used to create models if not all features are used
- Test version number in TestBayesModels
- Add tests with feature_select and notes on BoostAODE
-
-### Fixed
-
- Network predict test
- Network predict_proba test
- Network score test
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,20 +1,16 @@
 cmake_minimum_required(VERSION 3.20)

 project(BayesNet
-  VERSION 1.0.1
+  VERSION 0.1.0
  DESCRIPTION "Bayesian Network and basic classifiers Library."
  HOMEPAGE_URL "https://github.com/rmontanana/bayesnet"
  LANGUAGES CXX
 )

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

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

 # Global CMake variables
@@ -24,34 +20,29 @@ 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(ENABLE_TESTING "Unit testing build"                        ON)
+option(CODE_COVERAGE "Collect coverage from test library"         ON)
+
+set(CMAKE_BUILD_TYPE "Debug")

 # CMakes modules
 # --------------
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
+
 include(AddGitSubmodule)
-
-if (CODE_COVERAGE)
-    enable_testing()
-    include(CodeCoverage)
-    MESSAGE("Code coverage enabled")
-    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -O0 -g")
-    SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
-endif (CODE_COVERAGE)
-
-if (ENABLE_CLANG_TIDY)
-  include(StaticAnalyzers) # clang-tidy
-endif (ENABLE_CLANG_TIDY)
+include(StaticAnalyzers) # clang-tidy
+include(CodeCoverage)

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

 # Subdirectories
@@ -59,16 +50,27 @@ add_git_submodule("lib/json")
 add_subdirectory(config)
 add_subdirectory(lib/Files)
 add_subdirectory(src/BayesNet)
+add_subdirectory(src/Platform)
+add_subdirectory(sample)

-file(GLOB BayesNet_HEADERS CONFIGURE_DEPENDS ${BayesNet_SOURCE_DIR}/src/BayesNet/*.h ${BayesNet_SOURCE_DIR}/BayesNet/*.h)
+file(GLOB BayesNet_HEADERS CONFIGURE_DEPENDS ${BayesNet_SOURCE_DIR}/src/BayesNet/*.h ${BayesNet_SOURCE_DIR}/BayesNet/*.hpp)
 file(GLOB BayesNet_SOURCES CONFIGURE_DEPENDS ${BayesNet_SOURCE_DIR}/src/BayesNet/*.cc ${BayesNet_SOURCE_DIR}/src/BayesNet/*.cpp)
+file(GLOB Platform_SOURCES CONFIGURE_DEPENDS ${BayesNet_SOURCE_DIR}/src/Platform/*.cc ${BayesNet_SOURCE_DIR}/src/Platform/*.cpp)

 # Testing
 # -------
-
 if (ENABLE_TESTING)
  MESSAGE("Testing enabled")
-  add_git_submodule("lib/catch2")  
+  enable_testing()
+  if (CODE_COVERAGE)
+    #include(CodeCoverage)
+    MESSAGE("Code coverage enabled")
+    set(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
+    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+    SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
+  endif (CODE_COVERAGE)
+  #find_package(Catch2 3 REQUIRED)
  include(CTest)
+  #include(Catch)
  add_subdirectory(tests)
 endif (ENABLE_TESTING)
--- a/86
+++ b/86
@@ -1,26 +1,6 @@
 SHELL := /bin/bash
 .DEFAULT_GOAL := help
-.PHONY: coverage setup help buildr buildd test clean debug release
-
-f_release = build_release
-f_debug = build_debug
-app_targets = BayesNet
-test_targets = unit_tests_bayesnet 
-n_procs = -j 16
-
-define ClearTests
-	@for t in $(test_targets); do \
-		if [ -f $(f_debug)/tests/$$t ]; then \
-			echo ">>> Cleaning $$t..." ; \
-			rm -f $(f_debug)/tests/$$t ; \
-		fi ; \
-	done
-	@nfiles="$(find . -name "*.gcda" -print0)" ; \
-	if test "${nfiles}" != "" ; then \
-		find . -name "*.gcda" -print0 | xargs -0 rm 2>/dev/null ;\
-	fi ; 
-endef
-
+.PHONY: coverage setup help build test

 setup: ## Install dependencies for tests and coverage
 	@if [ "$(shell uname)" = "Darwin" ]; then \
@@ -32,54 +12,34 @@ setup: ## Install dependencies for tests and coverage
 	fi

 dependency: ## Create a dependency graph diagram of the project (build/dependency.png)
-	@echo ">>> Creating dependency graph diagram of the project...";
-	$(MAKE) debug
-	cd $(f_debug) && cmake .. --graphviz=dependency.dot && dot -Tpng dependency.dot -o dependency.png
+	cd build && 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)
+build: ## Build the project
+	@echo ">>> Building BayesNet ...";
+	@if [ -d ./build ]; then rm -rf ./build; fi
+	@mkdir build; 
+	cmake -S . -B build; \
+	cd build; \
+	make; \
 	
-buildr: ## Build the release targets
-	cmake --build $(f_release) -t $(app_targets) $(n_procs)
-
-clean: ## Clean the tests info
-	@echo ">>> Cleaning Debug BayesNet tests...";
-	$(call ClearTests)
 	@echo ">>> Done";

-debug: ## Build a debug version of the project
-	@echo ">>> Building Debug BayesNet...";
-	@if [ -d ./$(f_debug) ]; then rm -rf ./$(f_debug); fi
-	@mkdir $(f_debug); 
-	@cmake -S . -B $(f_debug) -D CMAKE_BUILD_TYPE=Debug -D ENABLE_TESTING=ON -D CODE_COVERAGE=ON
-	@echo ">>> Done";
-
-release: ## Build a Release version of the project
-	@echo ">>> Building Release BayesNet...";
-	@if [ -d ./$(f_release) ]; then rm -rf ./$(f_release); fi
-	@mkdir $(f_release); 
-	@cmake -S . -B $(f_release) -D CMAKE_BUILD_TYPE=Release
-	@echo ">>> Done";	
-
-opt = ""
-test: ## Run tests (opt="-s") to verbose output the tests, (opt="-c='Test Maximum Spanning Tree'") to run only that section
-	@echo ">>> Running BayesNet & Platform tests...";
-	@$(MAKE) clean
-	@cmake --build $(f_debug) -t $(test_targets) $(n_procs)
-	@for t in $(test_targets); do \
-		if [ -f $(f_debug)/tests/$$t ]; then \
-			cd $(f_debug)/tests ; \
-			./$$t $(opt) ; \
-		fi ; \
-	done
-	@echo ">>> Done";
+test: ## Run tests
+	@echo "* Running tests...";
+	find . -name "*.gcda" -print0 | xargs -0 rm
+	@cd build; \
+	cmake --build . --target unit_tests ;
+	@cd build/tests; \
+	./unit_tests;

 coverage: ## Run tests and generate coverage report (build/index.html)
-	@echo ">>> Building tests with coverage..."
-	@$(MAKE) test
-	@gcovr $(f_debug)/tests
-	@echo ">>> Done";	
-
+	@echo "*Building tests...";
+	find . -name "*.gcda" -print0 | xargs -0 rm
+	@cd build; \
+	cmake --build . --target unit_tests ;
+	@cd build/tests; \
+	./unit_tests;
+	gcovr ;

 help: ## Show help message
 	@IFS=$$'\n' ; \
--- a/README.md
+++ b/README.md
@@ -1,22 +1,5 @@
 # BayesNet

-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-Bayesian Network Classifiers using libtorch from scratch
-
-### Release
-
-```bash
-make release
-make buildr
-```
-
-### Debug & Tests
-
-```bash
-make debug
-make test
-make coverage
-```
+Bayesian Network Classifier with libtorch from scratch

 ## 1. Introduction
--- a/config/config.h.in
+++ b/config/config.h.in
@@ -7,8 +7,7 @@
 #define PROJECT_VERSION_MINOR @PROJECT_VERSION_MINOR @
 #define PROJECT_VERSION_PATCH @PROJECT_VERSION_PATCH @

-static constexpr std::string_view project_name = "@PROJECT_NAME@";
+static constexpr std::string_view project_name = " @PROJECT_NAME@ ";
 static constexpr std::string_view project_version = "@PROJECT_VERSION@";
 static constexpr std::string_view project_description = "@PROJECT_DESCRIPTION@";
 static constexpr std::string_view git_sha = "@GIT_SHA@";
-static constexpr std::string_view data_path = "@BayesNet_SOURCE_DIR@/tests/data/";
--- a/data/_TAN_cpp_accuracy__.json
+++ b/data/_TAN_cpp_accuracy__.json
@@ -0,0 +1 @@
+null
--- a/tests/data/diabetes.arff
+++ b/tests/data/diabetes.arff
--- a/tests/data/ecoli.arff
+++ b/tests/data/ecoli.arff
--- a/tests/data/glass.arff
+++ b/tests/data/glass.arff
--- a/data/glass.net
+++ b/data/glass.net
@@ -0,0 +1,25 @@
+Type Si
+Type Fe
+Type RI
+Type Na
+Type Ba
+Type Ca
+Type Al
+Type K
+Type Mg
+Fe RI
+Fe Ba
+Fe Ca
+RI Na
+RI Ba
+RI Ca
+RI Al
+RI K
+RI Mg
+Ba Ca
+Ba Al
+Ca Al
+Ca K
+Ca Mg
+Al K
+K Mg
--- a/tests/data/iris.arff
+++ b/tests/data/iris.arff
--- a/tests/data/iris.net
+++ b/tests/data/iris.net
--- a/tests/data/kdd_JapaneseVowels.arff
+++ b/tests/data/kdd_JapaneseVowels.arff
--- a/tests/data/letter.arff
+++ b/tests/data/letter.arff
--- a/tests/data/liver-disorders.arff
+++ b/tests/data/liver-disorders.arff
--- a/data/mfeat-factors-kdb2.net
+++ b/data/mfeat-factors-kdb2.net
@@ -0,0 +1,645 @@
+class att215
+class att25
+class att131
+class att95
+class att122
+class att17
+class att28
+class att5
+class att121
+class att214
+class att197
+class att116
+class att182
+class att60
+class att168
+class att178
+class att206
+class att89
+class att77
+class att209
+class att73
+class att126
+class att16
+class att74
+class att27
+class att61
+class att20
+class att101
+class att85
+class att76
+class att137
+class att211
+class att143
+class att14
+class att40
+class att210
+class att155
+class att170
+class att160
+class att23
+class att162
+class att203
+class att164
+class att107
+class att62
+class att42
+class att71
+class att128
+class att138
+class att83
+class att171
+class att92
+class att163
+class att49
+class att161
+class att158
+class att176
+class att11
+class att145
+class att4
+class att172
+class att196
+class att58
+class att68
+class att169
+class att80
+class att32
+class att175
+class att87
+class att88
+class att159
+class att18
+class att52
+class att98
+class att136
+class att150
+class att156
+class att110
+class att100
+class att63
+class att148
+class att90
+class att167
+class att35
+class att205
+class att51
+class att21
+class att142
+class att46
+class att134
+class att39
+class att102
+class att208
+class att130
+class att149
+class att96
+class att75
+class att118
+class att78
+class att213
+class att112
+class att38
+class att174
+class att189
+class att70
+class att179
+class att59
+class att79
+class att15
+class att47
+class att124
+class att34
+class att54
+class att191
+class att86
+class att56
+class att151
+class att66
+class att173
+class att44
+class att198
+class att139
+class att216
+class att129
+class att152
+class att69
+class att81
+class att50
+class att153
+class att41
+class att204
+class att188
+class att26
+class att13
+class att117
+class att114
+class att10
+class att64
+class att200
+class att9
+class att3
+class att119
+class att45
+class att104
+class att140
+class att30
+class att183
+class att146
+class att141
+class att202
+class att194
+class att24
+class att147
+class att8
+class att212
+class att123
+class att166
+class att187
+class att127
+class att190
+class att105
+class att106
+class att184
+class att82
+class att2
+class att135
+class att154
+class att111
+class att115
+class att99
+class att22
+class att84
+class att207
+class att94
+class att177
+class att103
+class att93
+class att201
+class att43
+class att36
+class att12
+class att125
+class att165
+class att180
+class att195
+class att157
+class att48
+class att6
+class att113
+class att193
+class att91
+class att72
+class att31
+class att132
+class att33
+class att57
+class att144
+class att192
+class att185
+class att37
+class att53
+class att120
+class att186
+class att199
+class att65
+class att108
+class att133
+class att29
+class att19
+class att7
+class att97
+class att67
+class att55
+class att1
+class att109
+class att181
+att215 att25
+att215 att131
+att215 att95
+att25 att131
+att25 att121
+att25 att73
+att25 att61
+att25 att85
+att25 att169
+att25 att13
+att131 att95
+att131 att122
+att131 att17
+att131 att28
+att131 att121
+att131 att214
+att131 att116
+att131 att126
+att131 att143
+att95 att122
+att95 att17
+att95 att28
+att95 att5
+att95 att214
+att95 att116
+att95 att60
+att95 att143
+att95 att155
+att95 att71
+att122 att182
+att122 att170
+att17 att5
+att17 att197
+att17 att89
+att17 att77
+att17 att161
+att28 att206
+att28 att16
+att28 att76
+att28 att172
+att28 att124
+att28 att64
+att5 att197
+att5 att89
+att5 att209
+att121 att73
+att214 att178
+att214 att58
+att214 att142
+att197 att209
+att197 att101
+att116 att182
+att116 att60
+att116 att168
+att116 att178
+att116 att206
+att116 att126
+att116 att16
+att116 att27
+att116 att20
+att116 att211
+att116 att164
+att116 att128
+att182 att27
+att182 att14
+att60 att168
+att60 att156
+att168 att156
+att168 att96
+att178 att20
+att178 att58
+att178 att142
+att178 att130
+att206 att74
+att206 att170
+att206 att158
+att89 att77
+att89 att137
+att89 att149
+att89 att173
+att77 att137
+att77 att161
+att209 att101
+att209 att41
+att73 att61
+att73 att157
+att126 att162
+att126 att138
+att126 att150
+att16 att74
+att16 att76
+att16 att40
+att16 att4
+att74 att14
+att74 att62
+att27 att171
+att61 att85
+att61 att169
+att20 att211
+att20 att210
+att20 att164
+att20 att176
+att101 att41
+att85 att13
+att76 att40
+att76 att160
+att137 att149
+att211 att210
+att211 att162
+att211 att171
+att211 att163
+att211 att175
+att211 att79
+att143 att155
+att143 att23
+att143 att71
+att143 att83
+att143 att11
+att14 att98
+att40 att160
+att40 att4
+att40 att196
+att40 att52
+att210 att42
+att210 att114
+att155 att23
+att155 att203
+att155 att107
+att155 att11
+att170 att158
+att160 att52
+att23 att203
+att162 att138
+att162 att18
+att162 att150
+att162 att90
+att162 att174
+att203 att107
+att203 att49
+att203 att59
+att203 att191
+att203 att119
+att164 att62
+att164 att42
+att164 att128
+att164 att92
+att164 att163
+att164 att176
+att164 att145
+att164 att68
+att164 att80
+att164 att98
+att164 att110
+att164 att205
+att164 att21
+att164 att213
+att164 att112
+att164 att38
+att164 att56
+att164 att44
+att107 att59
+att107 att47
+att107 att191
+att71 att83
+att71 att167
+att71 att35
+att128 att92
+att138 att18
+att83 att167
+att171 att87
+att171 att159
+att171 att63
+att171 att51
+att171 att39
+att171 att75
+att163 att49
+att163 att175
+att163 att87
+att163 att79
+att163 att151
+att163 att139
+att163 att187
+att163 att91
+att161 att173
+att176 att145
+att176 att172
+att176 att68
+att176 att80
+att176 att32
+att176 att110
+att176 att205
+att176 att21
+att176 att134
+att176 att56
+att4 att196
+att4 att88
+att4 att136
+att4 att100
+att4 att148
+att4 att208
+att172 att112
+att172 att184
+att196 att88
+att196 att136
+att196 att100
+att196 att208
+att58 att46
+att68 att32
+att32 att200
+att87 att159
+att87 att63
+att87 att75
+att87 att15
+att87 att99
+att159 att195
+att18 att90
+att18 att102
+att18 att78
+att18 att198
+att52 att124
+att98 att86
+att150 att174
+att150 att66
+att156 att96
+att156 att216
+att156 att204
+att156 att24
+att156 att84
+att100 att148
+att63 att51
+att63 att3
+att63 att183
+att90 att102
+att90 att78
+att167 att35
+att167 att179
+att35 att179
+att51 att39
+att51 att3
+att21 att134
+att21 att213
+att21 att38
+att21 att189
+att21 att129
+att21 att81
+att21 att117
+att21 att9
+att142 att46
+att142 att130
+att142 att118
+att142 att10
+att142 att202
+att142 att190
+att142 att106
+att46 att70
+att46 att34
+att46 att166
+att134 att2
+att102 att54
+att130 att118
+att130 att10
+att130 att202
+att149 att125
+att96 att216
+att96 att24
+att75 att15
+att75 att99
+att118 att70
+att78 att198
+att213 att189
+att38 att50
+att38 att26
+att174 att54
+att174 att66
+att174 att30
+att189 att86
+att189 att129
+att189 att69
+att189 att81
+att189 att153
+att189 att117
+att189 att9
+att189 att45
+att189 att105
+att70 att34
+att59 att47
+att79 att151
+att79 att139
+att79 att187
+att79 att127
+att79 att103
+att79 att43
+att79 att91
+att79 att19
+att124 att64
+att54 att114
+att54 att30
+att191 att119
+att86 att194
+att56 att44
+att56 att152
+att56 att50
+att56 att188
+att56 att26
+att56 att104
+att56 att140
+att56 att146
+att56 att194
+att56 att8
+att56 att2
+att56 att133
+att56 att1
+att173 att125
+att173 att113
+att44 att152
+att44 att188
+att44 att200
+att44 att212
+att44 att1
+att139 att103
+att139 att43
+att139 att31
+att139 att199
+att139 att7
+att216 att204
+att216 att36
+att216 att12
+att216 att180
+att216 att108
+att129 att69
+att152 att140
+att69 att153
+att81 att45
+att153 att141
+att41 att53
+att204 att12
+att13 att157
+att114 att6
+att114 att186
+att10 att190
+att64 att184
+att200 att104
+att9 att146
+att9 att141
+att9 att177
+att9 att37
+att9 att133
+att9 att109
+att9 att181
+att3 att183
+att3 att147
+att3 att123
+att3 att135
+att3 att111
+att45 att105
+att45 att177
+att45 att93
+att45 att201
+att45 att193
+att45 att37
+att45 att97
+att140 att8
+att30 att6
+att183 att147
+att183 att123
+att202 att166
+att202 att106
+att202 att82
+att24 att84
+att24 att36
+att147 att135
+att8 att212
+att166 att82
+att187 att127
+att187 att115
+att127 att115
+att105 att93
+att106 att154
+att82 att154
+att82 att22
+att135 att111
+att135 att207
+att154 att22
+att154 att94
+att111 att207
+att22 att94
+att84 att48
+att177 att165
+att103 att195
+att103 att109
+att93 att201
+att93 att165
+att93 att193
+att93 att33
+att201 att33
+att201 att57
+att36 att180
+att36 att72
+att36 att132
+att36 att144
+att125 att113
+att125 att185
+att125 att65
+att125 att29
+att180 att48
+att180 att72
+att180 att192
+att180 att108
+att6 att186
+att113 att185
+att113 att53
+att193 att97
+att91 att31
+att91 att19
+att72 att132
+att72 att192
+att31 att199
+att31 att67
+att132 att144
+att132 att120
+att33 att57
+att144 att120
+att185 att65
+att199 att7
+att199 att67
+att199 att55
+att65 att29
+att67 att55
+att109 att181
--- a/data/mfeat-factors-kdb3.net
+++ b/data/mfeat-factors-kdb3.net
@@ -0,0 +1,859 @@
+class att215
+class att25
+class att131
+class att95
+class att122
+class att17
+class att28
+class att5
+class att121
+class att214
+class att197
+class att116
+class att182
+class att60
+class att168
+class att178
+class att206
+class att89
+class att77
+class att209
+class att73
+class att126
+class att16
+class att74
+class att27
+class att61
+class att20
+class att101
+class att85
+class att76
+class att137
+class att211
+class att143
+class att14
+class att40
+class att210
+class att155
+class att170
+class att160
+class att23
+class att162
+class att203
+class att164
+class att107
+class att62
+class att42
+class att71
+class att128
+class att138
+class att83
+class att171
+class att92
+class att163
+class att49
+class att161
+class att158
+class att176
+class att11
+class att145
+class att4
+class att172
+class att196
+class att58
+class att68
+class att169
+class att80
+class att32
+class att175
+class att87
+class att88
+class att159
+class att18
+class att52
+class att98
+class att136
+class att150
+class att156
+class att110
+class att100
+class att63
+class att148
+class att90
+class att167
+class att35
+class att205
+class att51
+class att21
+class att142
+class att46
+class att134
+class att39
+class att102
+class att208
+class att130
+class att149
+class att96
+class att75
+class att118
+class att78
+class att213
+class att112
+class att38
+class att174
+class att189
+class att70
+class att179
+class att59
+class att79
+class att15
+class att47
+class att124
+class att34
+class att54
+class att191
+class att86
+class att56
+class att151
+class att66
+class att173
+class att44
+class att198
+class att139
+class att216
+class att129
+class att152
+class att69
+class att81
+class att50
+class att153
+class att41
+class att204
+class att188
+class att26
+class att13
+class att117
+class att114
+class att10
+class att64
+class att200
+class att9
+class att3
+class att119
+class att45
+class att104
+class att140
+class att30
+class att183
+class att146
+class att141
+class att202
+class att194
+class att24
+class att147
+class att8
+class att212
+class att123
+class att166
+class att187
+class att127
+class att190
+class att105
+class att106
+class att184
+class att82
+class att2
+class att135
+class att154
+class att111
+class att115
+class att99
+class att22
+class att84
+class att207
+class att94
+class att177
+class att103
+class att93
+class att201
+class att43
+class att36
+class att12
+class att125
+class att165
+class att180
+class att195
+class att157
+class att48
+class att6
+class att113
+class att193
+class att91
+class att72
+class att31
+class att132
+class att33
+class att57
+class att144
+class att192
+class att185
+class att37
+class att53
+class att120
+class att186
+class att199
+class att65
+class att108
+class att133
+class att29
+class att19
+class att7
+class att97
+class att67
+class att55
+class att1
+class att109
+class att181
+att215 att25
+att215 att131
+att215 att95
+att215 att17
+att215 att214
+att215 att143
+att25 att131
+att25 att95
+att25 att122
+att25 att121
+att25 att73
+att25 att61
+att25 att85
+att25 att169
+att25 att13
+att25 att157
+att131 att95
+att131 att122
+att131 att17
+att131 att28
+att131 att5
+att131 att121
+att131 att214
+att131 att116
+att131 att182
+att131 att60
+att131 att126
+att131 att16
+att131 att27
+att131 att20
+att131 att143
+att131 att155
+att95 att122
+att95 att17
+att95 att28
+att95 att5
+att95 att121
+att95 att214
+att95 att197
+att95 att116
+att95 att60
+att95 att168
+att95 att178
+att95 att143
+att95 att155
+att95 att23
+att95 att71
+att95 att167
+att122 att28
+att122 att182
+att122 att170
+att17 att5
+att17 att197
+att17 att89
+att17 att77
+att17 att209
+att17 att137
+att17 att161
+att17 att41
+att28 att206
+att28 att16
+att28 att76
+att28 att40
+att28 att210
+att28 att160
+att28 att172
+att28 att124
+att28 att64
+att5 att197
+att5 att89
+att5 att77
+att5 att209
+att5 att101
+att121 att73
+att121 att61
+att214 att116
+att214 att178
+att214 att206
+att214 att58
+att214 att142
+att214 att46
+att197 att89
+att197 att209
+att197 att101
+att116 att182
+att116 att60
+att116 att168
+att116 att178
+att116 att206
+att116 att73
+att116 att126
+att116 att16
+att116 att74
+att116 att27
+att116 att20
+att116 att211
+att116 att164
+att116 att128
+att116 att92
+att116 att176
+att116 att68
+att182 att27
+att182 att14
+att60 att168
+att60 att156
+att60 att96
+att168 att126
+att168 att156
+att168 att96
+att168 att216
+att178 att20
+att178 att211
+att178 att58
+att178 att142
+att178 att130
+att178 att166
+att206 att74
+att206 att170
+att206 att158
+att89 att77
+att89 att137
+att89 att149
+att89 att173
+att77 att137
+att77 att161
+att77 att149
+att209 att101
+att209 att41
+att73 att61
+att73 att85
+att73 att13
+att73 att157
+att126 att162
+att126 att138
+att126 att18
+att126 att150
+att16 att74
+att16 att76
+att16 att40
+att16 att4
+att16 att196
+att16 att136
+att74 att14
+att74 att62
+att27 att171
+att27 att63
+att61 att85
+att61 att169
+att20 att76
+att20 att211
+att20 att210
+att20 att170
+att20 att164
+att20 att128
+att20 att176
+att20 att80
+att101 att41
+att85 att169
+att85 att13
+att76 att14
+att76 att40
+att76 att160
+att76 att4
+att76 att52
+att137 att161
+att137 att149
+att137 att173
+att137 att125
+att211 att210
+att211 att162
+att211 att164
+att211 att62
+att211 att42
+att211 att171
+att211 att163
+att211 att175
+att211 att79
+att211 att151
+att211 att43
+att143 att155
+att143 att23
+att143 att203
+att143 att71
+att143 att83
+att143 att11
+att14 att98
+att40 att160
+att40 att4
+att40 att196
+att40 att88
+att40 att52
+att210 att162
+att210 att42
+att210 att114
+att155 att23
+att155 att203
+att155 att107
+att155 att11
+att170 att158
+att160 att52
+att160 att124
+att23 att203
+att23 att107
+att23 att71
+att23 att11
+att162 att138
+att162 att18
+att162 att150
+att162 att90
+att162 att102
+att162 att174
+att162 att66
+att203 att107
+att203 att49
+att203 att59
+att203 att47
+att203 att191
+att203 att119
+att164 att62
+att164 att42
+att164 att128
+att164 att171
+att164 att92
+att164 att163
+att164 att158
+att164 att176
+att164 att145
+att164 att172
+att164 att58
+att164 att68
+att164 att80
+att164 att32
+att164 att98
+att164 att156
+att164 att110
+att164 att205
+att164 att21
+att164 att134
+att164 att213
+att164 att112
+att164 att38
+att164 att189
+att164 att56
+att164 att44
+att164 att152
+att164 att8
+att107 att83
+att107 att49
+att107 att59
+att107 att47
+att107 att191
+att42 att138
+att42 att54
+att42 att114
+att71 att83
+att71 att167
+att71 att35
+att71 att179
+att128 att92
+att128 att112
+att138 att18
+att138 att150
+att83 att167
+att83 att35
+att171 att87
+att171 att159
+att171 att63
+att171 att51
+att171 att39
+att171 att75
+att92 att163
+att92 att145
+att92 att56
+att163 att49
+att163 att175
+att163 att87
+att163 att79
+att163 att151
+att163 att139
+att163 att187
+att163 att127
+att163 att103
+att163 att91
+att49 att37
+att161 att173
+att161 att113
+att176 att145
+att176 att172
+att176 att68
+att176 att80
+att176 att32
+att176 att175
+att176 att98
+att176 att110
+att176 att205
+att176 att21
+att176 att134
+att176 att213
+att176 att56
+att4 att196
+att4 att88
+att4 att136
+att4 att100
+att4 att148
+att4 att208
+att172 att112
+att172 att184
+att196 att88
+att196 att136
+att196 att100
+att196 att148
+att196 att208
+att58 att142
+att58 att46
+att58 att34
+att68 att32
+att80 att38
+att32 att110
+att32 att21
+att32 att44
+att32 att200
+att175 att87
+att175 att159
+att175 att79
+att175 att187
+att175 att115
+att87 att159
+att87 att63
+att87 att51
+att87 att75
+att87 att15
+att87 att99
+att159 att75
+att159 att15
+att159 att195
+att18 att90
+att18 att102
+att18 att78
+att18 att198
+att52 att124
+att52 att64
+att98 att86
+att136 att100
+att136 att208
+att150 att90
+att150 att174
+att150 att66
+att156 att205
+att156 att96
+att156 att216
+att156 att204
+att156 att24
+att156 att84
+att156 att36
+att156 att12
+att156 att108
+att100 att148
+att63 att51
+att63 att39
+att63 att3
+att63 att183
+att63 att147
+att90 att102
+att90 att78
+att167 att35
+att167 att179
+att35 att179
+att51 att39
+att51 att3
+att51 att183
+att21 att134
+att21 att213
+att21 att38
+att21 att189
+att21 att129
+att21 att81
+att21 att153
+att21 att117
+att21 att9
+att142 att46
+att142 att130
+att142 att118
+att142 att70
+att142 att10
+att142 att202
+att142 att190
+att142 att106
+att46 att130
+att46 att118
+att46 att70
+att46 att34
+att46 att166
+att46 att82
+att134 att2
+att39 att3
+att102 att78
+att102 att174
+att102 att54
+att102 att198
+att130 att118
+att130 att10
+att130 att202
+att130 att190
+att130 att106
+att149 att125
+att96 att216
+att96 att204
+att96 att24
+att75 att15
+att75 att99
+att118 att70
+att118 att10
+att118 att202
+att78 att198
+att213 att189
+att213 att129
+att213 att69
+att213 att81
+att38 att50
+att38 att26
+att174 att54
+att174 att66
+att174 att30
+att189 att86
+att189 att129
+att189 att69
+att189 att81
+att189 att153
+att189 att117
+att189 att9
+att189 att45
+att189 att141
+att189 att105
+att70 att34
+att70 att154
+att179 att59
+att59 att47
+att59 att191
+att59 att119
+att79 att86
+att79 att151
+att79 att139
+att79 att187
+att79 att127
+att79 att103
+att79 att43
+att79 att193
+att79 att91
+att79 att19
+att124 att64
+att54 att114
+att54 att30
+att54 att6
+att191 att119
+att86 att194
+att56 att44
+att56 att152
+att56 att50
+att56 att188
+att56 att26
+att56 att200
+att56 att104
+att56 att140
+att56 att146
+att56 att194
+att56 att8
+att56 att2
+att56 att133
+att56 att1
+att151 att139
+att66 att30
+att173 att125
+att173 att113
+att173 att185
+att44 att152
+att44 att50
+att44 att188
+att44 att200
+att44 att104
+att44 att140
+att44 att194
+att44 att212
+att44 att1
+att139 att26
+att139 att99
+att139 att103
+att139 att43
+att139 att91
+att139 att31
+att139 att199
+att139 att7
+att216 att204
+att216 att24
+att216 att84
+att216 att36
+att216 att12
+att216 att180
+att216 att108
+att129 att69
+att152 att188
+att152 att140
+att69 att153
+att69 att9
+att69 att177
+att81 att45
+att81 att105
+att153 att117
+att153 att141
+att41 att53
+att204 att12
+att204 att180
+att188 att146
+att188 att212
+att13 att157
+att114 att6
+att114 att186
+att10 att190
+att64 att184
+att200 att104
+att9 att45
+att9 att146
+att9 att141
+att9 att177
+att9 att37
+att9 att133
+att9 att109
+att9 att181
+att3 att183
+att3 att147
+att3 att123
+att3 att135
+att3 att111
+att45 att105
+att45 att177
+att45 att93
+att45 att201
+att45 att165
+att45 att193
+att45 att33
+att45 att37
+att45 att133
+att45 att97
+att140 att8
+att30 att6
+att30 att186
+att183 att147
+att183 att123
+att183 att135
+att146 att2
+att202 att166
+att202 att106
+att202 att82
+att24 att84
+att24 att36
+att24 att132
+att147 att123
+att147 att135
+att147 att111
+att147 att207
+att8 att212
+att166 att82
+att166 att22
+att166 att94
+att187 att127
+att187 att115
+att127 att115
+att105 att184
+att105 att93
+att105 att201
+att106 att154
+att82 att154
+att82 att22
+att135 att111
+att135 att207
+att154 att22
+att154 att94
+att111 att207
+att99 att195
+att22 att94
+att84 att48
+att177 att93
+att177 att165
+att177 att181
+att103 att195
+att103 att97
+att103 att109
+att93 att201
+att93 att165
+att93 att193
+att93 att33
+att93 att57
+att201 att33
+att201 att57
+att43 att31
+att36 att180
+att36 att48
+att36 att72
+att36 att132
+att36 att144
+att125 att113
+att125 att185
+att125 att65
+att125 att29
+att180 att48
+att180 att72
+att180 att192
+att180 att108
+att48 att72
+att6 att186
+att113 att185
+att113 att53
+att113 att65
+att193 att97
+att91 att31
+att91 att199
+att91 att19
+att72 att132
+att72 att144
+att72 att192
+att72 att120
+att31 att199
+att31 att7
+att31 att67
+att31 att55
+att31 att1
+att132 att144
+att132 att120
+att33 att57
+att144 att192
+att144 att120
+att185 att53
+att185 att65
+att185 att29
+att199 att19
+att199 att7
+att199 att67
+att199 att55
+att199 att109
+att65 att29
+att7 att67
+att67 att55
+att109 att181
+
--- a/tests/data/mfeat-factors.arff
+++ b/tests/data/mfeat-factors.arff
--- a/data/mfeat-factors.net
+++ b/data/mfeat-factors.net
@@ -0,0 +1,859 @@
+class att215
+class att25
+class att131
+class att95
+class att122
+class att17
+class att28
+class att5
+class att121
+class att214
+class att197
+class att116
+class att182
+class att60
+class att168
+class att178
+class att206
+class att89
+class att77
+class att209
+class att73
+class att126
+class att16
+class att74
+class att27
+class att61
+class att20
+class att101
+class att85
+class att76
+class att137
+class att211
+class att143
+class att14
+class att40
+class att210
+class att155
+class att170
+class att160
+class att23
+class att162
+class att203
+class att164
+class att107
+class att62
+class att42
+class att71
+class att128
+class att138
+class att83
+class att171
+class att92
+class att163
+class att49
+class att161
+class att158
+class att176
+class att11
+class att145
+class att4
+class att172
+class att196
+class att58
+class att68
+class att169
+class att80
+class att32
+class att175
+class att87
+class att88
+class att159
+class att18
+class att52
+class att98
+class att136
+class att150
+class att156
+class att110
+class att100
+class att63
+class att148
+class att90
+class att167
+class att35
+class att205
+class att51
+class att21
+class att142
+class att46
+class att134
+class att39
+class att102
+class att208
+class att130
+class att149
+class att96
+class att75
+class att118
+class att78
+class att213
+class att112
+class att38
+class att174
+class att189
+class att70
+class att179
+class att59
+class att79
+class att15
+class att47
+class att124
+class att34
+class att54
+class att191
+class att86
+class att56
+class att151
+class att66
+class att173
+class att44
+class att198
+class att139
+class att216
+class att129
+class att152
+class att69
+class att81
+class att50
+class att153
+class att41
+class att204
+class att188
+class att26
+class att13
+class att117
+class att114
+class att10
+class att64
+class att200
+class att9
+class att3
+class att119
+class att45
+class att104
+class att140
+class att30
+class att183
+class att146
+class att141
+class att202
+class att194
+class att24
+class att147
+class att8
+class att212
+class att123
+class att166
+class att187
+class att127
+class att190
+class att105
+class att106
+class att184
+class att82
+class att2
+class att135
+class att154
+class att111
+class att115
+class att99
+class att22
+class att84
+class att207
+class att94
+class att177
+class att103
+class att93
+class att201
+class att43
+class att36
+class att12
+class att125
+class att165
+class att180
+class att195
+class att157
+class att48
+class att6
+class att113
+class att193
+class att91
+class att72
+class att31
+class att132
+class att33
+class att57
+class att144
+class att192
+class att185
+class att37
+class att53
+class att120
+class att186
+class att199
+class att65
+class att108
+class att133
+class att29
+class att19
+class att7
+class att97
+class att67
+class att55
+class att1
+class att109
+class att181
+att215 att25
+att215 att131
+att215 att95
+att215 att17
+att215 att214
+att215 att143
+att25 att131
+att25 att95
+att25 att122
+att25 att121
+att25 att73
+att25 att61
+att25 att85
+att25 att169
+att25 att13
+att25 att157
+att131 att95
+att131 att122
+att131 att17
+att131 att28
+att131 att5
+att131 att121
+att131 att214
+att131 att116
+att131 att182
+att131 att60
+att131 att126
+att131 att16
+att131 att27
+att131 att20
+att131 att143
+att131 att155
+att95 att122
+att95 att17
+att95 att28
+att95 att5
+att95 att121
+att95 att214
+att95 att197
+att95 att116
+att95 att60
+att95 att168
+att95 att178
+att95 att143
+att95 att155
+att95 att23
+att95 att71
+att95 att167
+att122 att28
+att122 att182
+att122 att170
+att17 att5
+att17 att197
+att17 att89
+att17 att77
+att17 att209
+att17 att137
+att17 att161
+att17 att41
+att28 att206
+att28 att16
+att28 att76
+att28 att40
+att28 att210
+att28 att160
+att28 att172
+att28 att124
+att28 att64
+att5 att197
+att5 att89
+att5 att77
+att5 att209
+att5 att101
+att121 att73
+att121 att61
+att214 att116
+att214 att178
+att214 att206
+att214 att58
+att214 att142
+att214 att46
+att197 att89
+att197 att209
+att197 att101
+att116 att182
+att116 att60
+att116 att168
+att116 att178
+att116 att206
+att116 att73
+att116 att126
+att116 att16
+att116 att74
+att116 att27
+att116 att20
+att116 att211
+att116 att164
+att116 att128
+att116 att92
+att116 att176
+att116 att68
+att182 att27
+att182 att14
+att60 att168
+att60 att156
+att60 att96
+att168 att126
+att168 att156
+att168 att96
+att168 att216
+att178 att20
+att178 att211
+att178 att58
+att178 att142
+att178 att130
+att178 att166
+att206 att74
+att206 att170
+att206 att158
+att89 att77
+att89 att137
+att89 att149
+att89 att173
+att77 att137
+att77 att161
+att77 att149
+att209 att101
+att209 att41
+att73 att61
+att73 att85
+att73 att13
+att73 att157
+att126 att162
+att126 att138
+att126 att18
+att126 att150
+att16 att74
+att16 att76
+att16 att40
+att16 att4
+att16 att196
+att16 att136
+att74 att14
+att74 att62
+att27 att171
+att27 att63
+att61 att85
+att61 att169
+att20 att76
+att20 att211
+att20 att210
+att20 att170
+att20 att164
+att20 att128
+att20 att176
+att20 att80
+att101 att41
+att85 att169
+att85 att13
+att76 att14
+att76 att40
+att76 att160
+att76 att4
+att76 att52
+att137 att161
+att137 att149
+att137 att173
+att137 att125
+att211 att210
+att211 att162
+att211 att164
+att211 att62
+att211 att42
+att211 att171
+att211 att163
+att211 att175
+att211 att79
+att211 att151
+att211 att43
+att143 att155
+att143 att23
+att143 att203
+att143 att71
+att143 att83
+att143 att11
+att14 att98
+att40 att160
+att40 att4
+att40 att196
+att40 att88
+att40 att52
+att210 att162
+att210 att42
+att210 att114
+att155 att23
+att155 att203
+att155 att107
+att155 att11
+att170 att158
+att160 att52
+att160 att124
+att23 att203
+att23 att107
+att23 att71
+att23 att11
+att162 att138
+att162 att18
+att162 att150
+att162 att90
+att162 att102
+att162 att174
+att162 att66
+att203 att107
+att203 att49
+att203 att59
+att203 att47
+att203 att191
+att203 att119
+att164 att62
+att164 att42
+att164 att128
+att164 att171
+att164 att92
+att164 att163
+att164 att158
+att164 att176
+att164 att145
+att164 att172
+att164 att58
+att164 att68
+att164 att80
+att164 att32
+att164 att98
+att164 att156
+att164 att110
+att164 att205
+att164 att21
+att164 att134
+att164 att213
+att164 att112
+att164 att38
+att164 att189
+att164 att56
+att164 att44
+att164 att152
+att164 att8
+att107 att83
+att107 att49
+att107 att59
+att107 att47
+att107 att191
+att42 att138
+att42 att54
+att42 att114
+att71 att83
+att71 att167
+att71 att35
+att71 att179
+att128 att92
+att128 att112
+att138 att18
+att138 att150
+att83 att167
+att83 att35
+att171 att87
+att171 att159
+att171 att63
+att171 att51
+att171 att39
+att171 att75
+att92 att163
+att92 att145
+att92 att56
+att163 att49
+att163 att175
+att163 att87
+att163 att79
+att163 att151
+att163 att139
+att163 att187
+att163 att127
+att163 att103
+att163 att91
+att49 att37
+att161 att173
+att161 att113
+att176 att145
+att176 att172
+att176 att68
+att176 att80
+att176 att32
+att176 att175
+att176 att98
+att176 att110
+att176 att205
+att176 att21
+att176 att134
+att176 att213
+att176 att56
+att4 att196
+att4 att88
+att4 att136
+att4 att100
+att4 att148
+att4 att208
+att172 att112
+att172 att184
+att196 att88
+att196 att136
+att196 att100
+att196 att148
+att196 att208
+att58 att142
+att58 att46
+att58 att34
+att68 att32
+att80 att38
+att32 att110
+att32 att21
+att32 att44
+att32 att200
+att175 att87
+att175 att159
+att175 att79
+att175 att187
+att175 att115
+att87 att159
+att87 att63
+att87 att51
+att87 att75
+att87 att15
+att87 att99
+att159 att75
+att159 att15
+att159 att195
+att18 att90
+att18 att102
+att18 att78
+att18 att198
+att52 att124
+att52 att64
+att98 att86
+att136 att100
+att136 att208
+att150 att90
+att150 att174
+att150 att66
+att156 att205
+att156 att96
+att156 att216
+att156 att204
+att156 att24
+att156 att84
+att156 att36
+att156 att12
+att156 att108
+att100 att148
+att63 att51
+att63 att39
+att63 att3
+att63 att183
+att63 att147
+att90 att102
+att90 att78
+att167 att35
+att167 att179
+att35 att179
+att51 att39
+att51 att3
+att51 att183
+att21 att134
+att21 att213
+att21 att38
+att21 att189
+att21 att129
+att21 att81
+att21 att153
+att21 att117
+att21 att9
+att142 att46
+att142 att130
+att142 att118
+att142 att70
+att142 att10
+att142 att202
+att142 att190
+att142 att106
+att46 att130
+att46 att118
+att46 att70
+att46 att34
+att46 att166
+att46 att82
+att134 att2
+att39 att3
+att102 att78
+att102 att174
+att102 att54
+att102 att198
+att130 att118
+att130 att10
+att130 att202
+att130 att190
+att130 att106
+att149 att125
+att96 att216
+att96 att204
+att96 att24
+att75 att15
+att75 att99
+att118 att70
+att118 att10
+att118 att202
+att78 att198
+att213 att189
+att213 att129
+att213 att69
+att213 att81
+att38 att50
+att38 att26
+att174 att54
+att174 att66
+att174 att30
+att189 att86
+att189 att129
+att189 att69
+att189 att81
+att189 att153
+att189 att117
+att189 att9
+att189 att45
+att189 att141
+att189 att105
+att70 att34
+att70 att154
+att179 att59
+att59 att47
+att59 att191
+att59 att119
+att79 att86
+att79 att151
+att79 att139
+att79 att187
+att79 att127
+att79 att103
+att79 att43
+att79 att193
+att79 att91
+att79 att19
+att124 att64
+att54 att114
+att54 att30
+att54 att6
+att191 att119
+att86 att194
+att56 att44
+att56 att152
+att56 att50
+att56 att188
+att56 att26
+att56 att200
+att56 att104
+att56 att140
+att56 att146
+att56 att194
+att56 att8
+att56 att2
+att56 att133
+att56 att1
+att151 att139
+att66 att30
+att173 att125
+att173 att113
+att173 att185
+att44 att152
+att44 att50
+att44 att188
+att44 att200
+att44 att104
+att44 att140
+att44 att194
+att44 att212
+att44 att1
+att139 att26
+att139 att99
+att139 att103
+att139 att43
+att139 att91
+att139 att31
+att139 att199
+att139 att7
+att216 att204
+att216 att24
+att216 att84
+att216 att36
+att216 att12
+att216 att180
+att216 att108
+att129 att69
+att152 att188
+att152 att140
+att69 att153
+att69 att9
+att69 att177
+att81 att45
+att81 att105
+att153 att117
+att153 att141
+att41 att53
+att204 att12
+att204 att180
+att188 att146
+att188 att212
+att13 att157
+att114 att6
+att114 att186
+att10 att190
+att64 att184
+att200 att104
+att9 att45
+att9 att146
+att9 att141
+att9 att177
+att9 att37
+att9 att133
+att9 att109
+att9 att181
+att3 att183
+att3 att147
+att3 att123
+att3 att135
+att3 att111
+att45 att105
+att45 att177
+att45 att93
+att45 att201
+att45 att165
+att45 att193
+att45 att33
+att45 att37
+att45 att133
+att45 att97
+att140 att8
+att30 att6
+att30 att186
+att183 att147
+att183 att123
+att183 att135
+att146 att2
+att202 att166
+att202 att106
+att202 att82
+att24 att84
+att24 att36
+att24 att132
+att147 att123
+att147 att135
+att147 att111
+att147 att207
+att8 att212
+att166 att82
+att166 att22
+att166 att94
+att187 att127
+att187 att115
+att127 att115
+att105 att184
+att105 att93
+att105 att201
+att106 att154
+att82 att154
+att82 att22
+att135 att111
+att135 att207
+att154 att22
+att154 att94
+att111 att207
+att99 att195
+att22 att94
+att84 att48
+att177 att93
+att177 att165
+att177 att181
+att103 att195
+att103 att97
+att103 att109
+att93 att201
+att93 att165
+att93 att193
+att93 att33
+att93 att57
+att201 att33
+att201 att57
+att43 att31
+att36 att180
+att36 att48
+att36 att72
+att36 att132
+att36 att144
+att125 att113
+att125 att185
+att125 att65
+att125 att29
+att180 att48
+att180 att72
+att180 att192
+att180 att108
+att48 att72
+att6 att186
+att113 att185
+att113 att53
+att113 att65
+att193 att97
+att91 att31
+att91 att199
+att91 att19
+att72 att132
+att72 att144
+att72 att192
+att72 att120
+att31 att199
+att31 att7
+att31 att67
+att31 att55
+att31 att1
+att132 att144
+att132 att120
+att33 att57
+att144 att192
+att144 att120
+att185 att53
+att185 att65
+att185 att29
+att199 att19
+att199 att7
+att199 att67
+att199 att55
+att199 att109
+att65 att29
+att7 att67
+att67 att55
+att109 att181
+
--- a/diagrams/BayesNet.pdf
+++ b/diagrams/BayesNet.pdf
--- a/gcovr.cfg
+++ b/gcovr.cfg
@@ -1,4 +1,5 @@
 filter = src/
-exclude-directories = build_debug/lib/
+exclude = external/
+exclude = tests/
 print-summary = yes
 sort-percentage = yes
--- a/lib/Files/ArffFiles.cc
+++ b/lib/Files/ArffFiles.cc
@@ -4,9 +4,11 @@
 #include <map>
 #include <iostream>

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

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

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

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

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

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

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

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

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

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

-std::string ArffFiles::trim(const std::string& source)
+string ArffFiles::trim(const string& source)
 {
-    std::string s(source);
+    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;
 }

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

+using namespace std;
+
 class ArffFiles {
 private:
-    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;
+    vector<string> lines;
+    vector<pair<string, string>> attributes;
+    string className;
+    string classType;
+    vector<vector<float>> X;
+    vector<int> y;
    void generateDataset(int);
-    void loadCommon(std::string);
+    void loadCommon(string);
 public:
    ArffFiles();
-    void load(const std::string&, bool = true);
-    void load(const std::string&, const std::string&);
-    std::vector<std::string> getLines() const;
+    void load(const string&, bool = true);
+    void load(const string&, const string&);
+    vector<string> getLines() const;
    unsigned long int getSize() const;
-    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);
+    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);
 };

 #endif
--- a/lib/Files/CMakeLists.txt
+++ b/lib/Files/CMakeLists.txt
@@ -1 +1,2 @@
 add_library(ArffFiles ArffFiles.cc)
+#target_link_libraries(BayesNet "${TORCH_LIBRARIES}")
--- a/lib/argparse
+++ b/lib/argparse
--- a/lib/catch2
+++ b/lib/catch2
--- a/lib/folding
+++ b/lib/folding
--- a/lib/json
+++ b/lib/json
--- a/lib/mdlp
+++ b/lib/mdlp
--- a/sample/CMakeLists.txt
+++ b/sample/CMakeLists.txt
@@ -0,0 +1,7 @@
+include_directories(${BayesNet_SOURCE_DIR}/src/Platform)
+include_directories(${BayesNet_SOURCE_DIR}/src/BayesNet)
+include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
+include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
+include_directories(${BayesNet_SOURCE_DIR}/lib/argparse/include)
+add_executable(BayesNetSample sample.cc ${BayesNet_SOURCE_DIR}/src/Platform/Folding.cc ${BayesNet_SOURCE_DIR}/src/Platform/Models.cc) 
+target_link_libraries(BayesNetSample BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}")
--- a/sample/sample.cc
+++ b/sample/sample.cc
@@ -0,0 +1,222 @@
+#include <iostream>
+#include <torch/torch.h>
+#include <string>
+#include <thread>
+#include <map>
+#include <argparse/argparse.hpp>
+#include "ArffFiles.h"
+#include "BayesMetrics.h"
+#include "CPPFImdlp.h"
+#include "Folding.h"
+#include "Models.h"
+
+
+using namespace std;
+
+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)
+{
+    vector<mdlp::labels_t>Xd;
+    map<string, int> maxes;
+
+    auto fimdlp = mdlp::CPPFImdlp();
+    for (int i = 0; i < X.size(); i++) {
+        fimdlp.fit(X[i], y);
+        mdlp::labels_t& xd = fimdlp.transform(X[i]);
+        maxes[features[i]] = *max_element(xd.begin(), xd.end()) + 1;
+        Xd.push_back(xd);
+    }
+    return { Xd, maxes };
+}
+
+bool file_exists(const std::string& name)
+{
+    if (FILE* file = fopen(name.c_str(), "r")) {
+        fclose(file);
+        return true;
+    } else {
+        return false;
+    }
+}
+pair<vector<vector<int>>, vector<int>> extract_indices(vector<int> indices, vector<vector<int>> X, vector<int> y)
+{
+    vector<vector<int>> Xr;
+    vector<int> yr;
+    for (int col = 0; col < X.size(); ++col) {
+        Xr.push_back(vector<int>());
+    }
+    for (auto index : indices) {
+        for (int col = 0; col < X.size(); ++col) {
+            Xr[col].push_back(X[col][index]);
+        }
+        yr.push_back(y[index]);
+    }
+    return { Xr, yr };
+}
+
+int main(int argc, char** argv)
+{
+    map<string, bool> datasets = {
+            {"diabetes",           true},
+            {"ecoli",              true},
+            {"glass",              true},
+            {"iris",               true},
+            {"kdd_JapaneseVowels", false},
+            {"letter",             true},
+            {"liver-disorders",    true},
+            {"mfeat-factors",      true},
+    };
+    auto valid_datasets = vector<string>();
+    for (auto dataset : datasets) {
+        valid_datasets.push_back(dataset.first);
+    }
+    argparse::ArgumentParser program("BayesNetSample");
+    program.add_argument("-d", "--dataset")
+        .help("Dataset file name")
+        .action([valid_datasets](const std::string& value) {
+        if (find(valid_datasets.begin(), valid_datasets.end(), value) != valid_datasets.end()) {
+            return value;
+        }
+        throw runtime_error("file must be one of {diabetes, ecoli, glass, iris, kdd_JapaneseVowels, letter, liver-disorders, mfeat-factors}");
+            }
+    );
+    program.add_argument("-p", "--path")
+        .help(" folder where the data files are located, default")
+        .default_value(string{ PATH }
+    );
+    program.add_argument("-m", "--model")
+        .help("Model to use " + platform::Models::toString())
+        .action([](const std::string& value) {
+        static const vector<string> choices = platform::Models::getNames();
+        if (find(choices.begin(), choices.end(), value) != choices.end()) {
+            return value;
+        }
+        throw runtime_error("Model must be one of " + platform::Models::toString());
+            }
+    );
+    program.add_argument("--discretize").help("Discretize input dataset").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) {
+        try {
+            auto k = stoi(value);
+            if (k < 2) {
+                throw runtime_error("Number of folds must be greater than 1");
+            }
+            return k;
+        }
+        catch (const runtime_error& err) {
+            throw runtime_error(err.what());
+        }
+        catch (...) {
+            throw runtime_error("Number of folds must be an integer");
+        }});
+    program.add_argument("-s", "--seed").help("Random seed").default_value(-1).scan<'i', int>();
+    bool class_last, stratified, tensors;
+    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");
+        complete_file_name = path + file_name + ".arff";
+        stratified = program.get<bool>("stratified");
+        tensors = program.get<bool>("tensors");
+        nFolds = program.get<int>("folds");
+        seed = program.get<int>("seed");
+        class_last = datasets[file_name];
+        if (!file_exists(complete_file_name)) {
+            throw runtime_error("Data File " + path + file_name + ".arff" + " does not exist");
+        }
+    }
+    catch (const exception& err) {
+        cerr << err.what() << endl;
+        cerr << program;
+        exit(1);
+    }
+
+    /*
+    * Begin Processing
+    */
+    auto handler = ArffFiles();
+    handler.load(complete_file_name, class_last);
+    // Get Dataset X, y
+    vector<mdlp::samples_t>& X = handler.getX();
+    mdlp::labels_t& y = handler.getY();
+    // Get className & Features
+    auto className = handler.getClassName();
+    vector<string> features;
+    for (auto feature : handler.getAttributes()) {
+        features.push_back(feature.first);
+    }
+    // Discretize Dataset
+    auto [Xd, maxes] = discretize(X, y, features);
+    maxes[className] = *max_element(y.begin(), y.end()) + 1;
+    map<string, vector<int>> states;
+    for (auto feature : features) {
+        states[feature] = vector<int>(maxes[feature]);
+    }
+    states[className] = vector<int>(maxes[className]);
+
+    bayesnet::BaseClassifier* clf = platform::Models::get(model_name);
+    clf->fit(Xd, y, features, className, states);
+    auto score = clf->score(Xd, y);
+    auto lines = clf->show();
+    auto graph = clf->graph();
+    for (auto line : lines) {
+        cout << line << endl;
+    }
+    cout << "Score: " << score << endl;
+    auto dot_file = model_name + "_" + file_name;
+    ofstream file(dot_file + ".dot");
+    file << graph;
+    file.close();
+    cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << endl;
+    cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << endl;
+    string stratified_string = stratified ? " Stratified" : "";
+    cout << nFolds << " Folds" << stratified_string << " Cross validation" << endl;
+    cout << "==========================================" << endl;
+    torch::Tensor Xt = torch::zeros({ static_cast<int>(Xd.size()), static_cast<int>(Xd[0].size()) }, torch::kInt32);
+    torch::Tensor yt = torch::tensor(y, torch::kInt32);
+    for (int i = 0; i < features.size(); ++i) {
+        Xt.index_put_({ i, "..." }, torch::tensor(Xd[i], torch::kInt32));
+    }
+    float total_score = 0, total_score_train = 0, score_train, score_test;
+    Fold* fold;
+    if (stratified)
+        fold = new StratifiedKFold(nFolds, y, seed);
+    else
+        fold = new KFold(nFolds, y.size(), seed);
+    for (auto i = 0; i < nFolds; ++i) {
+        auto [train, test] = fold->getFold(i);
+        cout << "Fold: " << i + 1 << endl;
+        if (tensors) {
+            auto ttrain = torch::tensor(train, torch::kInt64);
+            auto ttest = torch::tensor(test, torch::kInt64);
+            torch::Tensor Xtraint = torch::index_select(Xt, 1, ttrain);
+            torch::Tensor ytraint = yt.index({ ttrain });
+            torch::Tensor Xtestt = torch::index_select(Xt, 1, ttest);
+            torch::Tensor ytestt = yt.index({ ttest });
+            clf->fit(Xtraint, ytraint, features, className, states);
+            score_train = clf->score(Xtraint, ytraint);
+            score_test = clf->score(Xtestt, ytestt);
+        } else {
+            auto [Xtrain, ytrain] = extract_indices(train, Xd, y);
+            auto [Xtest, ytest] = extract_indices(test, Xd, y);
+            clf->fit(Xtrain, ytrain, features, className, states);
+            score_train = clf->score(Xtrain, ytrain);
+            score_test = clf->score(Xtest, ytest);
+        }
+        total_score_train += score_train;
+        total_score += score_test;
+        cout << "Score Train: " << score_train << endl;
+        cout << "Score Test : " << score_test << endl;
+        cout << "-------------------------------------------------------------------------------" << endl;
+    }
+    cout << "**********************************************************************************" << endl;
+    cout << "Average Score Train: " << total_score_train / nFolds << endl;
+    cout << "Average Score Test : " << total_score / nFolds << endl;
+    return 0;
+}
--- a/src/BayesNet/AODE.cc
+++ b/src/BayesNet/AODE.cc
@@ -2,16 +2,14 @@

 namespace bayesnet {
    AODE::AODE() : Ensemble() {}
-    void AODE::buildModel(const torch::Tensor& weights)
+    void AODE::train()
    {
        models.clear();
        for (int i = 0; i < features.size(); ++i) {
            models.push_back(std::make_unique<SPODE>(i));
        }
-        n_models = models.size();
-        significanceModels = std::vector<double>(n_models, 1.0);
    }
-    std::vector<std::string> AODE::graph(const std::string& title) const
+    vector<string> AODE::graph(string title)
    {
        return Ensemble::graph(title);
    }
--- a/src/BayesNet/AODE.h
+++ b/src/BayesNet/AODE.h
@@ -5,11 +5,10 @@
 namespace bayesnet {
    class AODE : public Ensemble {
    protected:
-        void buildModel(const torch::Tensor& weights) override;
+        void train() override;
    public:
        AODE();
-        virtual ~AODE() {};
-        std::vector<std::string> graph(const std::string& title = "AODE") const override;
+        vector<string> graph(string title = "AODE") override;
    };
 }
 #endif
--- a/src/BayesNet/AODELd.cc
+++ b/src/BayesNet/AODELd.cc
@@ -1,39 +0,0 @@
-#include "AODELd.h"
-
-namespace bayesnet {
-    AODELd::AODELd() : Ensemble(), Proposal(dataset, features, className) {}
-    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 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
-        Ensemble::fit(dataset, features, className, states);
-        return *this;
-
-    }
-    void AODELd::buildModel(const torch::Tensor& weights)
-    {
-        models.clear();
-        for (int i = 0; i < features.size(); ++i) {
-            models.push_back(std::make_unique<SPODELd>(i));
-        }
-        n_models = models.size();
-        significanceModels = std::vector<double>(n_models, 1.0);
-    }
-    void AODELd::trainModel(const torch::Tensor& weights)
-    {
-        for (const auto& model : models) {
-            model->fit(Xf, y, features, className, states);
-        }
-    }
-    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
@@ -1,20 +0,0 @@
-#ifndef AODELD_H
-#define AODELD_H
-#include "Ensemble.h"
-#include "Proposal.h"
-#include "SPODELd.h"
-
-namespace bayesnet {
-    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 std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_) override;
-        virtual ~AODELd() = default;
-        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
@@ -1,38 +1,23 @@
 #ifndef BASE_H
 #define BASE_H
 #include <torch/torch.h>
-#include <nlohmann/json.hpp>
 #include <vector>
 namespace bayesnet {
-    enum status_t { NORMAL, WARNING, ERROR };
+    using namespace std;
    class BaseClassifier {
    public:
-        // X is nxm std::vector, y is nx1 std::vector
-        virtual BaseClassifier& fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) = 0;
-        // X is nxm tensor, y is nx1 tensor
-        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;
-        std::vector<int> virtual predict(std::vector<std::vector<int >>& X) = 0;
-        status_t virtual getStatus() const = 0;
-        float virtual score(std::vector<std::vector<int>>& X, std::vector<int>& y) = 0;
+        virtual BaseClassifier& fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states) = 0;
+        virtual BaseClassifier& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) = 0;
+        vector<int> virtual predict(vector<vector<int>>& X) = 0;
+        float virtual score(vector<vector<int>>& X, vector<int>& y) = 0;
        float virtual score(torch::Tensor& X, torch::Tensor& y) = 0;
-        int virtual getNumberOfNodes()const = 0;
-        int virtual getNumberOfEdges()const = 0;
-        int virtual getNumberOfStates() const = 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;
-        std::vector<std::string> virtual getNotes() const = 0;
-        void virtual dump_cpt()const = 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;
+        int virtual getNumberOfNodes() = 0;
+        int virtual getNumberOfEdges() = 0;
+        int virtual getNumberOfStates() = 0;
+        vector<string> virtual show() = 0;
+        vector<string> virtual graph(string title = "") = 0;
+        virtual ~BaseClassifier() = default;
+        const string inline getVersion() const { return "0.1.0"; };
    };
 }
 #endif
--- a/src/BayesNet/BayesMetrics.cc
+++ b/src/BayesNet/BayesMetrics.cc
@@ -1,89 +1,57 @@
 #include "BayesMetrics.h"
 #include "Mst.h"
 namespace bayesnet {
-    //samples is n+1xm tensor used to fit the model
-    Metrics::Metrics(const torch::Tensor& samples, const std::vector<std::string>& features, const std::string& className, const int classNumStates)
+    Metrics::Metrics(torch::Tensor& samples, vector<string>& features, string& className, int classNumStates)
        : samples(samples)
        , features(features)
        , className(className)
        , classNumStates(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)
+    Metrics::Metrics(const vector<vector<int>>& vsamples, const vector<int>& labels, const vector<string>& features, const string& className, const int classNumStates)
        : features(features)
        , className(className)
        , classNumStates(classNumStates)
        , samples(torch::zeros({ static_cast<int>(vsamples[0].size()), static_cast<int>(vsamples.size() + 1) }, torch::kInt32))
    {
        for (int i = 0; i < vsamples.size(); ++i) {
-            samples.index_put_({ i,  "..." }, torch::tensor(vsamples[i], torch::kInt32));
+            samples.index_put_({ "...", i }, torch::tensor(vsamples[i], torch::kInt32));
        }
-        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
+        samples.index_put_({ "...", -1 }, torch::tensor(labels, torch::kInt32));
    }
-    std::vector<int> Metrics::SelectKBestWeighted(const torch::Tensor& weights, bool ascending, unsigned k)
+    vector<pair<string, string>> Metrics::doCombinations(const vector<string>& source)
    {
-        // Return the K Best features 
-        auto n = samples.size(0) - 1;
-        if (k == 0) {
-            k = n;
-        }
-        // compute scores
-        scoresKBest.clear();
-        featuresKBest.clear();
-        auto label = samples.index({ -1, "..." });
-        for (int i = 0; i < n; ++i) {
-            scoresKBest.push_back(mutualInformation(label, samples.index({ i, "..." }), weights));
-            featuresKBest.push_back(i);
-        }
-        // sort & reduce scores and features
-        if (ascending) {
-            sort(featuresKBest.begin(), featuresKBest.end(), [&](int i, int j)
-                { return scoresKBest[i] < scoresKBest[j]; });
-            sort(scoresKBest.begin(), scoresKBest.end(), std::less<double>());
-            if (k < n) {
-                for (int i = 0; i < n - k; ++i) {
-                    featuresKBest.erase(featuresKBest.begin());
-                    scoresKBest.erase(scoresKBest.begin());
-                }
+        vector<pair<string, string>> result;
+        for (int i = 0; i < source.size(); ++i) {
+            string temp = source[i];
+            for (int j = i + 1; j < source.size(); ++j) {
+                result.push_back({ temp, source[j] });
            }
-        } else {
-            sort(featuresKBest.begin(), featuresKBest.end(), [&](int i, int j)
-                { return scoresKBest[i] > scoresKBest[j]; });
-            sort(scoresKBest.begin(), scoresKBest.end(), std::greater<double>());
-            featuresKBest.resize(k);
-            scoresKBest.resize(k);
        }
-        return featuresKBest;
+        return result;
    }
-    std::vector<double> Metrics::getScoresKBest() const
+    torch::Tensor Metrics::conditionalEdge()
    {
-        return scoresKBest;
-    }
-
-    torch::Tensor Metrics::conditionalEdge(const torch::Tensor& weights)
-    {
-        auto result = std::vector<double>();
-        auto source = std::vector<std::string>(features);
+        auto result = vector<double>();
+        auto source = vector<string>(features);
        source.push_back(className);
        auto combinations = doCombinations(source);
        // Compute class prior
-        auto margin = torch::zeros({ classNumStates }, torch::kFloat);
+        auto margin = torch::zeros({ classNumStates });
        for (int value = 0; value < classNumStates; ++value) {
-            auto mask = samples.index({ -1,  "..." }) == value;
-            margin[value] = mask.sum().item<double>() / samples.size(1);
+            auto mask = samples.index({ "...", -1 }) == value;
+            margin[value] = mask.sum().item<float>() / samples.sizes()[0];
        }
        for (auto [first, second] : combinations) {
            int index_first = find(features.begin(), features.end(), first) - features.begin();
            int index_second = find(features.begin(), features.end(), second) - features.begin();
            double accumulated = 0;
            for (int value = 0; value < classNumStates; ++value) {
-                auto mask = samples.index({ -1, "..." }) == value;
-                auto first_dataset = samples.index({ index_first, mask });
-                auto second_dataset = samples.index({ index_second, mask });
-                auto weights_dataset = weights.index({ mask });
-                auto mi = mutualInformation(first_dataset, second_dataset, weights_dataset);
-                auto pb = margin[value].item<double>();
+                auto mask = samples.index({ "...", -1 }) == value;
+                auto first_dataset = samples.index({ mask, index_first });
+                auto second_dataset = samples.index({ mask, index_second });
+                auto mi = mutualInformation(first_dataset, second_dataset);
+                auto pb = margin[value].item<float>();
                accumulated += pb * mi;
            }
            result.push_back(accumulated);
@@ -99,33 +67,32 @@ namespace bayesnet {
        }
        return matrix;
    }
-    // To use in Python
-    std::vector<float> Metrics::conditionalEdgeWeights(std::vector<float>& weights_)
+    // To Interface with Python
+    vector<float> Metrics::conditionalEdgeWeights()
    {
-        const torch::Tensor weights = torch::tensor(weights_);
-        auto matrix = conditionalEdge(weights);
+        auto matrix = conditionalEdge();
        std::vector<float> v(matrix.data_ptr<float>(), matrix.data_ptr<float>() + matrix.numel());
        return v;
    }
-    double Metrics::entropy(const torch::Tensor& feature, const torch::Tensor& weights)
+    double Metrics::entropy(torch::Tensor& feature)
    {
-        torch::Tensor counts = feature.bincount(weights);
-        double totalWeight = counts.sum().item<double>();
+        torch::Tensor counts = feature.bincount();
+        int totalWeight = counts.sum().item<int>();
        torch::Tensor probs = counts.to(torch::kFloat) / totalWeight;
        torch::Tensor logProbs = torch::log(probs);
        torch::Tensor entropy = -probs * logProbs;
        return entropy.nansum().item<double>();
    }
    // H(Y|X) = sum_{x in X} p(x) H(Y|X=x)
-    double Metrics::conditionalEntropy(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature, const torch::Tensor& weights)
+    double Metrics::conditionalEntropy(torch::Tensor& firstFeature, torch::Tensor& secondFeature)
    {
        int numSamples = firstFeature.sizes()[0];
-        torch::Tensor featureCounts = secondFeature.bincount(weights);
-        std::unordered_map<int, std::unordered_map<int, double>> jointCounts;
+        torch::Tensor featureCounts = secondFeature.bincount();
+        unordered_map<int, unordered_map<int, double>> jointCounts;
        double totalWeight = 0;
        for (auto i = 0; i < numSamples; i++) {
-            jointCounts[secondFeature[i].item<int>()][firstFeature[i].item<int>()] += weights[i].item<double>();
-            totalWeight += weights[i].item<float>();
+            jointCounts[secondFeature[i].item<int>()][firstFeature[i].item<int>()] += 1;
+            totalWeight += 1;
        }
        if (totalWeight == 0)
            return 0;
@@ -146,16 +113,16 @@ namespace bayesnet {
        return entropyValue;
    }
    // I(X;Y) = H(Y) - H(Y|X)
-    double Metrics::mutualInformation(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature, const torch::Tensor& weights)
+    double Metrics::mutualInformation(torch::Tensor& firstFeature, torch::Tensor& secondFeature)
    {
-        return entropy(firstFeature, weights) - conditionalEntropy(firstFeature, secondFeature, weights);
+        return entropy(firstFeature) - conditionalEntropy(firstFeature, secondFeature);
    }
    /*
    Compute the maximum spanning tree considering the weights as distances
    and the indices of the weights as nodes of this square matrix using
    Kruskal algorithm
    */
-    std::vector<std::pair<int, int>> Metrics::maximumSpanningTree(const std::vector<std::string>& features, const torch::Tensor& weights, const int root)
+    vector<pair<int, int>> Metrics::maximumSpanningTree(vector<string> features, Tensor& weights, int root)
    {
        auto mst = MST(features, weights, root);
        return mst.maximumSpanningTree();
--- a/src/BayesNet/BayesMetrics.h
+++ b/src/BayesNet/BayesMetrics.h
@@ -4,46 +4,25 @@
 #include <vector>
 #include <string>
 namespace bayesnet {
+    using namespace std;
+    using namespace torch;
    class Metrics {
    private:
-        int classNumStates = 0;
-        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:
-        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>
-        std::vector<std::pair<T, T>> doCombinations(const std::vector<T>& source)
-        {
-            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) {
-                    result.push_back({ temp, source[j] });
-                }
-            }
-            return result;
-        }
-        template <class T>
-        T pop_first(std::vector<T>& v)
-        {
-            T temp = v[0];
-            v.erase(v.begin());
-            return temp;
-        }
+        Tensor samples;
+        vector<string> features;
+        string className;
+        int classNumStates;
    public:
        Metrics() = default;
-        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);
+        Metrics(Tensor&, vector<string>&, string&, int);
+        Metrics(const vector<vector<int>>&, const vector<int>&, const vector<string>&, const string&, const int);
+        double entropy(Tensor&);
+        double conditionalEntropy(Tensor&, Tensor&);
+        double mutualInformation(Tensor&, Tensor&);
+        vector<float> conditionalEdgeWeights();
+        Tensor conditionalEdge();
+        vector<pair<string, string>> doCombinations(const vector<string>&);
+        vector<pair<int, int>> maximumSpanningTree(vector<string> features, Tensor& weights, int root);
    };
 }
 #endif
--- a/src/BayesNet/BoostAODE.cc
+++ b/src/BayesNet/BoostAODE.cc
@@ -1,210 +0,0 @@
-#include <set>
-#include <functional>
-#include <limits.h>
-#include "BoostAODE.h"
-#include "CFS.h"
-#include "FCBF.h"
-#include "IWSS.h"
-#include "folding.hpp"
-
-namespace bayesnet {
-    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
-        models.clear();
-        n_models = 0;
-        // Prepare the validation dataset
-        auto y_ = dataset.index({ -1, "..." });
-        if (convergence) {
-            // Prepare train & validation sets from train data
-            auto fold = folding::StratifiedKFold(5, y_, 271);
-            dataset_ = torch::clone(dataset);
-            // save input dataset
-            auto [train, test] = fold.getFold(0);
-            auto train_t = torch::tensor(train);
-            auto test_t = torch::tensor(test);
-            // Get train and validation sets
-            X_train = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), train_t });
-            y_train = dataset.index({ -1, train_t });
-            X_test = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), test_t });
-            y_test = dataset.index({ -1, test_t });
-            dataset = X_train;
-            m = X_train.size(1);
-            auto n_classes = states.at(className).size();
-            metrics = Metrics(dataset, features, className, n_classes);
-            // Build dataset with train data
-            buildDataset(y_train);
-        } else {
-            // Use all data to train
-            X_train = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), "..." });
-            y_train = y_;
-        }
-    }
-    void BoostAODE::setHyperparameters(const nlohmann::json& 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"];
-            std::vector<std::string> algos = { "IWSS", "FCBF", "CFS" };
-            selectFeatures = true;
-            algorithm = selectedAlgorithm;
-            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());
-        }
-    }
-    std::unordered_set<int> BoostAODE::initializeModels()
-    {
-        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 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 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) {
-            // std::cout << "Feature: [" << feature << "] " << feature << " " << features.at(feature) << std::endl;
-            featuresUsed.insert(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);
-            n_models++;
-        }
-        notes.push_back("Used features in initialization: " + std::to_string(featuresUsed.size()) + " of " + std::to_string(features.size()) + " with " + algorithm);
-        delete featureSelector;
-        return featuresUsed;
-    }
-    void BoostAODE::trainModel(const torch::Tensor& weights)
-    {
-        std::unordered_set<int> featuresUsed;
-        if (selectFeatures) {
-            featuresUsed = initializeModels();
-        }
-        if (maxModels == 0)
-            maxModels = .1 * n > 10 ? .1 * n : n;
-        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 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
-        // 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
-            std::unique_ptr<Classifier> model;
-            auto feature = featureSelection[0];
-            if (!repeatSparent || featuresUsed.size() < featureSelection.size()) {
-                bool used = true;
-                for (const auto& feat : featureSelection) {
-                    if (std::find(featuresUsed.begin(), featuresUsed.end(), feat) != featuresUsed.end()) {
-                        continue;
-                    }
-                    used = false;
-                    feature = feat;
-                    break;
-                }
-                if (used) {
-                    exitCondition = true;
-                    continue;
-                }
-            }
-            featuresUsed.insert(feature);
-            model = std::make_unique<SPODE>(feature);
-            model->fit(dataset, features, className, states, weights_);
-            auto ypred = model->predict(X_train);
-            // Step 3.1: Compute the classifier amout of say
-            auto mask_wrong = ypred != y_train;
-            auto mask_right = ypred == y_train;
-            auto masked_weights = weights_ * mask_wrong.to(weights_.dtype());
-            double epsilon_t = masked_weights.sum().item<double>();
-            double wt = (1 - epsilon_t) / epsilon_t;
-            double alpha_t = epsilon_t == 0 ? 1 : 0.5 * log(wt);
-            // Step 3.2: Update weights for next classifier
-            // Step 3.2.1: Update weights of wrong samples
-            weights_ += mask_wrong.to(weights_.dtype()) * exp(alpha_t) * weights_;
-            // Step 3.2.2: Update weights of right samples
-            weights_ += mask_right.to(weights_.dtype()) * exp(-alpha_t) * weights_;
-            // Step 3.3: Normalise the weights
-            double totalWeights = torch::sum(weights_).item<double>();
-            weights_ = weights_ / totalWeights;
-            // Step 3.4: Store classifier and its accuracy to weigh its future vote
-            models.push_back(std::move(model));
-            significanceModels.push_back(alpha_t);
-            n_models++;
-            if (convergence) {
-                auto y_val_predict = predict(X_test);
-                double accuracy = (y_val_predict == y_test).sum().item<double>() / (double)y_test.size(0);
-                if (priorAccuracy == 0) {
-                    priorAccuracy = accuracy;
-                } else {
-                    delta = accuracy - priorAccuracy;
-                }
-                if (delta < threshold) {
-                    count++;
-                }
-            }
-            exitCondition = n_models >= maxModels && repeatSparent || epsilon_t > 0.5 || count > tolerance;
-        }
-        if (featuresUsed.size() != features.size()) {
-            notes.push_back("Used features in train: " + std::to_string(featuresUsed.size()) + " of " + std::to_string(features.size()));
-            status = WARNING;
-        }
-        notes.push_back("Number of models: " + std::to_string(n_models));
-    }
-    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
@@ -1,33 +0,0 @@
-#ifndef BOOSTAODE_H
-#define BOOSTAODE_H
-#include "Ensemble.h"
-#include <map>
-#include "SPODE.h"
-#include "FeatureSelect.h"
-namespace bayesnet {
-    class BoostAODE : public Ensemble {
-    public:
-        BoostAODE();
-        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;
-        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
-        std::string algorithm = ""; // Selected feature selection algorithm
-        FeatureSelect* featureSelector = nullptr;
-        double threshold = -1;
-    };
-}
-#endif
--- a/src/BayesNet/CFS.cc
+++ b/src/BayesNet/CFS.cc
@@ -1,72 +0,0 @@
-#include "CFS.h"
-#include <limits>
-#include "bayesnetUtils.h"
-namespace bayesnet {
-    void CFS::fit()
-    {
-        initialize();
-        computeSuLabels();
-        auto featureOrder = argsort(suLabels); // sort descending order
-        auto continueCondition = true;
-        auto feature = featureOrder[0];
-        selectedFeatures.push_back(feature);
-        selectedScores.push_back(suLabels[feature]);
-        selectedFeatures.erase(selectedFeatures.begin());
-        while (continueCondition) {
-            double merit = std::numeric_limits<double>::lowest();
-            int bestFeature = -1;
-            for (auto feature : featureOrder) {
-                selectedFeatures.push_back(feature);
-                // Compute merit with selectedFeatures
-                auto meritNew = computeMeritCFS();
-                if (meritNew > merit) {
-                    merit = meritNew;
-                    bestFeature = feature;
-                }
-                selectedFeatures.pop_back();
-            }
-            if (bestFeature == -1) {
-                // meritNew has to be nan due to constant features
-                break;
-            }
-            selectedFeatures.push_back(bestFeature);
-            selectedScores.push_back(merit);
-            featureOrder.erase(remove(featureOrder.begin(), featureOrder.end(), bestFeature), featureOrder.end());
-            continueCondition = computeContinueCondition(featureOrder);
-        }
-        fitted = true;
-    }
-    bool CFS::computeContinueCondition(const std::vector<int>& featureOrder)
-    {
-        if (selectedFeatures.size() == maxFeatures || featureOrder.size() == 0) {
-            return false;
-        }
-        if (selectedScores.size() >= 5) {
-            /*
-            "To prevent the best first search from exploring the entire
-            feature subset search space, a stopping criterion is imposed.
-            The search will terminate if five consecutive fully expanded
-            subsets show no improvement over the current best subset."
-            as stated in Mark A.Hall Thesis
-            */
-            double item_ant = std::numeric_limits<double>::lowest();
-            int num = 0;
-            std::vector<double> lastFive(selectedScores.end() - 5, selectedScores.end());
-            for (auto item : lastFive) {
-                if (item_ant == std::numeric_limits<double>::lowest()) {
-                    item_ant = item;
-                }
-                if (item > item_ant) {
-                    break;
-                } else {
-                    num++;
-                    item_ant = item;
-                }
-            }
-            if (num == 5) {
-                return false;
-            }
-        }
-        return true;
-    }
-}
--- a/src/BayesNet/CFS.h
+++ b/src/BayesNet/CFS.h
@@ -1,20 +0,0 @@
-#ifndef CFS_H
-#define CFS_H
-#include <torch/torch.h>
-#include <vector>
-#include "FeatureSelect.h"
-namespace bayesnet {
-    class CFS : public FeatureSelect {
-    public:
-        // 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 std::vector<int>& featureOrder);
-    };
-}
-#endif
--- a/src/BayesNet/CMakeLists.txt
+++ b/src/BayesNet/CMakeLists.txt
@@ -1,13 +1,2 @@
-include_directories(
-    ${BayesNet_SOURCE_DIR}/lib/mdlp
-    ${BayesNet_SOURCE_DIR}/lib/Files
-    ${BayesNet_SOURCE_DIR}/lib/folding
-    ${BayesNet_SOURCE_DIR}/lib/json/include
-    ${BayesNet_SOURCE_DIR}/src/BayesNet
-    ${CMAKE_BINARY_DIR}/configured_files/include
-)
-
-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 )
-target_link_libraries(BayesNet mdlp "${TORCH_LIBRARIES}")
+add_library(BayesNet bayesnetUtils.cc Network.cc Node.cc BayesMetrics.cc Classifier.cc KDB.cc TAN.cc SPODE.cc Ensemble.cc AODE.cc Mst.cc)
+target_link_libraries(BayesNet "${TORCH_LIBRARIES}")
--- a/src/BayesNet/Classifier.cc
+++ b/src/BayesNet/Classifier.cc
@@ -2,159 +2,146 @@
 #include "bayesnetUtils.h"

 namespace bayesnet {
-    Classifier::Classifier(Network model) : model(model), m(0), n(0), metrics(Metrics()), fitted(false) {}
-    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)
+    using namespace torch;
+
+    Classifier::Classifier(const Network& model) : model(model), m(0), n(0), metrics(Metrics()), fitted(false) {}
+    Classifier& Classifier::build(vector<string>& features, string className, map<string, vector<int>>& states)
    {
+        dataset = torch::cat({ X, y.view({y.size(0), 1}) }, 1);
        this->features = features;
        this->className = className;
        this->states = states;
-        m = dataset.size(1);
-        n = dataset.size(0) - 1;
        checkFitParameters();
-        auto n_classes = states.at(className).size();
+        auto n_classes = states[className].size();
        metrics = Metrics(dataset, features, className, n_classes);
-        model.initialize();
-        buildModel(weights);
-        trainModel(weights);
+        train();
+        if (Xv == vector<vector<int>>()) {
+            // fit with tensors
+            model.fit(X, y, features, className);
+        } else {
+            // fit with vectors
+            model.fit(Xv, yv, features, className);
+        }
        fitted = true;
        return *this;
    }
-    void Classifier::buildDataset(torch::Tensor& ytmp)
+    Classifier& Classifier::fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states)
    {
-        try {
-            auto yresized = torch::transpose(ytmp.view({ ytmp.size(0), 1 }), 0, 1);
-            dataset = torch::cat({ dataset, yresized }, 0);
-        }
-        catch (const std::exception& e) {
-            std::cerr << e.what() << '\n';
-            std::cout << "X dimensions: " << dataset.sizes() << "\n";
-            std::cout << "y dimensions: " << ytmp.sizes() << "\n";
-            exit(1);
-        }
+        this->X = torch::transpose(X, 0, 1);
+        this->y = y;
+        Xv = vector<vector<int>>();
+        yv = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
+        return build(features, className, states);
    }
-    void Classifier::trainModel(const torch::Tensor& weights)
+
+    Classifier& Classifier::fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states)
    {
-        model.fit(dataset, weights, features, className, states);
-    }
-    // X is nxm where n is the number of features and m the number of samples
-    Classifier& Classifier::fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states)
-    {
-        dataset = X;
-        buildDataset(y);
-        const torch::Tensor weights = torch::full({ dataset.size(1) }, 1.0 / dataset.size(1), torch::kDouble);
-        return build(features, className, states, weights);
-    }
-    // X is nxm where n is the number of features and m the number of samples
-    Classifier& Classifier::fit(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()) }, torch::kInt32);
+        this->X = torch::zeros({ static_cast<int>(X[0].size()), static_cast<int>(X.size()) }, kInt32);
+        Xv = X;
        for (int i = 0; i < X.size(); ++i) {
-            dataset.index_put_({ i, "..." }, torch::tensor(X[i], torch::kInt32));
+            this->X.index_put_({ "...", i }, torch::tensor(X[i], 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 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 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);
+        this->y = torch::tensor(y, kInt32);
+        yv = y;
+        return build(features, className, states);
    }
    void Classifier::checkFitParameters()
    {
-        if (torch::is_floating_point(dataset)) {
-            throw std::invalid_argument("dataset (X, y) must be of type Integer");
+        auto sizes = X.sizes();
+        m = sizes[0];
+        n = sizes[1];
+        if (m != y.size(0)) {
+            throw invalid_argument("X and y must have the same number of samples");
        }
        if (n != features.size()) {
-            throw std::invalid_argument("Classifier: X " + std::to_string(n) + " and features " + std::to_string(features.size()) + " must have the same number of features");
+            throw invalid_argument("X and features must have the same number of features");
        }
        if (states.find(className) == states.end()) {
-            throw std::invalid_argument("className not found in states");
+            throw invalid_argument("className not found in states");
        }
        for (auto feature : features) {
            if (states.find(feature) == states.end()) {
-                throw std::invalid_argument("feature [" + feature + "] not found in states");
+                throw invalid_argument("feature [" + feature + "] not found in states");
            }
        }
    }
-    torch::Tensor Classifier::predict(torch::Tensor& X)
+
+    Tensor Classifier::predict(Tensor& X)
    {
        if (!fitted) {
-            throw std::logic_error("Classifier has not been fitted");
+            throw logic_error("Classifier has not been fitted");
        }
-        return model.predict(X);
+        auto m_ = X.size(0);
+        auto n_ = X.size(1);
+        //auto Xt = torch::transpose(X, 0, 1);
+        vector<vector<int>> Xd(n_, vector<int>(m_, 0));
+        for (auto i = 0; i < n_; i++) {
+            auto temp = X.index({ "...", i });
+            Xd[i] = vector<int>(temp.data_ptr<int>(), temp.data_ptr<int>() + temp.numel());
+        }
+        auto yp = model.predict(Xd);
+        auto ypred = torch::tensor(yp, torch::kInt32);
+        return ypred;
    }
-    std::vector<int> Classifier::predict(std::vector<std::vector<int>>& X)
+    vector<int> Classifier::predict(vector<vector<int>>& X)
    {
        if (!fitted) {
-            throw std::logic_error("Classifier has not been fitted");
+            throw logic_error("Classifier has not been fitted");
        }
        auto m_ = X[0].size();
        auto n_ = X.size();
-        std::vector<std::vector<int>> Xd(n_, std::vector<int>(m_, 0));
+        vector<vector<int>> Xd(n_, vector<int>(m_, 0));
        for (auto i = 0; i < n_; i++) {
-            Xd[i] = std::vector<int>(X[i].begin(), X[i].end());
+            Xd[i] = vector<int>(X[i].begin(), X[i].end());
        }
        auto yp = model.predict(Xd);
        return yp;
    }
-    float Classifier::score(torch::Tensor& X, torch::Tensor& y)
+    float Classifier::score(Tensor& X, Tensor& y)
    {
        if (!fitted) {
-            throw std::logic_error("Classifier has not been fitted");
+            throw logic_error("Classifier has not been fitted");
        }
-        torch::Tensor y_pred = predict(X);
+        auto Xt = torch::transpose(X, 0, 1);
+        Tensor y_pred = predict(Xt);
        return (y_pred == y).sum().item<float>() / y.size(0);
    }
-    float Classifier::score(std::vector<std::vector<int>>& X, std::vector<int>& y)
+    float Classifier::score(vector<vector<int>>& X, vector<int>& y)
    {
        if (!fitted) {
-            throw std::logic_error("Classifier has not been fitted");
+            throw logic_error("Classifier has not been fitted");
        }
-        return model.score(X, y);
+        auto m_ = X[0].size();
+        auto n_ = X.size();
+        vector<vector<int>> Xd(n_, vector<int>(m_, 0));
+        for (auto i = 0; i < n_; i++) {
+            Xd[i] = vector<int>(X[i].begin(), X[i].end());
+        }
+        return model.score(Xd, y);
    }
-    std::vector<std::string> Classifier::show() const
+    vector<string> Classifier::show()
    {
        return model.show();
    }
    void Classifier::addNodes()
    {
        // Add all nodes to the network
-        for (const auto& feature : features) {
-            model.addNode(feature);
+        for (auto feature : features) {
+            model.addNode(feature, states[feature].size());
        }
-        model.addNode(className);
+        model.addNode(className, states[className].size());
    }
-    int Classifier::getNumberOfNodes() const
+    int Classifier::getNumberOfNodes()
    {
        // Features does not include class
-        return fitted ? model.getFeatures().size() : 0;
+        return fitted ? model.getFeatures().size() + 1 : 0;
    }
-    int Classifier::getNumberOfEdges() const
+    int Classifier::getNumberOfEdges()
    {
-        return fitted ? model.getNumEdges() : 0;
+        return fitted ? model.getEdges().size() : 0;
    }
-    int Classifier::getNumberOfStates() const
+    int Classifier::getNumberOfStates()
    {
        return fitted ? model.getStates() : 0;
    }
-    std::vector<std::string> Classifier::topological_order()
-    {
-        return model.topological_sort();
-    }
-    void Classifier::dump_cpt() const
-    {
-        model.dump_cpt();
-    }
-    void Classifier::setHyperparameters(const nlohmann::json& hyperparameters)
-    {
-        //For classifiers that don't have hyperparameters
-    }
 }
--- a/src/BayesNet/Classifier.h
+++ b/src/BayesNet/Classifier.h
@@ -4,48 +4,42 @@
 #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 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
+        Classifier& build(vector<string>& features, string className, map<string, vector<int>>& states);
+    protected:
        Network model;
+        int m, n; // m: number of samples, n: number of features
+        Tensor X;
+        vector<vector<int>> Xv;
+        Tensor y;
+        vector<int> yv;
+        Tensor dataset;
        Metrics metrics;
-        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;
-        std::vector<std::string> notes; // Used to store messages occurred during the fit process
+        vector<string> features;
+        string className;
+        map<string, vector<int>> states;
        void checkFitParameters();
-        virtual void buildModel(const torch::Tensor& weights) = 0;
-        void trainModel(const torch::Tensor& weights) override;
-        void buildDataset(torch::Tensor& y);
+        virtual void train() = 0;
    public:
-        Classifier(Network model);
+        Classifier(const Network& model);
        virtual ~Classifier() = default;
-        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;
+        Classifier& fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        Classifier& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
        void addNodes();
-        int getNumberOfNodes() const override;
-        int getNumberOfEdges() const override;
-        int getNumberOfStates() const override;
-        torch::Tensor predict(torch::Tensor& X) override;
-        status_t getStatus() const override { return status; }
-        std::string getVersion() override { return { project_version.begin(), project_version.end() }; };
-        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;
-        std::vector<std::string> getNotes() const override { return notes; }
-        void dump_cpt() const override;
-        void setHyperparameters(const nlohmann::json& hyperparameters) override; //For classifiers that don't have hyperparameters
+        int getNumberOfNodes() override;
+        int getNumberOfEdges() override;
+        int getNumberOfStates() override;
+        Tensor predict(Tensor& X);
+        vector<int> predict(vector<vector<int>>& X) override;
+        float score(Tensor& X, Tensor& y) override;
+        float score(vector<vector<int>>& X, vector<int>& y) override;
+        vector<string> show() override;
    };
 }
 #endif
--- a/src/BayesNet/Ensemble.cc
+++ b/src/BayesNet/Ensemble.cc
@@ -1,77 +1,92 @@
 #include "Ensemble.h"

 namespace bayesnet {
+    using namespace torch;

-    Ensemble::Ensemble() : Classifier(Network()), n_models(0) {}
-
-    void Ensemble::trainModel(const torch::Tensor& weights)
+    Ensemble::Ensemble() : m(0), n(0), n_models(0), metrics(Metrics()), fitted(false) {}
+    Ensemble& Ensemble::build(vector<string>& features, string className, map<string, vector<int>>& states)
    {
+        dataset = cat({ X, y.view({y.size(0), 1}) }, 1);
+        this->features = features;
+        this->className = className;
+        this->states = states;
+        auto n_classes = states[className].size();
+        metrics = Metrics(dataset, features, className, n_classes);
+        // Build models
+        train();
+        // Train models
        n_models = models.size();
        for (auto i = 0; i < n_models; ++i) {
-            // fit with std::vectors
-            models[i]->fit(dataset, features, className, states);
+            models[i]->fit(Xv, yv, features, className, states);
        }
+        fitted = true;
+        return *this;
    }
-    std::vector<int> Ensemble::voting(torch::Tensor& y_pred)
+    Ensemble& Ensemble::fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states)
+    {
+        this->X = X;
+        this->y = y;
+        Xv = vector<vector<int>>();
+        yv = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
+        return build(features, className, states);
+    }
+    Ensemble& Ensemble::fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states)
+    {
+        this->X = torch::zeros({ static_cast<int>(X[0].size()), static_cast<int>(X.size()) }, kInt32);
+        Xv = X;
+        for (int i = 0; i < X.size(); ++i) {
+            this->X.index_put_({ "...", i }, torch::tensor(X[i], kInt32));
+        }
+        this->y = torch::tensor(y, kInt32);
+        yv = y;
+        return build(features, className, states);
+    }
+    Tensor Ensemble::predict(Tensor& X)
+    {
+        if (!fitted) {
+            throw logic_error("Ensemble has not been fitted");
+        }
+        Tensor y_pred = torch::zeros({ X.size(0), n_models }, kInt32);
+        for (auto i = 0; i < n_models; ++i) {
+            y_pred.index_put_({ "...", i }, models[i]->predict(X));
+        }
+        return torch::tensor(voting(y_pred));
+    }
+    vector<int> Ensemble::voting(Tensor& y_pred)
    {
        auto y_pred_ = y_pred.accessor<int, 2>();
-        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
+        vector<int> y_pred_final;
        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
-            std::vector<double> votes(numClasses, 0.0);
-            for (int j = 0; j < n_models; ++j) {
-                votes[y_pred_[i][j]] += significanceModels.at(j);
+            vector<float> votes(states[className].size(), 0);
+            for (int j = 0; j < y_pred.size(1); ++j) {
+                votes[y_pred_[i][j]] += 1;
            }
-            // argsort in descending order
            auto indices = argsort(votes);
            y_pred_final.push_back(indices[0]);
        }
        return y_pred_final;
    }
-    torch::Tensor Ensemble::predict(torch::Tensor& X)
+    vector<int> Ensemble::predict(vector<vector<int>>& X)
    {
        if (!fitted) {
-            throw std::logic_error("Ensemble has not been fitted");
-        }
-        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(std::thread([&, i]() {
-                auto ypredict = models[i]->predict(X);
-                std::lock_guard<std::mutex> lock(mtx);
-                y_pred.index_put_({ "...", i }, ypredict);
-                }));
-        }
-        for (auto& thread : threads) {
-            thread.join();
-        }
-        return torch::tensor(voting(y_pred));
-    }
-    std::vector<int> Ensemble::predict(std::vector<std::vector<int>>& X)
-    {
-        if (!fitted) {
-            throw std::logic_error("Ensemble has not been fitted");
+            throw logic_error("Ensemble has not been fitted");
        }
        long m_ = X[0].size();
        long n_ = X.size();
-        std::vector<std::vector<int>> Xd(n_, std::vector<int>(m_, 0));
+        vector<vector<int>> Xd(n_, vector<int>(m_, 0));
        for (auto i = 0; i < n_; i++) {
-            Xd[i] = std::vector<int>(X[i].begin(), X[i].end());
+            Xd[i] = vector<int>(X[i].begin(), X[i].end());
        }
-        torch::Tensor y_pred = torch::zeros({ m_, n_models }, torch::kInt32);
+        Tensor y_pred = torch::zeros({ m_, n_models }, kInt32);
        for (auto i = 0; i < n_models; ++i) {
-            y_pred.index_put_({ "...", i }, torch::tensor(models[i]->predict(Xd), torch::kInt32));
+            y_pred.index_put_({ "...", i }, torch::tensor(models[i]->predict(Xd), kInt32));
        }
        return voting(y_pred);
    }
-    float Ensemble::score(torch::Tensor& X, torch::Tensor& y)
+    float Ensemble::score(Tensor& X, Tensor& y)
    {
        if (!fitted) {
-            throw std::logic_error("Ensemble has not been fitted");
+            throw logic_error("Ensemble has not been fitted");
        }
        auto y_pred = predict(X);
        int correct = 0;
@@ -82,10 +97,10 @@ namespace bayesnet {
        }
        return (double)correct / y_pred.size(0);
    }
-    float Ensemble::score(std::vector<std::vector<int>>& X, std::vector<int>& y)
+    float Ensemble::score(vector<vector<int>>& X, vector<int>& y)
    {
        if (!fitted) {
-            throw std::logic_error("Ensemble has not been fitted");
+            throw logic_error("Ensemble has not been fitted");
        }
        auto y_pred = predict(X);
        int correct = 0;
@@ -95,26 +110,27 @@ namespace bayesnet {
            }
        }
        return (double)correct / y_pred.size();
+
    }
-    std::vector<std::string> Ensemble::show() const
+    vector<string> Ensemble::show()
    {
-        auto result = std::vector<std::string>();
+        auto result = vector<string>();
        for (auto i = 0; i < n_models; ++i) {
            auto res = models[i]->show();
            result.insert(result.end(), res.begin(), res.end());
        }
        return result;
    }
-    std::vector<std::string> Ensemble::graph(const std::string& title) const
+    vector<string> Ensemble::graph(string title)
    {
-        auto result = std::vector<std::string>();
+        auto result = vector<string>();
        for (auto i = 0; i < n_models; ++i) {
-            auto res = models[i]->graph(title + "_" + std::to_string(i));
+            auto res = models[i]->graph(title + "_" + to_string(i));
            result.insert(result.end(), res.begin(), res.end());
        }
        return result;
    }
-    int Ensemble::getNumberOfNodes() const
+    int Ensemble::getNumberOfNodes()
    {
        int nodes = 0;
        for (auto i = 0; i < n_models; ++i) {
@@ -122,7 +138,7 @@ namespace bayesnet {
        }
        return nodes;
    }
-    int Ensemble::getNumberOfEdges() const
+    int Ensemble::getNumberOfEdges()
    {
        int edges = 0;
        for (auto i = 0; i < n_models; ++i) {
@@ -130,7 +146,7 @@ namespace bayesnet {
        }
        return edges;
    }
-    int Ensemble::getNumberOfStates() const
+    int Ensemble::getNumberOfStates()
    {
        int nstates = 0;
        for (auto i = 0; i < n_models; ++i) {
--- a/src/BayesNet/Ensemble.h
+++ b/src/BayesNet/Ensemble.h
@@ -4,36 +4,43 @@
 #include "Classifier.h"
 #include "BayesMetrics.h"
 #include "bayesnetUtils.h"
+using namespace std;
+using namespace torch;

 namespace bayesnet {
-    class Ensemble : public Classifier {
+    class Ensemble : public BaseClassifier {
    private:
-        Ensemble& build(std::vector<std::string>& features, std::string className, std::map<std::string, std::vector<int>>& states);
+        bool fitted;
+        long n_models;
+        Ensemble& build(vector<string>& features, string className, map<string, vector<int>>& states);
    protected:
-        unsigned n_models;
-        std::vector<std::unique_ptr<Classifier>> models;
-        std::vector<double> significanceModels;
-        void trainModel(const torch::Tensor& weights) override;
-        std::vector<int> voting(torch::Tensor& y_pred);
+        vector<unique_ptr<Classifier>> models;
+        int m, n; // m: number of samples, n: number of features
+        Tensor X;
+        vector<vector<int>> Xv;
+        Tensor y;
+        vector<int> yv;
+        Tensor dataset;
+        Metrics metrics;
+        vector<string> features;
+        string className;
+        map<string, vector<int>> states;
+        void virtual train() = 0;
+        vector<int> voting(Tensor& y_pred);
    public:
        Ensemble();
        virtual ~Ensemble() = default;
-        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;
-        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 std::vector<std::string>();
-        }
-        void dump_cpt() const override
-        {
-        }
+        Ensemble& fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        Ensemble& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        Tensor predict(Tensor& X);
+        vector<int> predict(vector<vector<int>>& X) override;
+        float score(Tensor& X, Tensor& y) override;
+        float score(vector<vector<int>>& X, vector<int>& y) override;
+        int getNumberOfNodes() override;
+        int getNumberOfEdges() override;
+        int getNumberOfStates() override;
+        vector<string> show() override;
+        vector<string> graph(string title) override;
    };
 }
 #endif
--- a/src/BayesNet/FCBF.cc
+++ b/src/BayesNet/FCBF.cc
@@ -1,44 +0,0 @@
-#include "bayesnetUtils.h"
-#include "FCBF.h"
-namespace bayesnet {
-
-    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) {
-            throw std::invalid_argument("Threshold cannot be less than 1e-7");
-        }
-    }
-    void FCBF::fit()
-    {
-        initialize();
-        computeSuLabels();
-        auto featureOrder = argsort(suLabels); // sort descending order
-        auto featureOrderCopy = featureOrder;
-        for (const auto& feature : featureOrder) {
-            // Don't self compare
-            featureOrderCopy.erase(featureOrderCopy.begin());
-            if (suLabels.at(feature) == 0.0) {
-                // The feature has been removed from the list
-                continue;
-            }
-            if (suLabels.at(feature) < threshold) {
-                break;
-            }
-            // Remove redundant features
-            for (const auto& featureCopy : featureOrderCopy) {
-                double value = computeSuFeatures(feature, featureCopy);
-                if (value >= suLabels.at(featureCopy)) {
-                    // Remove feature from list
-                    suLabels[featureCopy] = 0.0;
-                }
-            }
-            selectedFeatures.push_back(feature);
-            selectedScores.push_back(suLabels[feature]);
-            if (selectedFeatures.size() == maxFeatures) {
-                break;
-            }
-        }
-        fitted = true;
-    }
-}
--- a/src/BayesNet/FCBF.h
+++ b/src/BayesNet/FCBF.h
@@ -1,17 +0,0 @@
-#ifndef FCBF_H
-#define FCBF_H
-#include <torch/torch.h>
-#include <vector>
-#include "FeatureSelect.h"
-namespace bayesnet {
-    class FCBF : public FeatureSelect {
-    public:
-        // 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:
-        double threshold = -1;
-    };
-}
-#endif
--- a/src/BayesNet/FeatureSelect.cc
+++ b/src/BayesNet/FeatureSelect.cc
@@ -1,79 +0,0 @@
-#include "FeatureSelect.h"
-#include <limits>
-#include "bayesnetUtils.h"
-namespace bayesnet {
-    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)
-
-    {
-    }
-    void FeatureSelect::initialize()
-    {
-        selectedFeatures.clear();
-        selectedScores.clear();
-    }
-    double FeatureSelect::symmetricalUncertainty(int a, int b)
-    {
-        /*
-        Compute symmetrical uncertainty. Normalize* information gain (mutual
-        information) with the entropies of the features in order to compensate
-        the bias due to high cardinality features. *Range [0, 1]
-        (https://www.sciencedirect.com/science/article/pii/S0020025519303603)
-        */
-        auto x = samples.index({ a, "..." });
-        auto y = samples.index({ b, "..." });
-        auto mu = mutualInformation(x, y, weights);
-        auto hx = entropy(x, weights);
-        auto hy = entropy(y, weights);
-        return 2.0 * mu / (hx + hy);
-    }
-    void FeatureSelect::computeSuLabels()
-    {
-        // Compute Simmetrical Uncertainty between features and labels
-        // https://en.wikipedia.org/wiki/Symmetric_uncertainty
-        for (int i = 0; i < features.size(); ++i) {
-            suLabels.push_back(symmetricalUncertainty(i, -1));
-        }
-    }
-    double FeatureSelect::computeSuFeatures(const int firstFeature, const int secondFeature)
-    {
-        // Compute Simmetrical Uncertainty between features
-        // https://en.wikipedia.org/wiki/Symmetric_uncertainty
-        try {
-            return suFeatures.at({ firstFeature, secondFeature });
-        }
-        catch (const std::out_of_range& e) {
-            double result = symmetricalUncertainty(firstFeature, secondFeature);
-            suFeatures[{firstFeature, secondFeature}] = result;
-            return result;
-        }
-    }
-    double FeatureSelect::computeMeritCFS()
-    {
-        double result;
-        double rcf = 0;
-        for (auto feature : selectedFeatures) {
-            rcf += suLabels[feature];
-        }
-        double rff = 0;
-        int n = selectedFeatures.size();
-        for (const auto& item : doCombinations(selectedFeatures)) {
-            rff += computeSuFeatures(item.first, item.second);
-        }
-        return rcf / sqrt(n + (n * n - n) * rff);
-    }
-    std::vector<int> FeatureSelect::getFeatures() const
-    {
-        if (!fitted) {
-            throw std::runtime_error("FeatureSelect not fitted");
-        }
-        return selectedFeatures;
-    }
-    std::vector<double> FeatureSelect::getScores() const
-    {
-        if (!fitted) {
-            throw std::runtime_error("FeatureSelect not fitted");
-        }
-        return selectedScores;
-    }
-}
--- a/src/BayesNet/FeatureSelect.h
+++ b/src/BayesNet/FeatureSelect.h
@@ -1,30 +0,0 @@
-#ifndef FEATURE_SELECT_H
-#define FEATURE_SELECT_H
-#include <torch/torch.h>
-#include <vector>
-#include "BayesMetrics.h"
-namespace bayesnet {
-    class FeatureSelect : public Metrics {
-    public:
-        // 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;
-        std::vector<int> getFeatures() const;
-        std::vector<double> getScores() const;
-    protected:
-        void initialize();
-        void computeSuLabels();
-        double computeSuFeatures(const int a, const int b);
-        double symmetricalUncertainty(int a, int b);
-        double computeMeritCFS();
-        const torch::Tensor& weights;
-        int maxFeatures;
-        std::vector<int> selectedFeatures;
-        std::vector<double> selectedScores;
-        std::vector<double> suLabels;
-        std::map<std::pair<int, int>, double> suFeatures;
-        bool fitted = false;
-    };
-}
-#endif
--- a/src/BayesNet/IWSS.cc
+++ b/src/BayesNet/IWSS.cc
@@ -1,47 +0,0 @@
-#include "IWSS.h"
-#include <limits>
-#include "bayesnetUtils.h"
-namespace bayesnet {
-    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) {
-            throw std::invalid_argument("Threshold has to be in [0, 0.5]");
-        }
-    }
-    void IWSS::fit()
-    {
-        initialize();
-        computeSuLabels();
-        auto featureOrder = argsort(suLabels); // sort descending order
-        auto featureOrderCopy = featureOrder;
-        // Add first and second features to result
-        //     First with its own score
-        auto first_feature = pop_first(featureOrderCopy);
-        selectedFeatures.push_back(first_feature);
-        selectedScores.push_back(suLabels.at(first_feature));
-        //     Second with the score of the candidates
-        selectedFeatures.push_back(pop_first(featureOrderCopy));
-        auto merit = computeMeritCFS();
-        selectedScores.push_back(merit);
-        for (const auto feature : featureOrderCopy) {
-            selectedFeatures.push_back(feature);
-            // Compute merit with selectedFeatures
-            auto meritNew = computeMeritCFS();
-            double delta = merit != 0.0 ? abs(merit - meritNew) / merit : 0.0;
-            if (meritNew > merit || delta < threshold) {
-                if (meritNew > merit) {
-                    merit = meritNew;
-                }
-                selectedScores.push_back(meritNew);
-            } else {
-                selectedFeatures.pop_back();
-                break;
-            }
-            if (selectedFeatures.size() == maxFeatures) {
-                break;
-            }
-        }
-        fitted = true;
-    }
-}
--- a/src/BayesNet/IWSS.h
+++ b/src/BayesNet/IWSS.h
@@ -1,17 +0,0 @@
-#ifndef IWSS_H
-#define IWSS_H
-#include <torch/torch.h>
-#include <vector>
-#include "FeatureSelect.h"
-namespace bayesnet {
-    class IWSS : public FeatureSelect {
-    public:
-        // 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:
-        double threshold = -1;
-    };
-}
-#endif
--- a/src/BayesNet/KDB.cc
+++ b/src/BayesNet/KDB.cc
@@ -1,21 +1,10 @@
 #include "KDB.h"

 namespace bayesnet {
-    KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta)
-    {
-        validHyperparameters = { "k", "theta" };
+    using namespace torch;

-    }
-    void KDB::setHyperparameters(const nlohmann::json& hyperparameters)
-    {
-        if (hyperparameters.contains("k")) {
-            k = hyperparameters["k"];
-        }
-        if (hyperparameters.contains("theta")) {
-            theta = hyperparameters["theta"];
-        }
-    }
-    void KDB::buildModel(const torch::Tensor& weights)
+    KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta) {}
+    void KDB::train()
    {
        /*
        1. For each feature Xi, compute mutual information, I(X;C),
@@ -38,25 +27,25 @@ namespace bayesnet {
        */
        // 1. For each feature Xi, compute mutual information, I(X;C),
        // where C is the class.
-        addNodes();
-        const torch::Tensor& y = dataset.index({ -1, "..." });
-        std::vector<double> mi;
+        vector <float> mi;
        for (auto i = 0; i < features.size(); i++) {
-            torch::Tensor firstFeature = dataset.index({ i, "..." });
-            mi.push_back(metrics.mutualInformation(firstFeature, y, weights));
+            Tensor firstFeature = X.index({ "...", i });
+            mi.push_back(metrics.mutualInformation(firstFeature, y));
        }
        // 2. Compute class conditional mutual information I(Xi;XjIC), f or each
-        auto conditionalEdgeWeights = metrics.conditionalEdge(weights);
+        auto conditionalEdgeWeights = metrics.conditionalEdge();
        // 3. Let the used variable list, S, be empty.
-        std::vector<int> S;
+        vector<int> S;
        // 4. Let the DAG network being constructed, BN, begin with a single
        // class node, C.
+        model.addNode(className, states[className].size());
        // 5. Repeat until S includes all domain features
        // 5.1. Select feature Xmax which is not in S and has the largest value
        // I(Xmax;C).
        auto order = argsort(mi);
        for (auto idx : order) {
            // 5.2. Add a node to BN representing Xmax.
+            model.addNode(features[idx], states[features[idx]].size());
            // 5.3. Add an arc from C to Xmax in BN.
            model.addEdge(className, features[idx]);
            // 5.4. Add m = min(lSl,/c) arcs from m distinct features Xj in S with
@@ -66,9 +55,9 @@ namespace bayesnet {
            S.push_back(idx);
        }
    }
-    void KDB::add_m_edges(int idx, std::vector<int>& S, torch::Tensor& weights)
+    void KDB::add_m_edges(int idx, vector<int>& S, Tensor& weights)
    {
-        auto n_edges = std::min(k, static_cast<int>(S.size()));
+        auto n_edges = min(k, static_cast<int>(S.size()));
        auto cond_w = clone(weights);
        bool exit_cond = k == 0;
        int num = 0;
@@ -80,7 +69,7 @@ namespace bayesnet {
                    model.addEdge(features[max_minfo], features[idx]);
                    num++;
                }
-                catch (const std::invalid_argument& e) {
+                catch (const invalid_argument& e) {
                    // Loops are not allowed
                }
            }
@@ -90,12 +79,11 @@ namespace bayesnet {
            exit_cond = num == n_edges || candidates.size(0) == 0;
        }
    }
-    std::vector<std::string> KDB::graph(const std::string& title) const
+    vector<string> KDB::graph(string title)
    {
-        std::string header{ title };
        if (title == "KDB") {
-            header += " (k=" + std::to_string(k) + ", theta=" + std::to_string(theta) + ")";
+            title += " (k=" + to_string(k) + ", theta=" + to_string(theta) + ")";
        }
-        return model.graph(header);
+        return model.graph(title);
    }
 }
--- a/src/BayesNet/KDB.h
+++ b/src/BayesNet/KDB.h
@@ -1,21 +1,20 @@
 #ifndef KDB_H
 #define KDB_H
-#include <torch/torch.h>
 #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, std::vector<int>& S, torch::Tensor& weights);
+        void add_m_edges(int idx, vector<int>& S, Tensor& weights);
    protected:
-        void buildModel(const torch::Tensor& weights) override;
+        void train() override;
    public:
        explicit KDB(int k, float theta = 0.03);
-        virtual ~KDB() = default;
-        void setHyperparameters(const nlohmann::json& hyperparameters) override;
-        std::vector<std::string> graph(const std::string& name = "KDB") const override;
+        vector<string> graph(string name = "KDB") override;
    };
 }
 #endif
--- a/src/BayesNet/KDBLd.cc
+++ b/src/BayesNet/KDBLd.cc
@@ -1,29 +0,0 @@
-#include "KDBLd.h"
-
-namespace bayesnet {
-    KDBLd::KDBLd(int k) : KDB(k), Proposal(dataset, features, className) {}
-    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 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
-        KDB::fit(dataset, features, className, states);
-        states = localDiscretizationProposal(states, model);
-        return *this;
-    }
-    torch::Tensor KDBLd::predict(torch::Tensor& X)
-    {
-        auto Xt = prepareX(X);
-        return KDB::predict(Xt);
-    }
-    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
@@ -1,18 +0,0 @@
-#ifndef KDBLD_H
-#define KDBLD_H
-#include "KDB.h"
-#include "Proposal.h"
-
-namespace bayesnet {
-    class KDBLd : public KDB, public Proposal {
-    private:
-    public:
-        explicit KDBLd(int k);
-        virtual ~KDBLd() = default;
-        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
@@ -1,13 +1,13 @@
 #include "Mst.h"
 #include <vector>
-#include <list>
 /*
    Based on the code from https://www.softwaretestinghelp.com/minimum-spanning-tree-tutorial/

 */

 namespace bayesnet {
-    Graph::Graph(int V) : V(V), parent(std::vector<int>(V))
+    using namespace std;
+    Graph::Graph(int V) : V(V), parent{ vector<int>(V) }
    {
        for (int i = 0; i < V; i++)
            parent[i] = i;
@@ -33,46 +33,38 @@ namespace bayesnet {
    }
    void Graph::kruskal_algorithm()
    {
+        int i;
        // sort the edges ordered on decreasing weight
-        stable_sort(G.begin(), G.end(), [](const auto& left, const auto& right) {return left.first > right.first;});
-        for (int i = 0; i < G.size(); i++) {
+        sort(G.begin(), G.end(), [](const auto& left, const auto& right) {return left.first > right.first;});
+        for (i = 0; i < G.size(); i++) {
            int uSt, vEd;
            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 std::vector
+                T.push_back(G[i]); // add to mst vector
                union_set(uSt, vEd);
            }
        }
    }
    void Graph::display_mst()
    {
-        std::cout << "Edge :" << " Weight" << std::endl;
+        cout << "Edge :" << " Weight" << endl;
        for (int i = 0; i < T.size(); i++) {
-            std::cout << T[i].second.first << " - " << T[i].second.second << " : "
+            cout << T[i].second.first << " - " << T[i].second.second << " : "
                << T[i].first;
-            std::cout << std::endl;
+            cout << endl;
        }
    }

-    void insertElement(std::list<int>& variables, int variable)
+    vector<pair<int, int>> reorder(vector<pair<float, pair<int, int>>> T, int root_original)
    {
-        if (std::find(variables.begin(), variables.end(), variable) == variables.end()) {
-            variables.push_front(variable);
-        }
-    }
-
-    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 = std::vector<std::pair<int, int>>();
-        auto visited = std::vector<int>();
-        auto nextVariables = std::list<int>();
-        nextVariables.push_front(root_original);
+        auto result = vector<pair<int, int>>();
+        auto visited = vector<int>();
+        auto nextVariables = unordered_set<int>();
+        nextVariables.emplace(root_original);
        while (nextVariables.size() > 0) {
-            int root = nextVariables.front();
-            nextVariables.pop_front();
+            int root = *nextVariables.begin();
+            nextVariables.erase(nextVariables.begin());
            for (int i = 0; i < T.size(); ++i) {
                auto [weight, edge] = T[i];
                auto [from, to] = edge;
@@ -80,10 +72,10 @@ namespace bayesnet {
                    visited.insert(visited.begin(), i);
                    if (from == root) {
                        result.push_back({ from, to });
-                        insertElement(nextVariables, to);
+                        nextVariables.emplace(to);
                    } else {
                        result.push_back({ to, from });
-                        insertElement(nextVariables, from);
+                        nextVariables.emplace(from);
                    }
                }
            }
@@ -103,11 +95,12 @@ namespace bayesnet {
        return result;
    }

-    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()
+    MST::MST(vector<string>& features, Tensor& weights, int root) : features(features), weights(weights), root(root) {}
+    vector<pair<int, int>> MST::maximumSpanningTree()
    {
        auto num_features = features.size();
        Graph g(num_features);
+
        // Make a complete graph
        for (int i = 0; i < num_features - 1; ++i) {
            for (int j = i + 1; j < num_features; ++j) {
--- a/src/BayesNet/Mst.h
+++ b/src/BayesNet/Mst.h
@@ -4,22 +4,23 @@
 #include <vector>
 #include <string>
 namespace bayesnet {
+    using namespace std;
+    using namespace torch;
    class MST {
    private:
-        torch::Tensor weights;
-        std::vector<std::string> features;
-        int root = 0;
+        Tensor weights;
+        vector<string> features;
+        int root;
    public:
-        MST() = default;
-        MST(const std::vector<std::string>& features, const torch::Tensor& weights, const int root);
-        std::vector<std::pair<int, int>> maximumSpanningTree();
+        MST(vector<string>& features, Tensor& weights, int root);
+        vector<pair<int, int>> maximumSpanningTree();
    };
    class Graph {
    private:
        int V;      // number of nodes in graph
-        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;
+        vector <pair<float, pair<int, int>>> G; // vector for graph
+        vector <pair<float, pair<int, int>>> T; // vector for mst
+        vector<int> parent;
    public:
        explicit Graph(int V);
        void addEdge(int u, int v, float wt);
@@ -27,7 +28,7 @@ namespace bayesnet {
        void union_set(int u, int v);
        void kruskal_algorithm();
        void display_mst();
-        std::vector <std::pair<float, std::pair<int, int>>> get_mst() { return T; }
+        vector <pair<float, pair<int, int>>> get_mst() { return T; }
    };
 }
 #endif
--- a/src/BayesNet/Network.cc
+++ b/src/BayesNet/Network.cc
@@ -3,24 +3,15 @@
 #include "Network.h"
 #include "bayesnetUtils.h"
 namespace bayesnet {
-    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)
+    Network::Network() : laplaceSmoothing(1), features(vector<string>()), className(""), classNumStates(0), maxThreads(0.8), fitted(false) {}
+    Network::Network(const float maxT) : laplaceSmoothing(1), features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
+    Network::Network(const float maxT, const int smoothing) : laplaceSmoothing(smoothing), features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
+    Network::Network(const Network& other) : laplaceSmoothing(other.laplaceSmoothing), features(other.features), className(other.className), classNumStates(other.classNumStates), maxThreads(other.maxThreads), fitted(other.fitted)
    {
-        for (const auto& node : other.nodes) {
-            nodes[node.first] = std::make_unique<Node>(*node.second);
+        for (const auto& pair : other.nodes) {
+            nodes[pair.first] = std::make_unique<Node>(*pair.second);
        }
    }
-    void Network::initialize()
-    {
-        features = std::vector<std::string>();
-        className = "";
-        classNumStates = 0;
-        fitted = false;
-        nodes.clear();
-        samples = torch::Tensor();
-    }
    float Network::getmaxThreads()
    {
        return maxThreads;
@@ -29,28 +20,28 @@ namespace bayesnet {
    {
        return samples;
    }
-    void Network::addNode(const std::string& name)
+    void Network::addNode(const string& name, const int numStates)
    {
-        if (name == "") {
-            throw std::invalid_argument("Node name cannot be empty");
-        }
-        if (nodes.find(name) != nodes.end()) {
-            return;
-        }
        if (find(features.begin(), features.end(), name) == features.end()) {
            features.push_back(name);
        }
-        nodes[name] = std::make_unique<Node>(name);
+        if (nodes.find(name) != nodes.end()) {
+            // if node exists update its number of states and remove parents, children and CPT
+            nodes[name]->clear();
+            nodes[name]->setNumStates(numStates);
+            return;
+        }
+        nodes[name] = std::make_unique<Node>(name, numStates);
    }
-    std::vector<std::string> Network::getFeatures() const
+    vector<string> Network::getFeatures()
    {
        return features;
    }
-    int Network::getClassNumStates() const
+    const int Network::getClassNumStates()
    {
        return classNumStates;
    }
-    int Network::getStates() const
+    const int Network::getStates()
    {
        int result = 0;
        for (auto& node : nodes) {
@@ -58,11 +49,11 @@ namespace bayesnet {
        }
        return result;
    }
-    std::string Network::getClassName() const
+    const string Network::getClassName()
    {
        return className;
    }
-    bool Network::isCyclic(const std::string& nodeId, std::unordered_set<std::string>& visited, std::unordered_set<std::string>& recStack)
+    bool Network::isCyclic(const string& nodeId, unordered_set<string>& visited, unordered_set<string>& recStack)
    {
        if (visited.find(nodeId) == visited.end()) // if node hasn't been visited yet
        {
@@ -78,158 +69,124 @@ namespace bayesnet {
        recStack.erase(nodeId); // remove node from recursion stack before function ends
        return false;
    }
-    void Network::addEdge(const std::string& parent, const std::string& child)
+    void Network::addEdge(const string& parent, const string& child)
    {
        if (nodes.find(parent) == nodes.end()) {
-            throw std::invalid_argument("Parent node " + parent + " does not exist");
+            throw invalid_argument("Parent node " + parent + " does not exist");
        }
        if (nodes.find(child) == nodes.end()) {
-            throw std::invalid_argument("Child node " + child + " does not exist");
+            throw 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());
-        std::unordered_set<std::string> visited;
-        std::unordered_set<std::string> recStack;
+        unordered_set<string> visited;
+        unordered_set<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 std::invalid_argument("Adding this edge forms a cycle in the graph.");
+            throw invalid_argument("Adding this edge forms a cycle in the graph.");
        }
    }
-    std::map<std::string, std::unique_ptr<Node>>& Network::getNodes()
+    map<string, std::unique_ptr<Node>>& Network::getNodes()
    {
        return nodes;
    }
-    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)
+    void Network::fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& featureNames, const string& className)
    {
-        if (weights.size(0) != n_samples) {
-            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 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 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 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 std::invalid_argument("className not found in Network::features");
-        }
-        for (auto& feature : featureNames) {
-            if (find(features.begin(), features.end(), feature) == features.end()) {
-                throw std::invalid_argument("Feature " + feature + " not found in Network::features");
-            }
-            if (states.find(feature) == states.end()) {
-                throw std::invalid_argument("Feature " + feature + " not found in 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 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 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);
+        features = featureNames;
        this->className = className;
-        torch::Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1);
-        samples = torch::cat({ X , ytmp }, 0);
+        dataset.clear();
+        // Specific part
+        classNumStates = torch::max(y).item<int>() + 1;
+        samples = torch::cat({ X, y.view({ y.size(0), 1 }) }, 1);
        for (int i = 0; i < featureNames.size(); ++i) {
-            auto row_feature = X.index({ i, "..." });
+            auto column = torch::flatten(X.index({ "...", i }));
+            auto k = vector<int>();
+            for (auto z = 0; z < X.size(0); ++z) {
+                k.push_back(column[z].item<int>());
+            }
+            dataset[featureNames[i]] = k;
        }
-        completeFit(states, weights);
+        dataset[className] = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
+        completeFit();
    }
-    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)
+    void Network::fit(const vector<vector<int>>& input_data, const vector<int>& labels, const vector<string>& featureNames, const string& className)
    {
-        checkFitData(samples.size(1), samples.size(0) - 1, samples.size(1), featureNames, className, states, weights);
+        features = featureNames;
        this->className = className;
-        this->samples = samples;
-        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 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);
-        this->className = className;
-        // Build tensor of samples (nxm) (n+1 because of the class)
-        samples = torch::zeros({ static_cast<int>(input_data.size() + 1), static_cast<int>(input_data[0].size()) }, torch::kInt32);
+        dataset.clear();
+        // Specific part
+        classNumStates = *max_element(labels.begin(), labels.end()) + 1;
+        // Build dataset & tensor of samples
+        samples = torch::zeros({ static_cast<int>(input_data[0].size()), static_cast<int>(input_data.size() + 1) }, torch::kInt32);
        for (int i = 0; i < featureNames.size(); ++i) {
-            samples.index_put_({ i, "..." }, torch::tensor(input_data[i], torch::kInt32));
+            dataset[featureNames[i]] = input_data[i];
+            samples.index_put_({ "...", i }, torch::tensor(input_data[i], torch::kInt32));
        }
-        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
-        completeFit(states, weights);
+        dataset[className] = labels;
+        samples.index_put_({ "...", -1 }, torch::tensor(labels, torch::kInt32));
+        completeFit();
    }
-    void Network::completeFit(const std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights)
+    void Network::completeFit()
    {
-        setStates(states);
-        laplaceSmoothing = 1.0 / samples.size(1); // To use in CPT computation
-        std::vector<std::thread> threads;
-        for (auto& node : nodes) {
-            threads.emplace_back([this, &node, &weights]() {
-                node.second->computeCPT(samples, features, laplaceSmoothing, weights);
+
+        int maxThreadsRunning = static_cast<int>(std::thread::hardware_concurrency() * maxThreads);
+        if (maxThreadsRunning < 1) {
+            maxThreadsRunning = 1;
+        }
+        vector<thread> threads;
+        mutex mtx;
+        condition_variable cv;
+        int activeThreads = 0;
+        int nextNodeIndex = 0;
+        while (nextNodeIndex < nodes.size()) {
+            unique_lock<mutex> lock(mtx);
+            cv.wait(lock, [&activeThreads, &maxThreadsRunning]() { return activeThreads < maxThreadsRunning; });
+            if (nextNodeIndex >= nodes.size()) {
+                break;  // No more work remaining
+            }
+            threads.emplace_back([this, &nextNodeIndex, &mtx, &cv, &activeThreads]() {
+                while (true) {
+                    unique_lock<mutex> lock(mtx);
+                    if (nextNodeIndex >= nodes.size()) {
+                        break;  // No more work remaining
+                    }
+                    auto& pair = *std::next(nodes.begin(), nextNodeIndex);
+                    ++nextNodeIndex;
+                    lock.unlock();
+                    pair.second->computeCPT(dataset, laplaceSmoothing);
+                    lock.lock();
+                    nodes[pair.first] = std::move(pair.second);
+                    lock.unlock();
+                }
+                lock_guard<mutex> lock(mtx);
+                --activeThreads;
+                cv.notify_one();
                });
+            ++activeThreads;
        }
        for (auto& thread : threads) {
            thread.join();
        }
        fitted = true;
    }
-    torch::Tensor Network::predict_tensor(const torch::Tensor& samples, const bool proba)
+
+    vector<int> Network::predict(const vector<vector<int>>& tsamples)
    {
        if (!fitted) {
-            throw std::logic_error("You must call fit() before calling predict()");
+            throw logic_error("You must call fit() before calling predict()");
        }
-        torch::Tensor result;
-        result = torch::zeros({ samples.size(1), classNumStates }, torch::kFloat64);
-        for (int i = 0; i < samples.size(1); ++i) {
-            const 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));
-            result.index_put_({ i, "..." }, temp);
-        }
-        if (proba)
-            return result;
-        return result.argmax(1);
-    }
-    // Return mxn tensor of probabilities
-    torch::Tensor Network::predict_proba(const torch::Tensor& samples)
-    {
-        return predict_tensor(samples, true);
-    }
-
-    // Return mxn tensor of probabilities
-    torch::Tensor Network::predict(const torch::Tensor& samples)
-    {
-        return predict_tensor(samples, false);
-    }
-
-    // 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 std::logic_error("You must call fit() before calling predict()");
-        }
-        std::vector<int> predictions;
-        std::vector<int> sample;
+        vector<int> predictions;
+        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]);
            }
-            std::vector<double> classProbabilities = predict_sample(sample);
+            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 +194,13 @@ namespace bayesnet {
        }
        return predictions;
    }
-    // Return mxn std::vector of probabilities
-    std::vector<std::vector<double>> Network::predict_proba(const std::vector<std::vector<int>>& tsamples)
+    vector<vector<double>> Network::predict_proba(const vector<vector<int>>& tsamples)
    {
        if (!fitted) {
-            throw std::logic_error("You must call fit() before calling predict_proba()");
+            throw logic_error("You must call fit() before calling predict_proba()");
        }
-        std::vector<std::vector<double>> predictions;
-        std::vector<int> sample;
+        vector<vector<double>> predictions;
+        vector<int> sample;
        for (int row = 0; row < tsamples[0].size(); ++row) {
            sample.clear();
            for (int col = 0; col < tsamples.size(); ++col) {
@@ -254,9 +210,9 @@ namespace bayesnet {
        }
        return predictions;
    }
-    double Network::score(const std::vector<std::vector<int>>& tsamples, const std::vector<int>& labels)
+    double Network::score(const vector<vector<int>>& tsamples, const vector<int>& labels)
    {
-        std::vector<int> y_pred = predict(tsamples);
+        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 +221,20 @@ namespace bayesnet {
        }
        return (double)correct / y_pred.size();
    }
-    // Return 1xn std::vector of probabilities
-    std::vector<double> Network::predict_sample(const std::vector<int>& sample)
+    vector<double> Network::predict_sample(const vector<int>& sample)
    {
        // Ensure the sample size is equal to the number of features
-        if (sample.size() != features.size() - 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) + ")");
+        if (sample.size() != features.size()) {
+            throw invalid_argument("Sample size (" + to_string(sample.size()) +
+                ") does not match the number of features (" + to_string(features.size()) + ")");
        }
-        std::map<std::string, int> evidence;
+        map<string, int> evidence;
        for (int i = 0; i < sample.size(); ++i) {
            evidence[features[i]] = sample[i];
        }
        return exactInference(evidence);
    }
-    // 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 std::invalid_argument("Sample size (" + std::to_string(sample.size(0)) +
-                ") does not match the number of features (" + std::to_string(features.size() - 1) + ")");
-        }
-        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(std::map<std::string, int>& completeEvidence)
+    double Network::computeFactor(map<string, int>& completeEvidence)
    {
        double result = 1.0;
        for (auto& node : getNodes()) {
@@ -301,34 +242,35 @@ namespace bayesnet {
        }
        return result;
    }
-    std::vector<double> Network::exactInference(std::map<std::string, int>& evidence)
+    vector<double> Network::exactInference(map<string, int>& evidence)
    {
-        std::vector<double> result(classNumStates, 0.0);
-        std::vector<std::thread> threads;
-        std::mutex mtx;
+        vector<double> result(classNumStates, 0.0);
+        vector<thread> threads;
+        mutex mtx;
        for (int i = 0; i < classNumStates; ++i) {
            threads.emplace_back([this, &result, &evidence, i, &mtx]() {
-                auto completeEvidence = std::map<std::string, int>(evidence);
+                auto completeEvidence = map<string, int>(evidence);
                completeEvidence[getClassName()] = i;
                double factor = computeFactor(completeEvidence);
-                std::lock_guard<std::mutex> lock(mtx);
+                lock_guard<mutex> lock(mtx);
                result[i] = factor;
                });
        }
        for (auto& thread : threads) {
            thread.join();
        }
+
        // Normalize result
        double sum = accumulate(result.begin(), result.end(), 0.0);
-        transform(result.begin(), result.end(), result.begin(), [sum](const double& value) { return value / sum; });
+        transform(result.begin(), result.end(), result.begin(), [sum](double x) { return x / sum; });
        return result;
    }
-    std::vector<std::string> Network::show() const
+    vector<string> Network::show()
    {
-        std::vector<std::string> result;
+        vector<string> result;
        // Draw the network
        for (auto& node : nodes) {
-            std::string line = node.first + " -> ";
+            string line = node.first + " -> ";
            for (auto child : node.second->getChildren()) {
                line += child->getName() + ", ";
            }
@@ -336,12 +278,12 @@ namespace bayesnet {
        }
        return result;
    }
-    std::vector<std::string> Network::graph(const std::string& title) const
+    vector<string> Network::graph(const string& title)
    {
-        auto output = std::vector<std::string>();
+        auto output = vector<string>();
        auto prefix = "digraph BayesNet {\nlabel=<BayesNet ";
        auto suffix = ">\nfontsize=30\nfontcolor=blue\nlabelloc=t\nlayout=circo\n";
-        std::string header = prefix + title + suffix;
+        string header = prefix + title + suffix;
        output.push_back(header);
        for (auto& node : nodes) {
            auto result = node.second->graph(className);
@@ -350,9 +292,9 @@ namespace bayesnet {
        output.push_back("}\n");
        return output;
    }
-    std::vector<std::pair<std::string, std::string>> Network::getEdges() const
+    vector<pair<string, string>> Network::getEdges()
    {
-        auto edges = std::vector<std::pair<std::string, std::string>>();
+        auto edges = vector<pair<string, string>>();
        for (const auto& node : nodes) {
            auto head = node.first;
            for (const auto& child : node.second->getChildren()) {
@@ -362,52 +304,4 @@ namespace bayesnet {
        }
        return edges;
    }
-    int Network::getNumEdges() const
-    {
-        return getEdges().size();
-    }
-    std::vector<std::string> Network::topological_sort()
-    {
-        /* Check if al the fathers of every node are before the node */
-        auto result = features;
-        result.erase(remove(result.begin(), result.end(), className), result.end());
-        bool ending{ false };
-        while (!ending) {
-            ending = true;
-            for (auto feature : features) {
-                auto fathers = nodes[feature]->getParents();
-                for (const auto& father : fathers) {
-                    auto fatherName = father->getName();
-                    if (fatherName == className) {
-                        continue;
-                    }
-                    // Check if father is placed before the actual feature
-                    auto it = find(result.begin(), result.end(), fatherName);
-                    if (it != result.end()) {
-                        auto it2 = find(result.begin(), result.end(), feature);
-                        if (it2 != result.end()) {
-                            if (distance(it, it2) < 0) {
-                                // if it is not, insert it before the feature
-                                result.erase(remove(result.begin(), result.end(), fatherName), result.end());
-                                result.insert(it2, fatherName);
-                                ending = false;
-                            }
-                        } else {
-                            throw std::logic_error("Error in topological sort because of node " + feature + " is not in result");
-                        }
-                    } else {
-                        throw std::logic_error("Error in topological sort because of node father " + fatherName + " is not in result");
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    void Network::dump_cpt() const
-    {
-        for (auto& node : nodes) {
-            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
@@ -3,61 +3,53 @@
 #include "Node.h"
 #include <map>
 #include <vector>
-#include "config.h"

 namespace bayesnet {
    class Network {
    private:
-        std::map<std::string, std::unique_ptr<Node>> nodes;
+        map<string, unique_ptr<Node>> nodes;
+        map<string, vector<int>> dataset;
        bool fitted;
-        float maxThreads = 0.95;
+        float maxThreads;
        int classNumStates;
-        std::vector<std::string> features; // Including classname
-        std::string className;
-        double laplaceSmoothing;
-        torch::Tensor samples; // nxm tensor used to fit the model
+        vector<string> features;
+        string className;
+        int laplaceSmoothing;
+        torch::Tensor samples;
        bool isCyclic(const std::string&, std::unordered_set<std::string>&, std::unordered_set<std::string>&);
-        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>>&);
+        vector<double> predict_sample(const vector<int>&);
+        vector<double> exactInference(map<string, int>&);
+        double computeFactor(map<string, int>&);
+        double mutual_info(torch::Tensor&, torch::Tensor&);
+        double entropy(torch::Tensor&);
+        double conditionalEntropy(torch::Tensor&, torch::Tensor&);
+        double mutualInformation(torch::Tensor&, torch::Tensor&);
+        void completeFit();
    public:
        Network();
-        explicit Network(float);
-        explicit Network(Network&);
-        ~Network() = default;
+        explicit Network(const float, const int);
+        explicit Network(const float);
+        explicit Network(const Network&);
        torch::Tensor& getSamples();
        float getmaxThreads();
-        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;
-        std::vector<std::pair<std::string, std::string>> getEdges() const;
-        int getNumEdges() const;
-        int getClassNumStates() 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 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);
-        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 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 std::string version() { return  { project_version.begin(), project_version.end() }; }
+        void addNode(const string&, const int);
+        void addEdge(const string&, const string&);
+        map<string, std::unique_ptr<Node>>& getNodes();
+        vector<string> getFeatures();
+        const int getStates();
+        vector<pair<string, string>> getEdges();
+        const int getClassNumStates();
+        const string getClassName();
+        void fit(const vector<vector<int>>&, const vector<int>&, const vector<string>&, const string&);
+        void fit(torch::Tensor&, torch::Tensor&, const vector<string>&, const string&);
+        vector<int> predict(const vector<vector<int>>&);
+        //Computes the conditional edge weight of variable index u and v conditioned on class_node
+        torch::Tensor conditionalEdgeWeight();
+        vector<vector<double>> predict_proba(const vector<vector<int>>&);
+        double score(const vector<vector<int>>&, const vector<int>&);
+        vector<string> show();
+        vector<string> graph(const string& title); // Returns a vector of strings representing the graph in graphviz format
+        inline string version() { return "0.1.0"; }
    };
 }
 #endif
--- a/src/BayesNet/Node.cc
+++ b/src/BayesNet/Node.cc
@@ -2,8 +2,8 @@

 namespace bayesnet {

-    Node::Node(const std::string& name)
-        : name(name), numStates(0), cpTable(torch::Tensor()), parents(std::vector<Node*>()), children(std::vector<Node*>())
+    Node::Node(const std::string& name, int numStates)
+        : name(name), numStates(numStates), cpTable(torch::Tensor()), parents(vector<Node*>()), children(vector<Node*>())
    {
    }
    void Node::clear()
@@ -14,7 +14,7 @@ namespace bayesnet {
        dimensions.clear();
        numStates = 0;
    }
-    std::string Node::getName() const
+    string Node::getName() const
    {
        return name;
    }
@@ -34,11 +34,11 @@ namespace bayesnet {
    {
        children.push_back(child);
    }
-    std::vector<Node*>& Node::getParents()
+    vector<Node*>& Node::getParents()
    {
        return parents;
    }
-    std::vector<Node*>& Node::getChildren()
+    vector<Node*>& Node::getChildren()
    {
        return children;
    }
@@ -63,73 +63,59 @@ namespace bayesnet {
    */
    unsigned Node::minFill()
    {
-        std::unordered_set<std::string> neighbors;
+        unordered_set<string> neighbors;
        for (auto child : children) {
            neighbors.emplace(child->getName());
        }
        for (auto parent : parents) {
            neighbors.emplace(parent->getName());
        }
-        auto source = std::vector<std::string>(neighbors.begin(), neighbors.end());
+        auto source = vector<string>(neighbors.begin(), neighbors.end());
        return combinations(source).size();
    }
-    std::vector<std::pair<std::string, std::string>> Node::combinations(const std::vector<std::string>& source)
+    vector<pair<string, string>> Node::combinations(const vector<string>& source)
    {
-        std::vector<std::pair<std::string, std::string>> result;
+        vector<pair<string, string>> result;
        for (int i = 0; i < source.size(); ++i) {
-            std::string temp = source[i];
+            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 std::vector<std::string>& features, const double laplaceSmoothing, const torch::Tensor& weights)
+    void Node::computeCPT(map<string, vector<int>>& dataset, const int laplaceSmoothing)
    {
-        dimensions.clear();
        // Get dimensions of the CPT
        dimensions.push_back(numStates);
-        transform(parents.begin(), parents.end(), back_inserter(dimensions), [](const auto& parent) { return parent->getNumStates(); });
-
+        transform(parents.begin(), parents.end(), back_inserter(dimensions), [](Node* parent) { return parent->getNumStates(); });
        // Create a tensor of zeros with the dimensions of the CPT
        cpTable = torch::zeros(dimensions, torch::kFloat) + laplaceSmoothing;
        // Fill table with counts
-        auto pos = find(features.begin(), features.end(), name);
-        if (pos == features.end()) {
-            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) {
-            c10::List<c10::optional<at::Tensor>> coordinates;
-            coordinates.push_back(dataset.index({ name_index, n_sample }));
-            for (auto parent : parents) {
-                pos = find(features.begin(), features.end(), parent->getName());
-                if (pos == features.end()) {
-                    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 }));
-            }
+        for (int n_sample = 0; n_sample < dataset[name].size(); ++n_sample) {
+            torch::List<c10::optional<torch::Tensor>> coordinates;
+            coordinates.push_back(torch::tensor(dataset[name][n_sample]));
+            transform(parents.begin(), parents.end(), back_inserter(coordinates), [&dataset, &n_sample](Node* parent) { return torch::tensor(dataset[parent->getName()][n_sample]); });
            // Increment the count of the corresponding coordinate
-            cpTable.index_put_({ coordinates }, cpTable.index({ coordinates }) + weights.index({ n_sample }).item<double>());
+            cpTable.index_put_({ coordinates }, cpTable.index({ coordinates }) + 1);
        }
        // Normalize the counts
        cpTable = cpTable / cpTable.sum(0);
    }
-    float Node::getFactorValue(std::map<std::string, int>& evidence)
+    float Node::getFactorValue(map<string, int>& evidence)
    {
-        c10::List<c10::optional<at::Tensor>> coordinates;
+        torch::List<c10::optional<torch::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(), std::back_inserter(coordinates), [&evidence](const auto& parent) { return at::tensor(evidence[parent->getName()]); });
+        coordinates.push_back(torch::tensor(evidence[name]));
+        transform(parents.begin(), parents.end(), back_inserter(coordinates), [&evidence](Node* parent) { return torch::tensor(evidence[parent->getName()]); });
        return cpTable.index({ coordinates }).item<float>();
    }
-    std::vector<std::string> Node::graph(const std::string& className)
+    vector<string> Node::graph(const string& className)
    {
-        auto output = std::vector<std::string>();
+        auto output = vector<string>();
        auto suffix = name == className ? ", fontcolor=red, fillcolor=lightblue, style=filled " : "";
        output.push_back(name + " [shape=circle" + suffix + "] \n");
-        transform(children.begin(), children.end(), back_inserter(output), [this](const auto& child) { return name + " -> " + child->getName(); });
+        transform(children.begin(), children.end(), back_inserter(output), [this](Node* child) { return name + " -> " + child->getName() + "\n"; });
        return output;
    }
 }
--- a/src/BayesNet/Node.h
+++ b/src/BayesNet/Node.h
@@ -5,32 +5,33 @@
 #include <vector>
 #include <string>
 namespace bayesnet {
+    using namespace std;
    class Node {
    private:
-        std::string name;
-        std::vector<Node*> parents;
-        std::vector<Node*> children;
+        string name;
+        vector<Node*> parents;
+        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, ...
-        std::vector<int64_t> dimensions; // dimensions of the cpTable
-        std::vector<std::pair<std::string, std::string>> combinations(const std::vector<std::string>&);
+        vector<int64_t> dimensions; // dimensions of the cpTable
    public:
-        explicit Node(const std::string&);
+        vector<pair<string, string>> combinations(const vector<string>&);
+        Node(const std::string&, int);
        void clear();
        void addParent(Node*);
        void addChild(Node*);
        void removeParent(Node*);
        void removeChild(Node*);
-        std::string getName() const;
-        std::vector<Node*>& getParents();
-        std::vector<Node*>& getChildren();
+        string getName() const;
+        vector<Node*>& getParents();
+        vector<Node*>& getChildren();
        torch::Tensor& getCPT();
-        void computeCPT(const torch::Tensor& dataset, const std::vector<std::string>& features, const double laplaceSmoothing, const torch::Tensor& weights);
+        void computeCPT(map<string, vector<int>>&, const int);
        int getNumStates() const;
        void setNumStates(int);
        unsigned minFill();
-        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>&);
+        vector<string> graph(const string& clasName); // Returns a vector of strings representing the graph in graphviz format
+        float getFactorValue(map<string, int>&);
    };
 }
 #endif
--- a/src/BayesNet/Proposal.cc
+++ b/src/BayesNet/Proposal.cc
@@ -1,110 +0,0 @@
-#include "Proposal.h"
-#include "ArffFiles.h"
-
-namespace bayesnet {
-    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) {
-            delete value;
-        }
-    }
-    void Proposal::checkInput(const torch::Tensor& X, const torch::Tensor& y)
-    {
-        if (!torch::is_floating_point(X)) {
-            throw std::invalid_argument("X must be a floating point tensor");
-        }
-        if (torch::is_floating_point(y)) {
-            throw std::invalid_argument("y must be an integer tensor");
-        }
-    }
-    map<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<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();
-            if (nodeParents.size() < 2) continue; // Only has class as parent
-            upgrade = true;
-            int index = find(pFeatures.begin(), pFeatures.end(), feature) - pFeatures.begin();
-            indicesToReDiscretize.push_back(index); // We need to re-discretize this feature
-            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
-            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)
-            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>());
-                }
-            }
-            auto arff = ArffFiles();
-            auto yxv = arff.factorize(yJoinParents);
-            auto xvf_ptr = Xf.index({ index }).data_ptr<float>();
-            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 = std::vector<float>(Xt_ptr, Xt_ptr + Xf.size(1));
-                pDataset.index_put_({ index, "..." }, torch::tensor(discretizers[pFeatures[index]]->transform(Xt)));
-                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;
-            }
-            const torch::Tensor weights = torch::full({ pDataset.size(1) }, 1.0 / pDataset.size(1), torch::kDouble);
-            model.fit(pDataset, weights, pFeatures, pClassName, states);
-        }
-        return states;
-    }
-    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<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 = 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 = 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 = std::vector<int>(n_classes);
-        iota(yStates.begin(), yStates.end(), 0);
-        states[pClassName] = yStates;
-        pDataset.index_put_({ n, "..." }, y);
-        return states;
-    }
-    torch::Tensor Proposal::prepareX(torch::Tensor& X)
-    {
-        auto Xtd = torch::zeros_like(X, torch::kInt32);
-        for (int i = 0; i < X.size(0); ++i) {
-            auto Xt = 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));
-        }
-        return Xtd;
-    }
-}
--- a/src/BayesNet/Proposal.h
+++ b/src/BayesNet/Proposal.h
@@ -1,30 +0,0 @@
-#ifndef PROPOSAL_H
-#define PROPOSAL_H
-#include <string>
-#include <map>
-#include <torch/torch.h>
-#include "Network.h"
-#include "CPPFImdlp.h"
-#include "Classifier.h"
-
-namespace bayesnet {
-    class Proposal {
-    public:
-        Proposal(torch::Tensor& pDataset, 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<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<std::string, mdlp::CPPFImdlp*> discretizers;
-    private:
-        torch::Tensor& pDataset; // (n+1)xm tensor
-        std::vector<std::string>& pFeatures;
-        std::string& pClassName;
-    };
-}
-
-#endif  
--- a/src/BayesNet/SPODE.cc
+++ b/src/BayesNet/SPODE.cc
@@ -4,7 +4,7 @@ namespace bayesnet {

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

-    void SPODE::buildModel(const torch::Tensor& weights)
+    void SPODE::train()
    {
        // 0. Add all nodes to the model
        addNodes();
@@ -17,7 +17,7 @@ namespace bayesnet {
            }
        }
    }
-    std::vector<std::string> SPODE::graph(const std::string& name) const
+    vector<string> SPODE::graph(string name )
    {
        return model.graph(name);
    }
--- a/src/BayesNet/SPODE.h
+++ b/src/BayesNet/SPODE.h
@@ -1,17 +1,15 @@
 #ifndef SPODE_H
 #define SPODE_H
 #include "Classifier.h"
-
 namespace bayesnet {
    class SPODE : public Classifier {
    private:
        int root;
    protected:
-        void buildModel(const torch::Tensor& weights) override;
+        void train() override;
    public:
        explicit SPODE(int root);
-        virtual ~SPODE() = default;
-        std::vector<std::string> graph(const std::string& name = "SPODE") const override;
+        vector<string> graph(string name = "SPODE") override;
    };
 }
 #endif
--- a/src/BayesNet/SPODELd.cc
+++ b/src/BayesNet/SPODELd.cc
@@ -1,47 +0,0 @@
-#include "SPODELd.h"
-
-namespace bayesnet {
-    SPODELd::SPODELd(int root) : SPODE(root), Proposal(dataset, features, className) {}
-    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 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
-        SPODE::fit(dataset, features, className, states);
-        states = localDiscretizationProposal(states, model);
-        return *this;
-    }
-    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");
-        }
-        Xf = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), "..." }).clone();
-        y = dataset.index({ -1, "..." }).clone();
-        features = features_;
-        className = className_;
-        // 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
-        SPODE::fit(dataset, features, className, states);
-        states = localDiscretizationProposal(states, model);
-        return *this;
-    }
-
-    torch::Tensor SPODELd::predict(torch::Tensor& X)
-    {
-        auto Xt = prepareX(X);
-        return SPODE::predict(Xt);
-    }
-    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
@@ -1,18 +0,0 @@
-#ifndef SPODELD_H
-#define SPODELD_H
-#include "SPODE.h"
-#include "Proposal.h"
-
-namespace bayesnet {
-    class SPODELd : public SPODE, public Proposal {
-    public:
-        explicit SPODELd(int root);
-        virtual ~SPODELd() = default;
-        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,27 +1,29 @@
 #include "TAN.h"

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

-    void TAN::buildModel(const torch::Tensor& weights)
+    void TAN::train()
    {
        // 0. Add all nodes to the model
        addNodes();
        // 1. Compute mutual information between each feature and the class and set the root node
        // as the highest mutual information with the class
-        auto mi = std::vector <std::pair<int, float >>();
-        torch::Tensor class_dataset = dataset.index({ -1, "..." });
+        auto mi = vector <pair<int, float >>();
+        Tensor class_dataset = dataset.index({ "...", -1 });
        for (int i = 0; i < static_cast<int>(features.size()); ++i) {
-            torch::Tensor feature_dataset = dataset.index({ i, "..." });
-            auto mi_value = metrics.mutualInformation(class_dataset, feature_dataset, weights);
+            Tensor feature_dataset = dataset.index({ "...", i });
+            auto mi_value = metrics.mutualInformation(class_dataset, feature_dataset);
            mi.push_back({ i, mi_value });
        }
        sort(mi.begin(), mi.end(), [](const auto& left, const auto& right) {return left.second < right.second;});
        auto root = mi[mi.size() - 1].first;
        // 2. Compute mutual information between each feature and the class
-        auto weights_matrix = metrics.conditionalEdge(weights);
+        auto weights = metrics.conditionalEdge();
        // 3. Compute the maximum spanning tree
-        auto mst = metrics.maximumSpanningTree(features, weights_matrix, root);
+        auto mst = metrics.maximumSpanningTree(features, weights, root);
        // 4. Add edges from the maximum spanning tree to the model
        for (auto i = 0; i < mst.size(); ++i) {
            auto [from, to] = mst[i];
@@ -32,7 +34,7 @@ namespace bayesnet {
            model.addEdge(className, feature);
        }
    }
-    std::vector<std::string> TAN::graph(const std::string& title) const
+    vector<string> TAN::graph(string title)
    {
        return model.graph(title);
    }
--- a/src/BayesNet/TAN.h
+++ b/src/BayesNet/TAN.h
@@ -2,14 +2,15 @@
 #define TAN_H
 #include "Classifier.h"
 namespace bayesnet {
+    using namespace std;
+    using namespace torch;
    class TAN : public Classifier {
    private:
    protected:
-        void buildModel(const torch::Tensor& weights) override;
+        void train() override;
    public:
        TAN();
-        virtual ~TAN() = default;
-        std::vector<std::string> graph(const std::string& name = "TAN") const override;
+        vector<string> graph(string name = "TAN") override;
    };
 }
 #endif
--- a/src/BayesNet/TANLd.cc
+++ b/src/BayesNet/TANLd.cc
@@ -1,30 +0,0 @@
-#include "TANLd.h"
-
-namespace bayesnet {
-    TANLd::TANLd() : TAN(), Proposal(dataset, features, className) {}
-    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 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
-        TAN::fit(dataset, features, className, states);
-        states = localDiscretizationProposal(states, model);
-        return *this;
-
-    }
-    torch::Tensor TANLd::predict(torch::Tensor& X)
-    {
-        auto Xt = prepareX(X);
-        return TAN::predict(Xt);
-    }
-    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
@@ -1,18 +0,0 @@
-#ifndef TANLD_H
-#define TANLD_H
-#include "TAN.h"
-#include "Proposal.h"
-
-namespace bayesnet {
-    class TANLd : public TAN, public Proposal {
-    private:
-    public:
-        TANLd();
-        virtual ~TANLd() = default;
-        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,23 +1,24 @@

 #include "bayesnetUtils.h"
 namespace bayesnet {
-    // Return the indices in descending order
-    std::vector<int> argsort(std::vector<double>& nums)
+    using namespace std;
+    using namespace torch;
+    vector<int> argsort(vector<float>& nums)
    {
        int n = nums.size();
-        std::vector<int> indices(n);
+        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;
    }
-    std::vector<std::vector<int>> tensorToVector(torch::Tensor& tensor)
+    vector<vector<int>> tensorToVector(Tensor& tensor)
    {
-        // convert mxn tensor to nxm std::vector
-        std::vector<std::vector<int>> result;
+        // convert mxn tensor to nxm vector
+        vector<vector<int>> result;
        // Iterate over cols
        for (int i = 0; i < tensor.size(1); ++i) {
            auto col_tensor = tensor.index({ "...", i });
-            auto col = std::vector<int>(col_tensor.data_ptr<int>(), col_tensor.data_ptr<int>() + tensor.size(0));
+            auto col = 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,7 +3,9 @@
 #include <torch/torch.h>
 #include <vector>
 namespace bayesnet {
-    std::vector<int> argsort(std::vector<double>& nums);
-    std::vector<std::vector<int>> tensorToVector(torch::Tensor& tensor);
+    using namespace std;
+    using namespace torch;
+    vector<int> argsort(vector<float>& nums);
+    vector<vector<int>> tensorToVector(Tensor& tensor);
 }
 #endif //BAYESNET_UTILS_H
--- a/src/Platform/CMakeLists.txt
+++ b/src/Platform/CMakeLists.txt
@@ -0,0 +1,8 @@
+include_directories(${BayesNet_SOURCE_DIR}/src/BayesNet)
+include_directories(${BayesNet_SOURCE_DIR}/src/Platform)
+include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
+include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
+include_directories(${BayesNet_SOURCE_DIR}/lib/argparse/include)
+include_directories(${BayesNet_SOURCE_DIR}/lib/json/include)
+add_executable(main main.cc Folding.cc platformUtils.cc Experiment.cc Datasets.cc CrossValidation.cc Models.cc)
+target_link_libraries(main BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}")
--- a/src/Platform/CrossValidation.cc
+++ b/src/Platform/CrossValidation.cc
@@ -0,0 +1,79 @@
+#include "CrossValidation.h"
+#include "Models.h"
+
+namespace platform {
+    using json = nlohmann::json;
+    using namespace std::chrono;
+
+    CrossValidation::CrossValidation(const string& modelName, bool stratified, int nfolds, const vector<int>& randomSeeds, platform::Datasets& datasets) : modelName(modelName), stratified(stratified), nfolds(nfolds), randomSeeds(randomSeeds), datasets(datasets)
+    {
+    }
+
+    Result CrossValidation::crossValidate(const string& fileName)
+    {
+        auto [Xt, y] = datasets.getTensors(fileName);
+        auto states = datasets.getStates(fileName);
+        auto className = datasets.getClassName(fileName);
+        auto features = datasets.getFeatures(fileName);
+        auto samples = datasets.getNSamples(fileName);
+        auto result = Result();
+        auto [values, counts] = at::_unique(y);
+        result.setSamples(Xt.size(1)).setFeatures(Xt.size(0)).setClasses(values.size(0));
+        int nSeeds = static_cast<int>(randomSeeds.size());
+        auto accuracy_test = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
+        auto accuracy_train = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
+        auto train_time = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
+        auto test_time = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
+        auto nodes = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
+        auto edges = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
+        auto num_states = torch::zeros({ nfolds * nSeeds }, torch::kFloat64);
+        Timer train_timer, test_timer;
+        int item = 0;
+        for (auto seed : randomSeeds) {
+            cout << "(" << seed << ") " << flush;
+            Fold* fold;
+            if (stratified)
+                fold = new StratifiedKFold(nfolds, y, seed);
+            else
+                fold = new KFold(nfolds, samples, seed);
+            cout << "Fold: " << flush;
+            for (int nfold = 0; nfold < nfolds; nfold++) {
+                bayesnet::BaseClassifier* model = Models::get(modelName);
+                result.setModelVersion(model->getVersion());
+                train_timer.start();
+                auto [train, test] = fold->getFold(nfold);
+                auto train_t = torch::tensor(train);
+                auto test_t = torch::tensor(test);
+                auto X_train = Xt.index({ "...", train_t });
+                auto y_train = y.index({ train_t });
+                auto X_test = Xt.index({ "...", test_t });
+                auto y_test = y.index({ test_t });
+                cout << nfold + 1 << ", " << flush;
+                model->fit(X_train, y_train, features, className, states);
+                nodes[item] = model->getNumberOfNodes();
+                edges[item] = model->getNumberOfEdges();
+                num_states[item] = model->getNumberOfStates();
+                train_time[item] = train_timer.getDuration();
+                auto accuracy_train_value = model->score(X_train, y_train);
+                test_timer.start();
+                auto accuracy_test_value = model->score(X_test, y_test);
+                test_time[item] = test_timer.getDuration();
+                accuracy_train[item] = accuracy_train_value;
+                accuracy_test[item] = accuracy_test_value;
+                // Store results and times in vector
+                result.addScoreTrain(accuracy_train_value);
+                result.addScoreTest(accuracy_test_value);
+                result.addTimeTrain(train_time[item].item<double>());
+                result.addTimeTest(test_time[item].item<double>());
+                item++;
+            }
+            delete fold;
+        }
+        cout << "end." << endl;
+        result.setScoreTest(torch::mean(accuracy_test).item<double>()).setScoreTrain(torch::mean(accuracy_train).item<double>());
+        result.setScoreTestStd(torch::std(accuracy_test).item<double>()).setScoreTrainStd(torch::std(accuracy_train).item<double>());
+        result.setTrainTime(torch::mean(train_time).item<double>()).setTestTime(torch::mean(test_time).item<double>());
+        result.setNodes(torch::mean(nodes).item<double>()).setLeaves(torch::mean(edges).item<double>()).setDepth(torch::mean(num_states).item<double>());
+        return result;
+    }
+} // namespace platform
--- a/src/Platform/CrossValidation.h
+++ b/src/Platform/CrossValidation.h
@@ -0,0 +1,25 @@
+#ifndef CROSSVALIDATION_H
+#define CROSSVALIDATION_H
+#include <torch/torch.h>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <chrono>
+#include "Folding.h"
+#include "Datasets.h"
+#include "Experiment.h"
+
+namespace platform {
+    class CrossValidation {
+    private:
+        bool stratified;
+        int nfolds;
+        string modelName;
+        vector<int> randomSeeds;
+        platform::Datasets& datasets;
+    public:
+        CrossValidation(const string& modelName, bool stratified, int nfolds, const vector<int>& randomSeeds, platform::Datasets& datasets);
+        ~CrossValidation() = default;
+        Result crossValidate(const string& fileName);
+    };
+}
+#endif // !CROSSVALIDATION_H
--- a/src/Platform/Datasets.cc
+++ b/src/Platform/Datasets.cc
@@ -0,0 +1,239 @@
+#include "Datasets.h"
+#include "platformUtils.h"
+#include "ArffFiles.h"
+namespace platform {
+    vector<string> split(const string& text, char delimiter)
+    {
+        vector<string> result;
+        stringstream ss(text);
+        string token;
+        while (getline(ss, token, delimiter)) {
+            result.push_back(token);
+        }
+        return result;
+    }
+    void Datasets::load()
+    {
+        ifstream catalog(path + "/all.txt");
+        if (catalog.is_open()) {
+            string line;
+            while (getline(catalog, line)) {
+                vector<string> tokens = split(line, ',');
+                string name = tokens[0];
+                string className = tokens[1];
+                datasets[name] = make_unique<Dataset>(path, name, className, discretize, fileType);
+            }
+            catalog.close();
+        } else {
+            throw invalid_argument("Unable to open catalog file. [" + path + "/all.txt" + "]");
+        }
+    }
+    vector<string> Datasets::getNames()
+    {
+        vector<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)
+    {
+        if (datasets[name]->isLoaded()) {
+            return datasets[name]->getFeatures();
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    map<string, vector<int>> Datasets::getStates(const string& name)
+    {
+        if (datasets[name]->isLoaded()) {
+            return datasets[name]->getStates();
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    string Datasets::getClassName(const string& name)
+    {
+        if (datasets[name]->isLoaded()) {
+            return datasets[name]->getClassName();
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    int Datasets::getNSamples(const string& name)
+    {
+        if (datasets[name]->isLoaded()) {
+            return datasets[name]->getNSamples();
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    pair<vector<vector<float>>&, vector<int>&> Datasets::getVectors(const string& name)
+    {
+        if (!datasets[name]->isLoaded()) {
+            datasets[name]->load();
+        }
+        return datasets[name]->getVectors();
+    }
+    pair<vector<vector<int>>&, vector<int>&> Datasets::getVectorsDiscretized(const string& name)
+    {
+        if (!datasets[name]->isLoaded()) {
+            datasets[name]->load();
+        }
+        return datasets[name]->getVectorsDiscretized();
+    }
+    pair<torch::Tensor&, torch::Tensor&> Datasets::getTensors(const string& name)
+    {
+        if (!datasets[name]->isLoaded()) {
+            datasets[name]->load();
+        }
+        return datasets[name]->getTensors();
+    }
+    bool Datasets::isDataset(const string& name)
+    {
+        return datasets.find(name) != datasets.end();
+    }
+    Dataset::Dataset(Dataset& dataset) : path(dataset.path), name(dataset.name), className(dataset.className), n_samples(dataset.n_samples), n_features(dataset.n_features), features(dataset.features), states(dataset.states), loaded(dataset.loaded), discretize(dataset.discretize), X(dataset.X), y(dataset.y), Xv(dataset.Xv), Xd(dataset.Xd), yv(dataset.yv), fileType(dataset.fileType) {}
+    string Dataset::getName()
+    {
+        return name;
+    }
+    string Dataset::getClassName()
+    {
+        return className;
+    }
+    vector<string> Dataset::getFeatures()
+    {
+        if (loaded) {
+            return features;
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    int Dataset::getNFeatures()
+    {
+        if (loaded) {
+            return n_features;
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    int Dataset::getNSamples()
+    {
+        if (loaded) {
+            return n_samples;
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    map<string, vector<int>> Dataset::getStates()
+    {
+        if (loaded) {
+            return states;
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    pair<vector<vector<float>>&, vector<int>&> Dataset::getVectors()
+    {
+        if (loaded) {
+            return { Xv, yv };
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    pair<vector<vector<int>>&, vector<int>&> Dataset::getVectorsDiscretized()
+    {
+        if (loaded) {
+            return { Xd, yv };
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    pair<torch::Tensor&, torch::Tensor&> Dataset::getTensors()
+    {
+        if (loaded) {
+            buildTensors();
+            return { X, y };
+        } else {
+            throw invalid_argument("Dataset not loaded.");
+        }
+    }
+    void Dataset::load_csv()
+    {
+        ifstream file(path + "/" + name + ".csv");
+        if (file.is_open()) {
+            string line;
+            getline(file, line);
+            vector<string> tokens = split(line, ',');
+            features = vector<string>(tokens.begin(), tokens.end() - 1);
+            className = tokens.back();
+            for (auto i = 0; i < features.size(); ++i) {
+                Xv.push_back(vector<float>());
+            }
+            while (getline(file, line)) {
+                tokens = split(line, ',');
+                for (auto i = 0; i < features.size(); ++i) {
+                    Xv[i].push_back(stof(tokens[i]));
+                }
+                yv.push_back(stoi(tokens.back()));
+            }
+            file.close();
+        } else {
+            throw 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);
+            iota(begin(states[features[i]]), end(states[features[i]]), 0);
+        }
+        states[className] = vector<int>(*max_element(yv.begin(), yv.end()) + 1);
+        iota(begin(states[className]), end(states[className]), 0);
+    }
+    void Dataset::load_arff()
+    {
+        auto arff = ArffFiles();
+        arff.load(path + "/" + name + ".arff", className);
+        // Get Dataset X, y
+        Xv = arff.getX();
+        yv = arff.getY();
+        // Get className & Features
+        className = arff.getClassName();
+        auto attributes = arff.getAttributes();
+        transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& f) { return f.first; });
+    }
+    void Dataset::load()
+    {
+        if (loaded) {
+            return;
+        }
+        if (fileType == CSV) {
+            load_csv();
+        } else if (fileType == ARFF) {
+            load_arff();
+        }
+        if (discretize) {
+            Xd = discretizeDataset(Xv, yv);
+            computeStates();
+            n_samples = Xd[0].size();
+            n_features = Xd.size();
+        }
+        loaded = true;
+    }
+    void Dataset::buildTensors()
+    {
+        if (discretize) {
+            X = torch::zeros({ static_cast<int>(n_features), static_cast<int>(n_samples) }, torch::kInt32);
+        } else {
+            X = torch::zeros({ static_cast<int>(n_features), static_cast<int>(n_samples) }, torch::kFloat32);
+        }
+        for (int i = 0; i < features.size(); ++i) {
+            if (discretize) {
+                X.index_put_({ i,  "..." }, torch::tensor(Xd[i], torch::kInt32));
+            } else {
+                X.index_put_({ i,  "..." }, torch::tensor(Xv[i], torch::kFloat32));
+            }
+        }
+        y = torch::tensor(yv, torch::kInt32);
+    }
+}
--- a/src/Platform/Datasets.h
+++ b/src/Platform/Datasets.h
@@ -0,0 +1,66 @@
+#ifndef DATASETS_H
+#define DATASETS_H
+#include <torch/torch.h>
+#include <map>
+#include <vector>
+#include <string>
+namespace platform {
+    using namespace std;
+    enum fileType_t { CSV, ARFF };
+    class Dataset {
+    private:
+        string path;
+        string name;
+        fileType_t fileType;
+        string className;
+        int n_samples, n_features;
+        vector<string> features;
+        map<string, vector<int>> states;
+        bool loaded;
+        bool discretize;
+        torch::Tensor X, y;
+        vector<vector<float>> Xv;
+        vector<vector<int>> Xd;
+        vector<int> yv;
+        void buildTensors();
+        void load_csv();
+        void load_arff();
+        void computeStates();
+    public:
+        Dataset(const string& path, const string& name, const string& className, bool discretize, fileType_t fileType) : path(path), name(name), className(className), discretize(discretize), loaded(false), fileType(fileType), n_samples(0), n_features(0) {};
+        explicit Dataset(Dataset&);
+        string getName();
+        string getClassName();
+        vector<string> getFeatures();
+        map<string, vector<int>> getStates();
+        pair<vector<vector<float>>&, vector<int>&> getVectors();
+        pair<vector<vector<int>>&, vector<int>&> getVectorsDiscretized();
+        pair<torch::Tensor&, torch::Tensor&> getTensors();
+        int getNFeatures();
+        int getNSamples();
+        void load();
+        const bool inline isLoaded() const { return loaded; };
+    };
+    class Datasets {
+    private:
+        string path;
+        fileType_t fileType;
+        map<string, unique_ptr<Dataset>> datasets;
+        bool discretize;
+        void load(); // Loads the list of datasets
+    public:
+        explicit Datasets(const string& path, bool discretize = false, fileType_t fileType = ARFF) : path(path), discretize(discretize), fileType(fileType) { load(); };
+        vector<string> getNames();
+        vector<string> getFeatures(const string& name);
+        int getNSamples(const string& name);
+        string getClassName(const string& name);
+        map<string, vector<int>> getStates(const string& name);
+        pair<vector<vector<float>>&, vector<int>&> getVectors(const string& name);
+        pair<vector<vector<int>>&, vector<int>&> getVectorsDiscretized(const string& name);
+        pair<torch::Tensor&, torch::Tensor&> getTensors(const string& name);
+        bool isDataset(const string& name);
+    };
+    vector<string> split(const string&, char);
+};
+
+#endif
--- a/src/Platform/DotEnv.h
+++ b/src/Platform/DotEnv.h
@@ -0,0 +1,67 @@
+#ifndef DOTENV_H
+#define DOTENV_H
+#include <string>
+#include <map>
+#include <fstream>
+#include <sstream>
+std::vector<std::string> split(std::string text, char delimiter)
+{
+    std::vector<std::string> result;
+    std::stringstream ss(text);
+    std::string token;
+    while (getline(ss, token, delimiter)) {
+        result.push_back(token);
+    }
+    return result;
+}
+class DotEnv {
+private:
+    std::map<std::string, std::string> env;
+    std::string trim(const std::string& str)
+    {
+        std::string result = str;
+        result.erase(result.begin(), std::find_if(result.begin(), result.end(), [](int ch) {
+            return !std::isspace(ch);
+            }));
+        result.erase(std::find_if(result.rbegin(), result.rend(), [](int ch) {
+            return !std::isspace(ch);
+            }).base(), result.end());
+        return result;
+    }
+public:
+    DotEnv()
+    {
+        std::ifstream file(".env");
+        if (!file.is_open()) {
+            std::cerr << "File .env not found" << std::endl;
+            exit(1);
+        }
+        std::string line;
+        while (std::getline(file, line)) {
+            line = trim(line);
+            if (line.empty() || line[0] == '#') {
+                continue;
+            }
+            std::istringstream iss(line);
+            std::string key, value;
+            if (std::getline(iss, key, '=') && std::getline(iss, value)) {
+                env[key] = value;
+            }
+        }
+    }
+    std::string get(const std::string& key)
+    {
+        return env[key];
+    }
+    std::vector<int> getSeeds()
+    {
+        auto seeds = std::vector<int>();
+        auto seeds_str = env["seeds"];
+        seeds_str = trim(seeds_str);
+        seeds_str = seeds_str.substr(1, seeds_str.size() - 2);
+        auto seeds_str_split = split(seeds_str, ',');
+        transform(seeds_str_split.begin(), seeds_str_split.end(), back_inserter(seeds), [](const auto& s) { return stoi(s); });
+        return seeds;
+    }
+};
+#endif
--- a/src/Platform/Experiment.cc
+++ b/src/Platform/Experiment.cc
@@ -0,0 +1,92 @@
+#include "Experiment.h"
+
+namespace platform {
+    using json = nlohmann::json;
+    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();
+    }
+    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();
+    }
+    string Experiment::get_file_name()
+    {
+        string result = "results_" + score_name + "_" + model + "_" + platform + "_" + get_date() + "_" + get_time() + "_" + (stratified ? "1" : "0") + ".json";
+        return result;
+    }
+
+    json Experiment::build_json()
+    {
+        json result;
+        result["title"] = title;
+        result["date"] = get_date();
+        result["time"] = get_time();
+        result["model"] = model;
+        result["version"] = model_version;
+        result["platform"] = platform;
+        result["score_name"] = score_name;
+        result["language"] = language;
+        result["language_version"] = language_version;
+        result["discretized"] = discretized;
+        result["stratified"] = stratified;
+        result["folds"] = nfolds;
+        result["seeds"] = random_seeds;
+        result["duration"] = duration;
+        result["results"] = json::array();
+        for (const auto& r : results) {
+            json j;
+            j["dataset"] = r.getDataset();
+            j["hyperparameters"] = r.getHyperparameters();
+            j["samples"] = r.getSamples();
+            j["features"] = r.getFeatures();
+            j["classes"] = r.getClasses();
+            j["score_train"] = r.getScoreTrain();
+            j["score_test"] = r.getScoreTest();
+            j["score"] = r.getScoreTest();
+            j["score_std"] = r.getScoreTestStd();
+            j["score_train_std"] = r.getScoreTrainStd();
+            j["score_test_std"] = r.getScoreTestStd();
+            j["train_time"] = r.getTrainTime();
+            j["train_time_std"] = r.getTrainTimeStd();
+            j["test_time"] = r.getTestTime();
+            j["test_time_std"] = r.getTestTimeStd();
+            j["time"] = r.getTestTime() + r.getTrainTime();
+            j["time_std"] = r.getTestTimeStd() + r.getTrainTimeStd();
+            j["scores_train"] = r.getScoresTrain();
+            j["scores_test"] = r.getScoresTest();
+            j["times_train"] = r.getTimesTrain();
+            j["times_test"] = r.getTimesTest();
+            j["nodes"] = r.getNodes();
+            j["leaves"] = r.getLeaves();
+            j["depth"] = r.getDepth();
+            result["results"].push_back(j);
+        }
+        return result;
+    }
+    void Experiment::save(const string& path)
+    {
+        json data = build_json();
+        ofstream file(path + "/" + get_file_name());
+        file << data;
+        file.close();
+    }
+    void Experiment::show()
+    {
+        json data = build_json();
+        cout << data.dump(4) << endl;
+    }
+
+}
--- a/src/Platform/Experiment.h
+++ b/src/Platform/Experiment.h
@@ -0,0 +1,108 @@
+#ifndef EXPERIMENT_H
+#define EXPERIMENT_H
+#include <torch/torch.h>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <chrono>
+
+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 = "", hyperparameters = "", model_version = "";
+        int samples{ 0 }, features{ 0 }, classes{ 0 };
+        double score_train{ 0 }, score_test = 0, score_train_std = 0, score_test_std = 0, train_time = 0, train_time_std = 0, test_time = 0, test_time_std = 0;
+        vector<double> scores_train{}, scores_test{}, times_train{}, times_test{};
+        float nodes{ 0 }, leaves{ 0 }, depth{ 0 };
+    public:
+        Result() = default;
+        Result& setDataset(const string& dataset) { this->dataset = dataset; return *this; }
+        Result& setHyperparameters(const string& hyperparameters) { this->hyperparameters = hyperparameters; return *this; }
+        Result& setSamples(const int samples) { this->samples = samples; return *this; }
+        Result& setFeatures(const int features) { this->features = features; return *this; }
+        Result& setClasses(const int classes) { this->classes = classes; return *this; }
+        Result& setScoreTrain(const double score) { this->score_train = score; return *this; }
+        Result& setScoreTest(const double score) { this->score_test = score; return *this; }
+        Result& setScoreTrainStd(const double score_std) { this->score_train_std = score_std; return *this; }
+        Result& setScoreTestStd(const double score_std) { this->score_test_std = score_std; return *this; }
+        Result& setTrainTime(const double train_time) { this->train_time = train_time; return *this; }
+        Result& setTrainTimeStd(const double train_time_std) { this->train_time_std = train_time_std; return *this; }
+        Result& setTestTime(const double test_time) { this->test_time = test_time; return *this; }
+        Result& setTestTimeStd(const double test_time_std) { this->test_time_std = test_time_std; return *this; }
+        Result& setNodes(const float nodes) { this->nodes = nodes; return *this; }
+        Result& setLeaves(const float leaves) { this->leaves = leaves; return *this; }
+        Result& setDepth(const float depth) { this->depth = depth; return *this; }
+        Result& setModelVersion(const string& model_version) { this->model_version = model_version; return *this; }
+        Result& addScoreTrain(const double score) { scores_train.push_back(score); return *this; }
+        Result& addScoreTest(const double score) { scores_test.push_back(score); return *this; }
+        Result& addTimeTrain(const double time) { times_train.push_back(time); return *this; }
+        Result& addTimeTest(const double time) { times_test.push_back(time); return *this; }
+        const float get_score_train() const { return score_train; }
+        float get_score_test() { return score_test; }
+        const string& getDataset() const { return dataset; }
+        const string& getHyperparameters() const { return hyperparameters; }
+        const int getSamples() const { return samples; }
+        const int getFeatures() const { return features; }
+        const int getClasses() const { return classes; }
+        const double getScoreTrain() const { return score_train; }
+        const double getScoreTest() const { return score_test; }
+        const double getScoreTrainStd() const { return score_train_std; }
+        const double getScoreTestStd() const { return score_test_std; }
+        const double getTrainTime() const { return train_time; }
+        const double getTrainTimeStd() const { return train_time_std; }
+        const double getTestTime() const { return test_time; }
+        const double getTestTimeStd() const { return test_time_std; }
+        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 string& getModelVersion() const { return model_version; }
+    };
+    class Experiment {
+    private:
+        string title{""}, model{""}, platform{""}, score_name{""}, model_version{""}, language_version{""}, language{""};
+        bool discretized{false}, stratified{false};
+        vector<Result> results;
+        vector<int> random_seeds;
+        int nfolds{0};
+        float duration{0};
+        json build_json();
+    public:
+        Experiment() = default;
+        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& setDiscretized(const bool discretized) { this->discretized = discretized; return *this; }
+        Experiment& setStratified(const bool stratified) { this->stratified = stratified; return *this; }
+        Experiment& setNFolds(const int nfolds) { this->nfolds = nfolds; return *this; }
+        Experiment& addResult(Result result) { results.push_back(result); return *this; }
+        Experiment& addRandomSeed(const int random_seed) { random_seeds.push_back(random_seed); return *this; }
+        Experiment& setDuration(const float duration) { this->duration = duration; return *this; }
+        string get_file_name();
+        void save(const string& path);
+        void show();
+    };
+}
+#endif
--- a/src/Platform/Folding.cc
+++ b/src/Platform/Folding.cc
@@ -0,0 +1,95 @@
+#include "Folding.h"
+#include <algorithm>
+#include <map>
+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);
+}
+KFold::KFold(int k, int n, int seed) : Fold(k, n, seed), indices(vector<int>())
+{
+    iota(begin(indices), end(indices), 0); // fill with 0, 1, ..., n - 1
+    shuffle(indices.begin(), indices.end(), random_seed);
+}
+pair<vector<int>, vector<int>> KFold::getFold(int nFold)
+{
+    if (nFold >= k || nFold < 0) {
+        throw out_of_range("nFold (" + to_string(nFold) + ") must be less than k (" + to_string(k) + ")");
+    }
+    int nTest = n / k;
+    auto train = vector<int>();
+    auto test = vector<int>();
+    for (int i = 0; i < n; i++) {
+        if (i >= nTest * nFold && i < nTest * (nFold + 1)) {
+            test.push_back(indices[i]);
+        } else {
+            train.push_back(indices[i]);
+        }
+    }
+    return { train, test };
+}
+StratifiedKFold::StratifiedKFold(int k, torch::Tensor& y, int seed) : Fold(k, y.numel(), seed)
+{
+    n = y.numel();
+    this->y = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + n);
+    build();
+}
+StratifiedKFold::StratifiedKFold(int k, const vector<int>& y, int seed)
+    : Fold(k, y.size(), seed)
+{
+    this->y = y;
+    n = y.size();
+    build();
+}
+void StratifiedKFold::build()
+{
+    stratified_indices = vector<vector<int>>(k);
+    int fold_size = n / k;
+    // Compute class counts and indices
+    auto class_indices = map<int, vector<int>>();
+    vector<int> class_counts(*max_element(y.begin(), y.end()) + 1, 0);
+    for (auto i = 0; i < n; ++i) {
+        class_counts[y[i]]++;
+        class_indices[y[i]].push_back(i);
+    }
+    // Shuffle class indices
+    for (auto& [cls, indices] : class_indices) {
+        shuffle(indices.begin(), indices.end(), random_seed);
+    }
+    // Assign indices to folds
+    for (auto label = 0; label < class_counts.size(); ++label) {
+        auto num_samples_to_take = class_counts[label] / k;
+        if (num_samples_to_take == 0)
+            continue;
+        auto remainder_samples_to_take = class_counts[label] % k;
+        for (auto fold = 0; fold < k; ++fold) {
+            auto it = next(class_indices[label].begin(), num_samples_to_take);
+            move(class_indices[label].begin(), it, back_inserter(stratified_indices[fold]));  // ##
+            class_indices[label].erase(class_indices[label].begin(), it);
+        }
+        while (remainder_samples_to_take > 0) {
+            int fold = (rand() % static_cast<int>(k));
+            if (stratified_indices[fold].size() == fold_size + 1) {
+                continue;
+            }
+            auto it = next(class_indices[label].begin(), 1);
+            stratified_indices[fold].push_back(*class_indices[label].begin());
+            class_indices[label].erase(class_indices[label].begin(), it);
+            remainder_samples_to_take--;
+        }
+    }
+}
+pair<vector<int>, 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) + ")");
+    }
+    vector<int> test_indices = stratified_indices[nFold];
+    vector<int> train_indices;
+    for (int i = 0; i < k; ++i) {
+        if (i == nFold) continue;
+        train_indices.insert(train_indices.end(), stratified_indices[i].begin(), stratified_indices[i].end());
+    }
+    return { train_indices, test_indices };
+}
--- a/src/Platform/Folding.h
+++ b/src/Platform/Folding.h
@@ -0,0 +1,37 @@
+#ifndef FOLDING_H
+#define FOLDING_H
+#include <torch/torch.h>
+#include <vector>
+#include <random> 
+using namespace std;
+
+class Fold {
+protected:
+    int k;
+    int n;
+    int seed;
+    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 ~Fold() = default;
+    int getNumberOfFolds() { return k; }
+};
+class KFold : public Fold {
+private:
+    vector<int> indices;
+public:
+    KFold(int k, int n, int seed = -1);
+    pair<vector<int>, vector<int>> getFold(int nFold) override;
+};
+class StratifiedKFold : public Fold {
+private:
+    vector<int> y;
+    vector<vector<int>> stratified_indices;
+    void build();
+public:
+    StratifiedKFold(int k, const vector<int>& y, int seed = -1);
+    StratifiedKFold(int k, torch::Tensor& y, int seed = -1);
+    pair<vector<int>, vector<int>> getFold(int nFold) override;
+};
+#endif
--- a/src/Platform/Models.cc
+++ b/src/Platform/Models.cc
@@ -0,0 +1,8 @@
+#include "Models.h"
+namespace platform {
+    using namespace std;
+    map<string, bayesnet::BaseClassifier*> Models::classifiers = map<string, bayesnet::BaseClassifier*>({
+        { "AODE", new bayesnet::AODE() }, { "KDB", new bayesnet::KDB(2) },
+        { "SPODE",  new bayesnet::SPODE(2) }, { "TAN",  new bayesnet::TAN() }
+        });
+}
--- a/src/Platform/Models.h
+++ b/src/Platform/Models.h
@@ -0,0 +1,33 @@
+#ifndef MODELS_H
+#define MODELS_H
+#include <map>
+#include "BaseClassifier.h"
+#include "AODE.h"
+#include "TAN.h"
+#include "KDB.h"
+#include "SPODE.h"
+namespace platform {
+    class Models {
+    private:
+        static map<string, bayesnet::BaseClassifier*> classifiers;
+    public:
+        static bayesnet::BaseClassifier* get(string name) { return classifiers[name]; }
+        static vector<string> getNames()
+        {
+            vector<string> names;
+            for (auto& [name, classifier] : classifiers) {
+                names.push_back(name);
+            }
+            return names;
+        }
+        static string toString()
+        {
+            string names = "";
+            for (auto& [name, classifier] : classifiers) {
+                names += name + ", ";
+            }
+            return "{" + names.substr(0, names.size() - 2) + "}";
+        }
+    };
+}
+#endif
--- a/src/Platform/main.cc
+++ b/src/Platform/main.cc
@@ -0,0 +1,136 @@
+#include <iostream>
+#include <argparse/argparse.hpp>
+#include "platformUtils.h"
+#include "Experiment.h"
+#include "Datasets.h"
+#include "DotEnv.h"
+#include "CrossValidation.h"
+#include "Models.h"
+
+
+using namespace std;
+const string PATH_RESULTS = "results";
+const string PATH_DATASETS = "datasets";
+
+argparse::ArgumentParser manageArguments(int argc, char** argv)
+{
+    auto env = DotEnv();
+    argparse::ArgumentParser program("BayesNetSample");
+    program.add_argument("-d", "--dataset").default_value("").help("Dataset file name");
+    program.add_argument("-p", "--path")
+        .help("folder where the data files are located, default")
+        .default_value(string{ PATH_DATASETS }
+    );
+    program.add_argument("-m", "--model")
+        .help("Model to use " + platform::Models::toString())
+        .action([](const std::string& value) {
+        static const vector<string> choices = platform::Models::getNames();
+        if (find(choices.begin(), choices.end(), value) != choices.end()) {
+            return value;
+        }
+        throw runtime_error("Model must be one of " + platform::Models::toString());
+            }
+    );
+    program.add_argument("--title").default_value("").help("Experiment title");
+    program.add_argument("--discretize").help("Discretize input dataset").default_value((bool)stoi(env.get("discretize"))).implicit_value(true);
+    program.add_argument("--stratified").help("If Stratified KFold is to be done").default_value((bool)stoi(env.get("stratified"))).implicit_value(true);
+    program.add_argument("-f", "--folds").help("Number of folds").default_value(stoi(env.get("n_folds"))).scan<'i', int>().action([](const string& value) {
+        try {
+            auto k = stoi(value);
+            if (k < 2) {
+                throw runtime_error("Number of folds must be greater than 1");
+            }
+            return k;
+        }
+        catch (const runtime_error& err) {
+            throw runtime_error(err.what());
+        }
+        catch (...) {
+            throw runtime_error("Number of folds must be an integer");
+        }});
+    auto seed_values = env.getSeeds();
+    program.add_argument("-s", "--seeds").nargs(1, 10).help("Random seeds. Set to -1 to have pseudo random").scan<'i', int>().default_value(seed_values);
+    try {
+        program.parse_args(argc, argv);
+        auto file_name = program.get<string>("dataset");
+        auto path = program.get<string>("path");
+        auto model_name = program.get<string>("model");
+        auto discretize_dataset = program.get<bool>("discretize");
+        auto stratified = program.get<bool>("stratified");
+        auto n_folds = program.get<int>("folds");
+        auto seeds = program.get<vector<int>>("seeds");
+        auto complete_file_name = path + file_name + ".arff";
+        auto title = program.get<string>("title");
+        if (title == "" && file_name == "") {
+            throw runtime_error("title is mandatory if dataset is not provided");
+        }
+    }
+    catch (const exception& err) {
+        cerr << err.what() << endl;
+        cerr << program;
+        exit(1);
+    }
+    return program;
+}
+
+int main(int argc, char** argv)
+{
+    auto program = manageArguments(argc, argv);
+    bool saveResults = false;
+    auto file_name = program.get<string>("dataset");
+    auto path = program.get<string>("path");
+    auto model_name = program.get<string>("model");
+    auto discretize_dataset = program.get<bool>("discretize");
+    auto stratified = program.get<bool>("stratified");
+    auto n_folds = program.get<int>("folds");
+    auto seeds = program.get<vector<int>>("seeds");
+    vector<string> filesToProcess;
+    auto datasets = platform::Datasets(path, true, platform::ARFF);
+    auto title = program.get<string>("title");
+    if (file_name != "") {
+        if (!datasets.isDataset(file_name)) {
+            cerr << "Dataset " << file_name << " not found" << endl;
+            exit(1);
+        }
+        if (title == "") {
+            title = "Test " + file_name + " " + model_name + " " + to_string(n_folds) + " folds";
+        }
+        filesToProcess.push_back(file_name);
+    } else {
+        filesToProcess = platform::Datasets(path, true, platform::ARFF).getNames();
+        saveResults = true; // Only save results if all datasets are processed
+    }
+
+    /*
+    * Begin Processing
+    */
+    auto experiment = platform::Experiment();
+    experiment.setTitle(title).setLanguage("cpp").setLanguageVersion("1.0.0");
+    experiment.setDiscretized(discretize_dataset).setModel(model_name).setPlatform("BayesNet");
+    experiment.setStratified(stratified).setNFolds(n_folds).setScoreName("accuracy");
+    for (auto seed : seeds) {
+        experiment.addRandomSeed(seed);
+    }
+    platform::Timer timer;
+    cout << "*** Starting experiment: " << title << " ***" << endl;
+    timer.start();
+    auto validation = platform::CrossValidation(model_name, stratified, n_folds, seeds, datasets);
+    for (auto fileName : filesToProcess) {
+        cout << "- " << setw(20) << left << fileName << " " << right << flush;
+        auto [X, y] = datasets.getTensors(fileName);
+        auto features = datasets.getFeatures(fileName);
+        auto samples = datasets.getNSamples(fileName);
+        cout << " (" << setw(5) << samples << "," << setw(3) << features.size() << ") " << flush;
+        auto result = validation.crossValidate(fileName);
+        result.setDataset(fileName);
+        experiment.setModelVersion(result.getModelVersion());
+        experiment.addResult(result);
+    }
+    experiment.setDuration(timer.getDuration());
+    if (saveResults)
+        experiment.save(PATH_RESULTS);
+    else
+        experiment.show();
+    cout << "Done!" << endl;
+    return 0;
+}
--- a/src/Platform/platformUtils.cc
+++ b/src/Platform/platformUtils.cc
@@ -0,0 +1,97 @@
+#include "platformUtils.h"
+
+using namespace torch;
+
+pair<vector<mdlp::labels_t>, map<string, int>> discretize(vector<mdlp::samples_t>& X, mdlp::labels_t& y, vector<string> features)
+{
+    vector<mdlp::labels_t> Xd;
+    map<string, int> maxes;
+    auto fimdlp = mdlp::CPPFImdlp();
+    for (int i = 0; i < X.size(); i++) {
+        fimdlp.fit(X[i], y);
+        mdlp::labels_t& xd = fimdlp.transform(X[i]);
+        maxes[features[i]] = *max_element(xd.begin(), xd.end()) + 1;
+        Xd.push_back(xd);
+    }
+    return { Xd, maxes };
+}
+
+vector<mdlp::labels_t> discretizeDataset(vector<mdlp::samples_t>& X, mdlp::labels_t& y)
+{
+    vector<mdlp::labels_t> Xd;
+    auto fimdlp = mdlp::CPPFImdlp();
+    for (int i = 0; i < X.size(); i++) {
+        fimdlp.fit(X[i], y);
+        mdlp::labels_t& xd = fimdlp.transform(X[i]);
+        Xd.push_back(xd);
+    }
+    return Xd;
+}
+
+bool file_exists(const std::string& name)
+{
+    if (FILE* file = fopen(name.c_str(), "r")) {
+        fclose(file);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+tuple<Tensor, Tensor, vector<string>, string, map<string, vector<int>>> loadDataset(const string& path, const string& name, bool class_last, bool discretize_dataset)
+{
+    auto handler = ArffFiles();
+    handler.load(path + static_cast<string>(name) + ".arff", class_last);
+    // Get Dataset X, y
+    vector<mdlp::samples_t>& X = handler.getX();
+    mdlp::labels_t& y = handler.getY();
+    // Get className & Features
+    auto className = handler.getClassName();
+    vector<string> features;
+    auto attributes = handler.getAttributes();
+    transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& f) { return f.first; });
+    Tensor Xd;
+    auto states = map<string, vector<int>>();
+    if (discretize_dataset) {
+        auto Xr = discretizeDataset(X, y);
+        Xd = torch::zeros({ static_cast<int>(Xr[0].size()), static_cast<int>(Xr.size()) }, torch::kInt32);
+        for (int i = 0; i < features.size(); ++i) {
+            states[features[i]] = vector<int>(*max_element(Xr[i].begin(), Xr[i].end()) + 1);
+            iota(begin(states[features[i]]), end(states[features[i]]), 0);
+            Xd.index_put_({ "...", i }, torch::tensor(Xr[i], torch::kInt32));
+        }
+        states[className] = vector<int>(*max_element(y.begin(), y.end()) + 1);
+        iota(begin(states[className]), end(states[className]), 0);
+    } else {
+        Xd = torch::zeros({ static_cast<int>(X[0].size()), static_cast<int>(X.size()) }, torch::kFloat32);
+        for (int i = 0; i < features.size(); ++i) {
+            Xd.index_put_({ "...", i }, torch::tensor(X[i]));
+        }
+    }
+    return { Xd, torch::tensor(y, torch::kInt32), features, className, states };
+}
+
+tuple<vector<vector<int>>, vector<int>, vector<string>, string, map<string, vector<int>>> loadFile(const string& name)
+{
+    auto handler = ArffFiles();
+    handler.load(PATH + static_cast<string>(name) + ".arff");
+    // Get Dataset X, y
+    vector<mdlp::samples_t>& X = handler.getX();
+    mdlp::labels_t& y = handler.getY();
+    // Get className & Features
+    auto className = handler.getClassName();
+    vector<string> features;
+    auto attributes = handler.getAttributes();
+    transform(attributes.begin(), attributes.end(), back_inserter(features), [](const auto& f) { return f.first; });
+    // Discretize Dataset
+    vector<mdlp::labels_t> Xd;
+    map<string, int> maxes;
+    tie(Xd, maxes) = discretize(X, y, features);
+    maxes[className] = *max_element(y.begin(), y.end()) + 1;
+    map<string, vector<int>> states;
+    for (auto feature : features) {
+        states[feature] = vector<int>(maxes[feature]);
+    }
+    states[className] = vector<int>(maxes[className]);
+    return { Xd, y, features, className, states };
+}
--- a/src/Platform/platformUtils.h
+++ b/src/Platform/platformUtils.h
@@ -0,0 +1,20 @@
+#ifndef PLATFORM_UTILS_H
+#define PLATFORM_UTILS_H
+#include <torch/torch.h>
+#include <string>
+#include <vector>
+#include <map>
+#include <tuple>
+#include "ArffFiles.h"
+#include "CPPFImdlp.h"
+using namespace std;
+const string PATH = "../../data/";
+
+bool file_exists(const std::string& name);
+pair<vector<mdlp::labels_t>, map<string, int>> discretize(vector<mdlp::samples_t>& X, mdlp::labels_t& y, vector<string> features);
+vector<mdlp::labels_t> discretizeDataset(vector<mdlp::samples_t>& X, mdlp::labels_t& y);
+// pair<torch::Tensor, map<string, vector<int>>> discretizeTorch(torch::Tensor& X, torch::Tensor& y, vector<string>& features, const string& className);
+tuple<vector<vector<int>>, vector<int>, vector<string>, string, map<string, vector<int>>> loadFile(const string& name);
+tuple<torch::Tensor, torch::Tensor, vector<string>, string, map<string, vector<int>>> loadDataset(const string& path, const string& name, bool class_last, bool discretize_dataset);
+map<string, vector<int>> get_states(vector<string>& features, string className, map<string, int>& maxes);
+#endif //PLATFORM_UTILS_H
--- a/tests/BayesModels.cc
+++ b/tests/BayesModels.cc
@@ -0,0 +1,88 @@
+#define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+#include <catch2/generators/catch_generators.hpp>
+#include <vector>
+#include <map>
+#include <string>
+#include "KDB.h"
+#include "TAN.h"
+#include "SPODE.h"
+#include "AODE.h"
+#include "platformUtils.h"
+
+TEST_CASE("Test Bayesian Classifiers score", "[BayesNet]")
+{
+    map <pair<string, string>, float> scores = {
+        {{"diabetes", "AODE"}, 0.811198}, {{"diabetes", "KDB"}, 0.852865}, {{"diabetes", "SPODE"}, 0.802083}, {{"diabetes", "TAN"}, 0.821615},
+        {{"ecoli", "AODE"}, 0.889881}, {{"ecoli", "KDB"}, 0.889881}, {{"ecoli", "SPODE"}, 0.880952}, {{"ecoli", "TAN"}, 0.892857},
+        {{"glass", "AODE"}, 0.78972}, {{"glass", "KDB"}, 0.827103}, {{"glass", "SPODE"}, 0.775701}, {{"glass", "TAN"}, 0.827103},
+        {{"iris", "AODE"}, 0.973333}, {{"iris", "KDB"}, 0.973333}, {{"iris", "SPODE"}, 0.973333}, {{"iris", "TAN"}, 0.973333}
+    };
+
+    string file_name = GENERATE("glass", "iris", "ecoli", "diabetes");
+    auto [Xd, y, features, className, states] = loadFile(file_name);
+
+    SECTION("Test TAN classifier (" + file_name + ")")
+    {
+        auto clf = bayesnet::TAN();
+        clf.fit(Xd, y, features, className, states);
+        auto score = clf.score(Xd, y);
+        //scores[{file_name, "TAN"}] = score;
+        REQUIRE(score == Catch::Approx(scores[{file_name, "TAN"}]).epsilon(1e-6));
+    }
+    SECTION("Test KDB classifier (" + file_name + ")")
+    {
+        auto clf = bayesnet::KDB(2);
+        clf.fit(Xd, y, features, className, states);
+        auto score = clf.score(Xd, y);
+        //scores[{file_name, "KDB"}] = score;
+        REQUIRE(score == Catch::Approx(scores[{file_name, "KDB"
+        }]).epsilon(1e-6));
+    }
+    SECTION("Test SPODE classifier (" + file_name + ")")
+    {
+        auto clf = bayesnet::SPODE(1);
+        clf.fit(Xd, y, features, className, states);
+        auto score = clf.score(Xd, y);
+        // scores[{file_name, "SPODE"}] = score;
+        REQUIRE(score == Catch::Approx(scores[{file_name, "SPODE"}]).epsilon(1e-6));
+    }
+    SECTION("Test AODE classifier (" + file_name + ")")
+    {
+        auto clf = bayesnet::AODE();
+        clf.fit(Xd, y, features, className, states);
+        auto score = clf.score(Xd, y);
+        // scores[{file_name, "AODE"}] = score;
+        REQUIRE(score == Catch::Approx(scores[{file_name, "AODE"}]).epsilon(1e-6));
+    }
+    // for (auto scores : scores) {
+    //     cout << "{{\"" << scores.first.first << "\", \"" << scores.first.second << "\"}, " << scores.second << "}, ";
+    // }
+}
+TEST_CASE("Models features")
+{
+    auto graph = vector<string>({ "digraph BayesNet {\nlabel=<BayesNet Test>\nfontsize=30\nfontcolor=blue\nlabelloc=t\nlayout=circo\n",
+        "class [shape=circle, fontcolor=red, fillcolor=lightblue, style=filled ] \n",
+        "class -> sepallength", "class -> sepalwidth", "class -> petallength", "class -> petalwidth", "petallength [shape=circle] \n",
+        "petallength -> sepallength", "petalwidth [shape=circle] \n", "sepallength [shape=circle] \n",
+        "sepallength -> sepalwidth", "sepalwidth [shape=circle] \n", "sepalwidth -> petalwidth", "}\n"
+        }
+    );
+
+    auto clf = bayesnet::TAN();
+    auto [Xd, y, features, className, states] = loadFile("iris");
+    clf.fit(Xd, y, features, className, states);
+    REQUIRE(clf.getNumberOfNodes() == 5);
+    REQUIRE(clf.getNumberOfEdges() == 7);
+    REQUIRE(clf.show() == vector<string>{"class -> sepallength, sepalwidth, petallength, petalwidth, ", "petallength -> sepallength, ", "petalwidth -> ", "sepallength -> sepalwidth, ", "sepalwidth -> petalwidth, "});
+    REQUIRE(clf.graph("Test") == graph);
+}
+TEST_CASE("Get num features & num edges")
+{
+    auto [Xd, y, features, className, states] = loadFile("iris");
+    auto clf = bayesnet::KDB(2);
+    clf.fit(Xd, y, features, className, states);
+    REQUIRE(clf.getNumberOfNodes() == 5);
+    REQUIRE(clf.getNumberOfEdges() == 8);
+}
--- a/tests/BayesNetwork.cc
+++ b/tests/BayesNetwork.cc
@@ -0,0 +1,41 @@
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+#include <catch2/generators/catch_generators.hpp>
+#include <string>
+#include "KDB.h"
+#include "platformUtils.h"
+
+TEST_CASE("Test Bayesian Network")
+{
+    auto [Xd, y, features, className, states] = loadFile("iris");
+
+    SECTION("Test Update Nodes")
+    {
+        auto net = bayesnet::Network();
+        net.addNode("A", 3);
+        REQUIRE(net.getStates() == 3);
+        net.addNode("A", 5);
+        REQUIRE(net.getStates() == 5);
+    }
+    SECTION("Test get features")
+    {
+        auto net = bayesnet::Network();
+        net.addNode("A", 3);
+        net.addNode("B", 5);
+        REQUIRE(net.getFeatures() == vector<string>{"A", "B"});
+        net.addNode("C", 2);
+        REQUIRE(net.getFeatures() == vector<string>{"A", "B", "C"});
+    }
+    SECTION("Test get edges")
+    {
+        auto net = bayesnet::Network();
+        net.addNode("A", 3);
+        net.addNode("B", 5);
+        net.addNode("C", 2);
+        net.addEdge("A", "B");
+        net.addEdge("B", "C");
+        REQUIRE(net.getEdges() == vector<pair<string, string>>{ {"A", "B"}, { "B", "C" } });
+        net.addEdge("A", "C");
+        REQUIRE(net.getEdges() == vector<pair<string, string>>{ {"A", "B"}, { "A", "C" }, { "B", "C" } });
+    }
+}
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,16 +1,11 @@
 if(ENABLE_TESTING)
-    set(TEST_BAYESNET "unit_tests_bayesnet")
-    include_directories(
-        ${BayesNet_SOURCE_DIR}/src/BayesNet
-        ${BayesNet_SOURCE_DIR}/src/Platform
-        ${BayesNet_SOURCE_DIR}/lib/Files
-        ${BayesNet_SOURCE_DIR}/lib/mdlp
-        ${BayesNet_SOURCE_DIR}/lib/folding
-        ${BayesNet_SOURCE_DIR}/lib/json/include
-        ${CMAKE_BINARY_DIR}/configured_files/include
-    )
-    set(TEST_SOURCES_BAYESNET TestBayesModels.cc TestBayesNetwork.cc TestBayesMetrics.cc TestUtils.cc ${BayesNet_SOURCES})
-    add_executable(${TEST_BAYESNET} ${TEST_SOURCES_BAYESNET})
-    target_link_libraries(${TEST_BAYESNET} PUBLIC "${TORCH_LIBRARIES}" ArffFiles mdlp Catch2::Catch2WithMain)
-    add_test(NAME ${TEST_BAYESNET} COMMAND ${TEST_BAYESNET})
+    set(TEST_MAIN "unit_tests")
+    include_directories(${BayesNet_SOURCE_DIR}/src/BayesNet)
+    include_directories(${BayesNet_SOURCE_DIR}/src/Platform)
+    include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
+    include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
+    set(TEST_SOURCES BayesModels.cc BayesNetwork.cc ${BayesNet_SOURCE_DIR}/src/Platform/platformUtils.cc ${BayesNet_SOURCES})
+    add_executable(${TEST_MAIN} ${TEST_SOURCES})
+    target_link_libraries(${TEST_MAIN} PUBLIC "${TORCH_LIBRARIES}" ArffFiles mdlp Catch2::Catch2WithMain)
+    add_test(NAME ${TEST_MAIN} COMMAND ${TEST_MAIN})
 endif(ENABLE_TESTING)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ricardo Montañana	d8764db716	Fix linter warnings	2023-07-29 01:16:19 +02:00
Ricardo Montañana	8049df436c	Add Models class	2023-07-28 12:11:52 +02:00
Ricardo Montañana	b420ad2bc2	Add dotenv and possible multiple seeds	2023-07-28 00:53:16 +02:00