Compile TANNew with poor accuracy

.vscode/launch.json

@@ -10,12 +10,13 @@
                 "-d",
                 "iris",
                 "-m",
-                "TAN",
+                "KDB",
+                "-s",
+                "271",
                 "-p",
-                "../../data/",
-                "--tensors"
+                "/Users/rmontanana/Code/discretizbench/datasets/",
             ],
-            "cwd": "${workspaceFolder}/build/sample/",
+            //"cwd": "${workspaceFolder}/build/sample/",
         },
         {
             "type": "lldb",
@@ -24,15 +25,12 @@
             "program": "${workspaceFolder}/build/src/Platform/main",
             "args": [
                 "-m",
-                "TAN",
+                "TANNew",
                 "-p",
                 "/Users/rmontanana/Code/discretizbench/datasets",
-                "--discretize",
                 "--stratified",
-                "--title",
-                "Debug test",
                 "-d",
-                "ionosphere"
+                "iris"
             ],
             "cwd": "${workspaceFolder}/build/src/Platform",
         },

CMakeLists.txt

@@ -7,10 +7,14 @@ project(BayesNet
   LANGUAGES CXX
 )
 
+if (CODE_COVERAGE AND NOT ENABLE_TESTING)
+  MESSAGE(FATAL_ERROR "Code coverage requires testing enabled")
+endif (CODE_COVERAGE AND NOT ENABLE_TESTING)
+
 find_package(Torch REQUIRED)
 
 if (POLICY CMP0135)
-    cmake_policy(SET CMP0135 NEW)
+  cmake_policy(SET CMP0135 NEW)
 endif ()
 
 # Global CMake variables
@@ -24,24 +28,31 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")
 # Options
 # -------
 option(ENABLE_CLANG_TIDY "Enable to add clang tidy."              OFF)
-option(ENABLE_TESTING "Unit testing build"                        ON)
-option(CODE_COVERAGE "Collect coverage from test library"         ON)
-
-set(CMAKE_BUILD_TYPE "Debug")
+option(ENABLE_TESTING "Unit testing build"                        OFF)
+option(CODE_COVERAGE "Collect coverage from test library"         OFF)
 
 # CMakes modules
 # --------------
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 
 include(AddGitSubmodule)
-include(StaticAnalyzers) # clang-tidy
-include(CodeCoverage)
+if (CODE_COVERAGE)
+    enable_testing()
+    include(CodeCoverage)
+    MESSAGE("Code coverage enabled")
+    set(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
+    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+    SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
+endif (CODE_COVERAGE)
+
+if (ENABLE_CLANG_TIDY)
+  include(StaticAnalyzers) # clang-tidy
+endif (ENABLE_CLANG_TIDY)
 
 # External libraries - dependencies of BayesNet
 # ---------------------------------------------
 # include(FetchContent)
 add_git_submodule("lib/mdlp")
-add_git_submodule("lib/catch2")
 add_git_submodule("lib/argparse")
 add_git_submodule("lib/json")
 
@@ -59,18 +70,11 @@ file(GLOB Platform_SOURCES CONFIGURE_DEPENDS ${BayesNet_SOURCE_DIR}/src/Platform
 
 # Testing
 # -------
+
 if (ENABLE_TESTING)
   MESSAGE("Testing enabled")
-  enable_testing()
-  if (CODE_COVERAGE)
-    #include(CodeCoverage)
-    MESSAGE("Code coverage enabled")
-    set(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
-    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
-    SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
-  endif (CODE_COVERAGE)
-  #find_package(Catch2 3 REQUIRED)
+  add_git_submodule("lib/catch2")
+  
   include(CTest)
-  #include(Catch)
   add_subdirectory(tests)
 endif (ENABLE_TESTING)

Makefile

@@ -14,16 +14,22 @@ setup: ## Install dependencies for tests and coverage
 dependency: ## Create a dependency graph diagram of the project (build/dependency.png)
 	cd build && cmake .. --graphviz=dependency.dot && dot -Tpng dependency.dot -o dependency.png
 
-build: ## Build the project
-	@echo ">>> Building BayesNet ...";
+debug: ## Build a debug version of the project
+	@echo ">>> Building Debug BayesNet ...";
 	@if [ -d ./build ]; then rm -rf ./build; fi
 	@mkdir build; 
-	cmake -S . -B build; \
-	cd build; \
-	make; \
-	
+	cmake -S . -B build -D CMAKE_BUILD_TYPE=Debug -D ENABLE_TESTING=ON -D CODE_COVERAGE=ON; \
+	cmake --build build -j 32;
 	@echo ">>> Done";
 
+release: ## Build a Release version of the project
+	@echo ">>> Building Release BayesNet ...";
+	@if [ -d ./build ]; then rm -rf ./build; fi
+	@mkdir build; 
+	cmake -S . -B build -D CMAKE_BUILD_TYPE=Release; \
+	cmake --build build -t main -t BayesNetSample -j 32;
+	@echo ">>> Done";	
+
 test: ## Run tests
 	@echo "* Running tests...";
 	find . -name "*.gcda" -print0 | xargs -0 rm

TAN_iris.dot

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

gcovr.cfg

@@ -1,5 +1,4 @@
 filter = src/
-exclude = external/
-exclude = tests/
+exclude-directories = build/lib/
 print-summary = yes
 sort-percentage = yes

sample/sample.cc

@@ -1,7 +1,6 @@
 #include <iostream>
 #include <torch/torch.h>
 #include <string>
-#include <thread>
 #include <map>
 #include <argparse/argparse.hpp>
 #include "ArffFiles.h"
@@ -42,7 +41,7 @@ bool file_exists(const std::string& name)
 }
 pair<vector<vector<int>>, vector<int>> extract_indices(vector<int> indices, vector<vector<int>> X, vector<int> y)
 {
-    vector<vector<int>> Xr;
+    vector<vector<int>> Xr; // nxm
     vector<int> yr;
     for (int col = 0; col < X.size(); ++col) {
         Xr.push_back(vector<int>());
@@ -96,6 +95,7 @@ int main(int argc, char** argv)
             }
     );
     program.add_argument("--discretize").help("Discretize input dataset").default_value(false).implicit_value(true);
+    program.add_argument("--dumpcpt").help("Dump CPT Tables").default_value(false).implicit_value(true);
     program.add_argument("--stratified").help("If Stratified KFold is to be done").default_value(false).implicit_value(true);
     program.add_argument("--tensors").help("Use tensors to store samples").default_value(false).implicit_value(true);
     program.add_argument("-f", "--folds").help("Number of folds").default_value(5).scan<'i', int>().action([](const string& value) {
@@ -113,7 +113,7 @@ int main(int argc, char** argv)
             throw runtime_error("Number of folds must be an integer");
         }});
     program.add_argument("-s", "--seed").help("Random seed").default_value(-1).scan<'i', int>();
-    bool class_last, stratified, tensors;
+    bool class_last, stratified, tensors, dump_cpt;
     string model_name, file_name, path, complete_file_name;
     int nFolds, seed;
     try {
@@ -126,6 +126,7 @@ int main(int argc, char** argv)
         tensors = program.get<bool>("tensors");
         nFolds = program.get<int>("folds");
         seed = program.get<int>("seed");
+        dump_cpt = program.get<bool>("dumpcpt");
         class_last = datasets[file_name];
         if (!file_exists(complete_file_name)) {
             throw runtime_error("Data File " + path + file_name + ".arff" + " does not exist");
@@ -161,13 +162,23 @@ int main(int argc, char** argv)
     states[className] = vector<int>(maxes[className]);
     auto clf = platform::Models::instance()->create(model_name);
     clf->fit(Xd, y, features, className, states);
-    auto score = clf->score(Xd, y);
+    if (dump_cpt) {
+        cout << "--- CPT Tables ---" << endl;
+        clf->dump_cpt();
+    }
     auto lines = clf->show();
-    auto graph = clf->graph();
     for (auto line : lines) {
         cout << line << endl;
     }
+    cout << "--- Topological Order ---" << endl;
+    auto order = clf->topological_order();
+    for (auto name : order) {
+        cout << name << ", ";
+    }
+    cout << "end." << endl;
+    auto score = clf->score(Xd, y);
     cout << "Score: " << score << endl;
+    auto graph = clf->graph();
     auto dot_file = model_name + "_" + file_name;
     ofstream file(dot_file + ".dot");
     file << graph;
@@ -199,15 +210,21 @@ int main(int argc, char** argv)
             torch::Tensor Xtestt = torch::index_select(Xt, 1, ttest);
             torch::Tensor ytestt = yt.index({ ttest });
             clf->fit(Xtraint, ytraint, features, className, states);
+            auto temp = clf->predict(Xtraint);
             score_train = clf->score(Xtraint, ytraint);
             score_test = clf->score(Xtestt, ytestt);
         } else {
             auto [Xtrain, ytrain] = extract_indices(train, Xd, y);
             auto [Xtest, ytest] = extract_indices(test, Xd, y);
             clf->fit(Xtrain, ytrain, features, className, states);
+
             score_train = clf->score(Xtrain, ytrain);
             score_test = clf->score(Xtest, ytest);
         }
+        if (dump_cpt) {
+            cout << "--- CPT Tables ---" << endl;
+            clf->dump_cpt();
+        }
         total_score_train += score_train;
         total_score += score_test;
         cout << "Score Train: " << score_train << endl;

src/BayesNet/AODE.cc

@@ -9,7 +9,7 @@ namespace bayesnet {
             models.push_back(std::make_unique<SPODE>(i));
         }
     }
-    vector<string> AODE::graph(string title)
+    vector<string> AODE::graph(const string& title)
     {
         return Ensemble::graph(title);
     }

src/BayesNet/AODE.h

@@ -9,7 +9,7 @@ namespace bayesnet {
     public:
         AODE();
         virtual ~AODE() {};
-        vector<string> graph(string title = "AODE") override;
+        vector<string> graph(const string& title = "AODE") override;
     };
 }
 #endif

src/BayesNet/BaseClassifier.h

@@ -6,8 +6,11 @@ namespace bayesnet {
     using namespace std;
     class BaseClassifier {
     public:
+        // X is nxm vector, y is nx1 vector
         virtual BaseClassifier& fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states) = 0;
+        // X is nxm tensor, y is nx1 tensor
         virtual BaseClassifier& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) = 0;
+        torch::Tensor virtual predict(torch::Tensor& X) = 0;
         vector<int> virtual predict(vector<vector<int>>& X) = 0;
         float virtual score(vector<vector<int>>& X, vector<int>& y) = 0;
         float virtual score(torch::Tensor& X, torch::Tensor& y) = 0;
@@ -15,9 +18,11 @@ namespace bayesnet {
         int virtual getNumberOfEdges() = 0;
         int virtual getNumberOfStates() = 0;
         vector<string> virtual show() = 0;
-        vector<string> virtual graph(string title = "") = 0;
+        vector<string> virtual graph(const string& title = "") = 0;
         virtual ~BaseClassifier() = default;
         const string inline getVersion() const { return "0.1.0"; };
+        vector<string> virtual topological_order() = 0;
+        void virtual dump_cpt() = 0;
     };
 }
 #endif

src/BayesNet/BayesMetrics.cc

@@ -1,6 +1,7 @@
 #include "BayesMetrics.h"
 #include "Mst.h"
 namespace bayesnet {
+    //samples is nxm tensor used to fit the model
     Metrics::Metrics(torch::Tensor& samples, vector<string>& features, string& className, int classNumStates)
         : samples(samples)
         , features(features)
@@ -8,6 +9,7 @@ namespace bayesnet {
         , classNumStates(classNumStates)
     {
     }
+    //samples is nxm vector used to fit the model
     Metrics::Metrics(const vector<vector<int>>& vsamples, const vector<int>& labels, const vector<string>& features, const string& className, const int classNumStates)
         : features(features)
         , className(className)
@@ -15,9 +17,9 @@ namespace bayesnet {
         , samples(torch::zeros({ static_cast<int>(vsamples[0].size()), static_cast<int>(vsamples.size() + 1) }, torch::kInt32))
     {
         for (int i = 0; i < vsamples.size(); ++i) {
-            samples.index_put_({ "...", i }, torch::tensor(vsamples[i], torch::kInt32));
+            samples.index_put_({ i,  "..." }, torch::tensor(vsamples[i], torch::kInt32));
         }
-        samples.index_put_({ "...", -1 }, torch::tensor(labels, torch::kInt32));
+        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
     }
     vector<pair<string, string>> Metrics::doCombinations(const vector<string>& source)
     {
@@ -39,17 +41,17 @@ namespace bayesnet {
         // Compute class prior
         auto margin = torch::zeros({ classNumStates });
         for (int value = 0; value < classNumStates; ++value) {
-            auto mask = samples.index({ "...", -1 }) == value;
-            margin[value] = mask.sum().item<float>() / samples.sizes()[0];
+            auto mask = samples.index({ -1,  "..." }) == value;
+            margin[value] = mask.sum().item<float>() / samples.size(1);
         }
         for (auto [first, second] : combinations) {
             int index_first = find(features.begin(), features.end(), first) - features.begin();
             int index_second = find(features.begin(), features.end(), second) - features.begin();
             double accumulated = 0;
             for (int value = 0; value < classNumStates; ++value) {
-                auto mask = samples.index({ "...", -1 }) == value;
-                auto first_dataset = samples.index({ mask, index_first });
-                auto second_dataset = samples.index({ mask, index_second });
+                auto mask = samples.index({ -1, "..." }) == value;
+                auto first_dataset = samples.index({ index_first, mask });
+                auto second_dataset = samples.index({ index_second, mask });
                 auto mi = mutualInformation(first_dataset, second_dataset);
                 auto pb = margin[value].item<float>();
                 accumulated += pb * mi;
@@ -67,6 +69,7 @@ namespace bayesnet {
         }
         return matrix;
     }
+    // To use in Python
     vector<float> Metrics::conditionalEdgeWeights()
     {
         auto matrix = conditionalEdge();

src/BayesNet/BayesMetrics.h

@@ -8,7 +8,7 @@ namespace bayesnet {
     using namespace torch;
     class Metrics {
     private:
-        Tensor samples;
+        Tensor samples; // nxm tensor used to fit the model
         vector<string> features;
         string className;
         int classNumStates = 0;
@@ -19,7 +19,7 @@ namespace bayesnet {
         double entropy(Tensor&);
         double conditionalEntropy(Tensor&, Tensor&);
         double mutualInformation(Tensor&, Tensor&);
-        vector<float> conditionalEdgeWeights();
+        vector<float> conditionalEdgeWeights(); // To use in Python
         Tensor conditionalEdge();
         vector<pair<string, string>> doCombinations(const vector<string>&);
         vector<pair<int, int>> maximumSpanningTree(vector<string> features, Tensor& weights, int root);

src/BayesNet/CMakeLists.txt

@@ -1,2 +1,4 @@
-add_library(BayesNet bayesnetUtils.cc Network.cc Node.cc BayesMetrics.cc Classifier.cc KDB.cc TAN.cc SPODE.cc Ensemble.cc AODE.cc Mst.cc)
-target_link_libraries(BayesNet "${TORCH_LIBRARIES}")
+include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
+include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
+add_library(BayesNet bayesnetUtils.cc Network.cc Node.cc BayesMetrics.cc Classifier.cc KDB.cc TAN.cc SPODE.cc Ensemble.cc AODE.cc TANNew.cc Mst.cc)
+target_link_libraries(BayesNet mdlp ArffFiles "${TORCH_LIBRARIES}")

src/BayesNet/Classifier.cc

@@ -1,5 +1,6 @@
 #include "Classifier.h"
 #include "bayesnetUtils.h"
+#include "ArffFiles.h"
 
 namespace bayesnet {
     using namespace torch;
@@ -7,15 +8,17 @@ namespace bayesnet {
     Classifier::Classifier(Network model) : model(model), m(0), n(0), metrics(Metrics()), fitted(false) {}
     Classifier& Classifier::build(vector<string>& features, string className, map<string, vector<int>>& states)
     {
-        dataset = torch::cat({ X, y.view({y.size(0), 1}) }, 1);
+        Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1);
+        samples = torch::cat({ X, ytmp }, 0);
         this->features = features;
         this->className = className;
         this->states = states;
         checkFitParameters();
         auto n_classes = states[className].size();
-        metrics = Metrics(dataset, features, className, n_classes);
+        metrics = Metrics(samples, features, className, n_classes);
+        model.initialize();
         train();
-        if (Xv == vector<vector<int>>()) {
+        if (Xv.empty()) {
             // fit with tensors
             model.fit(X, y, features, className);
         } else {
@@ -25,21 +28,23 @@ namespace bayesnet {
         fitted = true;
         return *this;
     }
+    // X is nxm where n is the number of features and m the number of samples
     Classifier& Classifier::fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states)
     {
-        this->X = torch::transpose(X, 0, 1);
+        this->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);
     }
-
+    // X is nxm where n is the number of features and m the number of samples
     Classifier& Classifier::fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states)
     {
-        this->X = torch::zeros({ static_cast<int>(X[0].size()), static_cast<int>(X.size()) }, kInt32);
+
+        this->X = torch::zeros({ static_cast<int>(X.size()), static_cast<int>(X[0].size()) }, kInt32);
         Xv = X;
         for (int i = 0; i < X.size(); ++i) {
-            this->X.index_put_({ "...", i }, torch::tensor(X[i], kInt32));
+            this->X.index_put_({ i, "..." }, torch::tensor(X[i], kInt32));
         }
         this->y = torch::tensor(y, kInt32);
         yv = y;
@@ -48,8 +53,8 @@ namespace bayesnet {
     void Classifier::checkFitParameters()
     {
         auto sizes = X.sizes();
-        m = sizes[0];
-        n = sizes[1];
+        m = sizes[1];
+        n = sizes[0];
         if (m != y.size(0)) {
             throw invalid_argument("X and y must have the same number of samples");
         }
@@ -65,23 +70,12 @@ namespace bayesnet {
             }
         }
     }
-
     Tensor Classifier::predict(Tensor& X)
     {
         if (!fitted) {
             throw logic_error("Classifier has not been fitted");
         }
-        auto m_ = X.size(0);
-        auto n_ = X.size(1);
-        //auto Xt = torch::transpose(X, 0, 1);
-        vector<vector<int>> Xd(n_, vector<int>(m_, 0));
-        for (auto i = 0; i < n_; i++) {
-            auto temp = X.index({ "...", i });
-            Xd[i] = vector<int>(temp.data_ptr<int>(), temp.data_ptr<int>() + temp.numel());
-        }
-        auto yp = model.predict(Xd);
-        auto ypred = torch::tensor(yp, torch::kInt32);
-        return ypred;
+        return model.predict(X);
     }
     vector<int> Classifier::predict(vector<vector<int>>& X)
     {
@@ -102,8 +96,7 @@ namespace bayesnet {
         if (!fitted) {
             throw logic_error("Classifier has not been fitted");
         }
-        auto Xt = torch::transpose(X, 0, 1);
-        Tensor y_pred = predict(Xt);
+        Tensor y_pred = predict(X);
         return (y_pred == y).sum().item<float>() / y.size(0);
     }
     float Classifier::score(vector<vector<int>>& X, vector<int>& y)
@@ -111,13 +104,7 @@ namespace bayesnet {
         if (!fitted) {
             throw logic_error("Classifier has not been fitted");
         }
-        auto m_ = X[0].size();
-        auto n_ = X.size();
-        vector<vector<int>> Xd(n_, vector<int>(m_, 0));
-        for (auto i = 0; i < n_; i++) {
-            Xd[i] = vector<int>(X[i].begin(), X[i].end());
-        }
-        return model.score(Xd, y);
+        return model.score(X, y);
     }
     vector<string> Classifier::show()
     {
@@ -126,10 +113,12 @@ namespace bayesnet {
     void Classifier::addNodes()
     {
         // Add all nodes to the network
-        for (auto feature : features) {
+        for (const auto& feature : features) {
             model.addNode(feature, states[feature].size());
+            cout << "-Adding node " << feature << " with " << states[feature].size() << " states" << endl;
         }
         model.addNode(className, states[className].size());
+        cout << "*Adding class " << className << " with " << states[className].size() << " states" << endl;
     }
     int Classifier::getNumberOfNodes()
     {
@@ -144,4 +133,65 @@ namespace bayesnet {
     {
         return fitted ? model.getStates() : 0;
     }
+    vector<string> Classifier::topological_order()
+    {
+        return model.topological_sort();
+    }
+    void Classifier::dump_cpt()
+    {
+        model.dump_cpt();
+    }
+    void Classifier::localDiscretizationProposal(map<string, mdlp::CPPFImdlp*>& discretizers, Tensor& Xf)
+    {
+        // order of local discretization is important. no good 0, 1, 2...
+        auto order = model.topological_sort();
+        auto& nodes = model.getNodes();
+        vector<int> indicesToReDiscretize;
+        auto n_samples = Xf.size(1);
+        bool upgrade = false; // Flag to check if we need to upgrade the model
+        for (auto feature : order) {
+            auto nodeParents = nodes[feature]->getParents();
+            int index = find(features.begin(), features.end(), feature) - features.begin();
+            vector<string> parents;
+            transform(nodeParents.begin(), nodeParents.end(), back_inserter(parents), [](const auto& p) {return p->getName(); });
+            if (parents.size() == 1) continue; // Only has class as parent
+            upgrade = true;
+            // Remove class as parent as it will be added later
+            parents.erase(remove(parents.begin(), parents.end(), className), parents.end());
+            // Get the indices of the parents
+            vector<int> indices;
+            transform(parents.begin(), parents.end(), back_inserter(indices), [&](const auto& p) {return find(features.begin(), features.end(), p) - features.begin(); });
+            // Now we fit the discretizer of the feature conditioned on its parents and the class i.e. discretizer.fit(X[index], X[indices] + y)
+            vector<string> yJoinParents;
+            transform(yv.begin(), yv.end(), back_inserter(yJoinParents), [&](const auto& p) {return to_string(p); });
+            for (auto idx : indices) {
+                for (int i = 0; i < n_samples; ++i) {
+                    yJoinParents[i] += to_string(Xv[idx][i]);
+                }
+            }
+            auto arff = ArffFiles();
+            auto yxv = arff.factorize(yJoinParents);
+            auto xvf_ptr = Xf.index({ index }).data_ptr<float>();
+            auto xvf = vector<mdlp::precision_t>(xvf_ptr, xvf_ptr + Xf.size(1));
+            discretizers[feature]->fit(xvf, yxv);
+            indicesToReDiscretize.push_back(index);
+        }
+        if (upgrade) {
+            // Discretize again X (only the affected indices) with the new fitted discretizers
+            for (auto index : indicesToReDiscretize) {
+                auto Xt_ptr = Xf.index({ index }).data_ptr<float>();
+                auto Xt = vector<float>(Xt_ptr, Xt_ptr + Xf.size(1));
+                Xv[index] = discretizers[features[index]]->transform(Xt);
+                auto xStates = vector<int>(discretizers[features[index]]->getCutPoints().size() + 1);
+                iota(xStates.begin(), xStates.end(), 0);
+                states[features[index]] = xStates;
+            }
+            // Now we fit the model again with the new values
+            cout << "Classifier: Upgrading model" << endl;
+            // To update the nodes states
+            addNodes();
+            model.fit(Xv, yv, features, className);
+            cout << "Classifier: Model upgraded" << endl;
+        }
+    }
 }

src/BayesNet/Classifier.h

@@ -4,6 +4,7 @@
 #include "BaseClassifier.h"
 #include "Network.h"
 #include "BayesMetrics.h"
+#include "CPPFImdlp.h"
 using namespace std;
 using namespace torch;
 
@@ -15,17 +16,18 @@ namespace bayesnet {
     protected:
         Network model;
         int m, n; // m: number of samples, n: number of features
-        Tensor X;
-        vector<vector<int>> Xv;
+        Tensor X; // nxm tensor
+        vector<vector<int>> Xv; // nxm vector
         Tensor y;
         vector<int> yv;
-        Tensor dataset;
+        Tensor samples; // (n+1)xm tensor
         Metrics metrics;
         vector<string> features;
         string className;
         map<string, vector<int>> states;
         void checkFitParameters();
         virtual void train() = 0;
+        void localDiscretizationProposal(map<string, mdlp::CPPFImdlp*>& discretizers, Tensor& Xf);
     public:
         Classifier(Network model);
         virtual ~Classifier() = default;
@@ -35,11 +37,13 @@ namespace bayesnet {
         int getNumberOfNodes() override;
         int getNumberOfEdges() override;
         int getNumberOfStates() override;
-        Tensor predict(Tensor& X);
+        Tensor predict(Tensor& X) override;
         vector<int> predict(vector<vector<int>>& X) override;
         float score(Tensor& X, Tensor& y) override;
         float score(vector<vector<int>>& X, vector<int>& y) override;
         vector<string> show() override;
+        vector<string> topological_order() override;
+        void dump_cpt() override;
     };
 }
 #endif

src/BayesNet/Ensemble.cc

@@ -16,15 +16,22 @@ namespace bayesnet {
         train();
         // Train models
         n_models = models.size();
+        auto Xt = torch::transpose(X, 0, 1);
         for (auto i = 0; i < n_models; ++i) {
-            models[i]->fit(Xv, yv, features, className, states);
+            if (Xv == vector<vector<int>>()) {
+                // fit with tensors
+                models[i]->fit(Xt, y, features, className, states);
+            } else {
+                // fit with vectors
+                models[i]->fit(Xv, yv, features, className, states);
+            }
         }
         fitted = true;
         return *this;
     }
     Ensemble& Ensemble::fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states)
     {
-        this->X = X;
+        this->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));
@@ -41,17 +48,6 @@ namespace bayesnet {
         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>();
@@ -66,6 +62,28 @@ namespace bayesnet {
         }
         return y_pred_final;
     }
+    Tensor Ensemble::predict(Tensor& X)
+    {
+        if (!fitted) {
+            throw logic_error("Ensemble has not been fitted");
+        }
+        Tensor y_pred = torch::zeros({ X.size(1), n_models }, kInt32);
+        //Create a threadpool
+        auto threads{ vector<thread>() };
+        auto lock = mutex();
+        for (auto i = 0; i < n_models; ++i) {
+            threads.push_back(thread([&, i]() {
+                auto ypredict = models[i]->predict(X);
+                lock.lock();
+                y_pred.index_put_({ "...", i }, ypredict);
+                lock.unlock();
+                }));
+        }
+        for (auto& thread : threads) {
+            thread.join();
+        }
+        return torch::tensor(voting(y_pred));
+    }
     vector<int> Ensemble::predict(vector<vector<int>>& X)
     {
         if (!fitted) {
@@ -121,7 +139,7 @@ namespace bayesnet {
         }
         return result;
     }
-    vector<string> Ensemble::graph(string title)
+    vector<string> Ensemble::graph(const string& title)
     {
         auto result = vector<string>();
         for (auto i = 0; i < n_models; ++i) {

src/BayesNet/Ensemble.h

@@ -32,7 +32,7 @@ namespace bayesnet {
         virtual ~Ensemble() = default;
         Ensemble& fit(vector<vector<int>>& X, vector<int>& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
         Ensemble& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
-        Tensor predict(Tensor& X);
+        Tensor predict(Tensor& X) override;
         vector<int> predict(vector<vector<int>>& X) override;
         float score(Tensor& X, Tensor& y) override;
         float score(vector<vector<int>>& X, vector<int>& y) override;
@@ -40,7 +40,14 @@ namespace bayesnet {
         int getNumberOfEdges() override;
         int getNumberOfStates() override;
         vector<string> show() override;
-        vector<string> graph(string title) override;
+        vector<string> graph(const string& title) override;
+        vector<string> topological_order() override
+        {
+            return vector<string>();
+        }
+        void dump_cpt() override
+        {
+        }
     };
 }
 #endif

src/BayesNet/KDB.cc

@@ -27,9 +27,10 @@ namespace bayesnet {
         */
         // 1. For each feature Xi, compute mutual information, I(X;C),
         // where C is the class.
+        addNodes();
         vector <float> mi;
         for (auto i = 0; i < features.size(); i++) {
-            Tensor firstFeature = X.index({ "...", i });
+            Tensor firstFeature = X.index({ i, "..." });
             mi.push_back(metrics.mutualInformation(firstFeature, y));
         }
         // 2. Compute class conditional mutual information I(Xi;XjIC), f or each
@@ -38,14 +39,12 @@ namespace bayesnet {
         vector<int> S;
         // 4. Let the DAG network being constructed, BN, begin with a single
         // class node, C.
-        model.addNode(className, states[className].size());
         // 5. Repeat until S includes all domain features
         // 5.1. Select feature Xmax which is not in S and has the largest value
         // I(Xmax;C).
         auto order = argsort(mi);
         for (auto idx : order) {
             // 5.2. Add a node to BN representing Xmax.
-            model.addNode(features[idx], states[features[idx]].size());
             // 5.3. Add an arc from C to Xmax in BN.
             model.addEdge(className, features[idx]);
             // 5.4. Add m = min(lSl,/c) arcs from m distinct features Xj in S with
@@ -79,11 +78,12 @@ namespace bayesnet {
             exit_cond = num == n_edges || candidates.size(0) == 0;
         }
     }
-    vector<string> KDB::graph(string title)
+    vector<string> KDB::graph(const string& title)
     {
+        string header{ title };
         if (title == "KDB") {
-            title += " (k=" + to_string(k) + ", theta=" + to_string(theta) + ")";
+            header += " (k=" + to_string(k) + ", theta=" + to_string(theta) + ")";
         }
-        return model.graph(title);
+        return model.graph(header);
     }
 }

src/BayesNet/KDB.h

@@ -15,7 +15,7 @@ namespace bayesnet {
     public:
         explicit KDB(int k, float theta = 0.03);
         virtual ~KDB() {};
-        vector<string> graph(string name = "KDB") override;
+        vector<string> graph(const string& name = "KDB") override;
     };
 }
 #endif

src/BayesNet/Network.cc

@@ -3,15 +3,26 @@
 #include "Network.h"
 #include "bayesnetUtils.h"
 namespace bayesnet {
-    Network::Network() : laplaceSmoothing(1), features(vector<string>()), className(""), classNumStates(0), maxThreads(0.8), fitted(false) {}
-    Network::Network(float maxT) : laplaceSmoothing(1), features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
+    Network::Network() : features(vector<string>()), className(""), classNumStates(0), fitted(false) {}
+    Network::Network(float maxT) : features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
     Network::Network(float maxT, int smoothing) : laplaceSmoothing(smoothing), features(vector<string>()), className(""), classNumStates(0), maxThreads(maxT), fitted(false) {}
-    Network::Network(Network& other) : laplaceSmoothing(other.laplaceSmoothing), features(other.features), className(other.className), classNumStates(other.getClassNumStates()), maxThreads(other.getmaxThreads()), fitted(other.fitted)
+    Network::Network(Network& other) : laplaceSmoothing(other.laplaceSmoothing), features(other.features), className(other.className), classNumStates(other.getClassNumStates()), maxThreads(other.
+        getmaxThreads()), fitted(other.fitted)
     {
         for (const auto& pair : other.nodes) {
             nodes[pair.first] = std::make_unique<Node>(*pair.second);
         }
     }
+    void Network::initialize()
+    {
+        features = vector<string>();
+        className = "";
+        classNumStates = 0;
+        fitted = false;
+        nodes.clear();
+        dataset.clear();
+        samples = torch::Tensor();
+    }
     float Network::getmaxThreads()
     {
         return maxThreads;
@@ -22,6 +33,9 @@ namespace bayesnet {
     }
     void Network::addNode(const string& name, int numStates)
     {
+        if (name == "") {
+            throw invalid_argument("Node name cannot be empty");
+        }
         if (find(features.begin(), features.end(), name) == features.end()) {
             features.push_back(name);
         }
@@ -94,45 +108,63 @@ namespace bayesnet {
     {
         return nodes;
     }
+    void Network::checkFitData(int n_samples, int n_features, int n_samples_y, const vector<string>& featureNames, const string& className)
+    {
+        if (n_samples != n_samples_y) {
+            throw invalid_argument("X and y must have the same number of samples in Network::fit (" + to_string(n_samples) + " != " + to_string(n_samples_y) + ")");
+        }
+        if (n_features != featureNames.size()) {
+            throw invalid_argument("X and features must have the same number of features in Network::fit (" + to_string(n_features) + " != " + to_string(featureNames.size()) + ")");
+        }
+        if (n_features != features.size() - 1) {
+            throw invalid_argument("X and local features must have the same number of features in Network::fit (" + to_string(n_features) + " != " + to_string(features.size() - 1) + ")");
+        }
+        if (find(features.begin(), features.end(), className) == features.end()) {
+            throw invalid_argument("className not found in Network::features");
+        }
+        for (auto& feature : featureNames) {
+            if (find(features.begin(), features.end(), feature) == features.end()) {
+                throw invalid_argument("Feature " + feature + " not found in Network::features");
+            }
+        }
+    }
+    // X comes in nxm, where n is the number of features and m the number of samples
     void Network::fit(torch::Tensor& X, torch::Tensor& y, const vector<string>& featureNames, const string& className)
     {
-        features = featureNames;
+        checkFitData(X.size(1), X.size(0), y.size(0), featureNames, className);
         this->className = className;
         dataset.clear();
         // Specific part
         classNumStates = torch::max(y).item<int>() + 1;
-        samples = torch::cat({ X, y.view({ y.size(0), 1 }) }, 1);
+        Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1);
+        samples = torch::cat({ X , ytmp }, 0);
         for (int i = 0; i < featureNames.size(); ++i) {
-            auto 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;
+            auto row_feature = X.index({ i, "..." });
+            dataset[featureNames[i]] = vector<int>(row_feature.data_ptr<int>(), row_feature.data_ptr<int>() + row_feature.size(0));;
         }
         dataset[className] = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
         completeFit();
     }
+    // input_data comes in nxm, where n is the number of features and m the number of samples
     void Network::fit(const vector<vector<int>>& input_data, const vector<int>& labels, const vector<string>& featureNames, const string& className)
     {
-        features = featureNames;
+        checkFitData(input_data[0].size(), input_data.size(), labels.size(), featureNames, className);
         this->className = className;
         dataset.clear();
         // Specific part
         classNumStates = *max_element(labels.begin(), labels.end()) + 1;
-        // Build dataset & tensor of samples
-        samples = torch::zeros({ static_cast<int>(input_data[0].size()), static_cast<int>(input_data.size() + 1) }, torch::kInt32);
+        // Build dataset & tensor of samples (nxm) (n+1 because of the class)
+        samples = torch::zeros({ static_cast<int>(input_data.size() + 1), static_cast<int>(input_data[0].size()) }, torch::kInt32);
         for (int i = 0; i < featureNames.size(); ++i) {
             dataset[featureNames[i]] = input_data[i];
-            samples.index_put_({ "...", i }, torch::tensor(input_data[i], torch::kInt32));
+            samples.index_put_({ i, "..." }, torch::tensor(input_data[i], torch::kInt32));
         }
         dataset[className] = labels;
-        samples.index_put_({ "...", -1 }, torch::tensor(labels, torch::kInt32));
+        samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32));
         completeFit();
     }
     void Network::completeFit()
     {
-
         int maxThreadsRunning = static_cast<int>(std::thread::hardware_concurrency() * maxThreads);
         if (maxThreadsRunning < 1) {
             maxThreadsRunning = 1;
@@ -170,7 +202,36 @@ namespace bayesnet {
         }
         fitted = true;
     }
+    torch::Tensor Network::predict_tensor(const torch::Tensor& samples, const bool proba)
+    {
+        if (!fitted) {
+            throw logic_error("You must call fit() before calling predict()");
+        }
+        torch::Tensor result;
+        result = torch::zeros({ samples.size(1), classNumStates }, torch::kFloat64);
+        for (int i = 0; i < samples.size(1); ++i) {
+            auto sample = samples.index({ "...", i });
+            result.index_put_({ i, "..." }, torch::tensor(predict_sample(sample), torch::kFloat64));
+        }
+        if (proba)
+            return result;
+        else
+            return result.argmax(1);
+    }
+    // Return mxn tensor of probabilities
+    Tensor Network::predict_proba(const Tensor& samples)
+    {
+        return predict_tensor(samples, true);
+    }
 
+    // Return mxn tensor of probabilities
+    Tensor Network::predict(const Tensor& samples)
+    {
+        return predict_tensor(samples, false);
+    }
+
+    // Return mx1 vector of predictions
+    // tsamples is nxm vector of samples
     vector<int> Network::predict(const vector<vector<int>>& tsamples)
     {
         if (!fitted) {
@@ -191,6 +252,7 @@ namespace bayesnet {
         }
         return predictions;
     }
+    // Return mxn vector of probabilities
     vector<vector<double>> Network::predict_proba(const vector<vector<int>>& tsamples)
     {
         if (!fitted) {
@@ -218,12 +280,13 @@ namespace bayesnet {
         }
         return (double)correct / y_pred.size();
     }
+    // Return 1xn vector of probabilities
     vector<double> Network::predict_sample(const vector<int>& sample)
     {
         // Ensure the sample size is equal to the number of features
-        if (sample.size() != features.size()) {
+        if (sample.size() != features.size() - 1) {
             throw invalid_argument("Sample size (" + to_string(sample.size()) +
-                ") does not match the number of features (" + to_string(features.size()) + ")");
+                ") does not match the number of features (" + to_string(features.size() - 1) + ")");
         }
         map<string, int> evidence;
         for (int i = 0; i < sample.size(); ++i) {
@@ -231,6 +294,20 @@ namespace bayesnet {
         }
         return exactInference(evidence);
     }
+    // Return 1xn vector of probabilities
+    vector<double> Network::predict_sample(const Tensor& sample)
+    {
+        // Ensure the sample size is equal to the number of features
+        if (sample.size(0) != features.size() - 1) {
+            throw invalid_argument("Sample size (" + to_string(sample.size(0)) +
+                ") does not match the number of features (" + to_string(features.size() - 1) + ")");
+        }
+        map<string, int> evidence;
+        for (int i = 0; i < sample.size(0); ++i) {
+            evidence[features[i]] = sample[i].item<int>();
+        }
+        return exactInference(evidence);
+    }
     double Network::computeFactor(map<string, int>& completeEvidence)
     {
         double result = 1.0;
@@ -301,4 +378,48 @@ namespace bayesnet {
         }
         return edges;
     }
+    vector<string> Network::topological_sort()
+    {
+        /* Check if al the fathers of every node are before the node */
+        auto result = features;
+        result.erase(remove(result.begin(), result.end(), className), result.end());
+        bool ending{ false };
+        int idx = 0;
+        while (!ending) {
+            ending = true;
+            for (auto feature : features) {
+                auto fathers = nodes[feature]->getParents();
+                for (const auto& father : fathers) {
+                    auto fatherName = father->getName();
+                    if (fatherName == className) {
+                        continue;
+                    }
+                    // Check if father is placed before the actual feature
+                    auto it = find(result.begin(), result.end(), fatherName);
+                    if (it != result.end()) {
+                        auto it2 = find(result.begin(), result.end(), feature);
+                        if (it2 != result.end()) {
+                            if (distance(it, it2) < 0) {
+                                // if it is not, insert it before the feature
+                                result.erase(remove(result.begin(), result.end(), fatherName), result.end());
+                                result.insert(it2, fatherName);
+                                ending = false;
+                            }
+                        } else {
+                            throw logic_error("Error in topological sort because of node " + feature + " is not in result");
+                        }
+                    } else {
+                        throw logic_error("Error in topological sort because of node father " + fatherName + " is not in result");
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    void Network::dump_cpt()
+    {
+        for (auto& node : nodes) {
+            cout << "* " << node.first << ": " << node.second->getCPT() << endl;
+        }
+    }
 }

src/BayesNet/Network.h

@@ -10,14 +10,15 @@ namespace bayesnet {
         map<string, unique_ptr<Node>> nodes;
         map<string, vector<int>> dataset;
         bool fitted;
-        float maxThreads;
+        float maxThreads = 0.95;
         int classNumStates;
-        vector<string> features;
+        vector<string> features; // Including class
         string className;
-        int laplaceSmoothing;
-        torch::Tensor samples;
+        int laplaceSmoothing = 1;
+        torch::Tensor samples; // nxm tensor used to fit the model
         bool isCyclic(const std::string&, std::unordered_set<std::string>&, std::unordered_set<std::string>&);
         vector<double> predict_sample(const vector<int>&);
+        vector<double> predict_sample(const torch::Tensor&);
         vector<double> exactInference(map<string, int>&);
         double computeFactor(map<string, int>&);
         double mutual_info(torch::Tensor&, torch::Tensor&);
@@ -25,6 +26,7 @@ namespace bayesnet {
         double conditionalEntropy(torch::Tensor&, torch::Tensor&);
         double mutualInformation(torch::Tensor&, torch::Tensor&);
         void completeFit();
+        void checkFitData(int n_features, int n_samples, int n_samples_y, const vector<string>& featureNames, const string& className);
     public:
         Network();
         explicit Network(float, int);
@@ -42,13 +44,19 @@ namespace bayesnet {
         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>>&);
+        vector<int> predict(const vector<vector<int>>&); // Return mx1 vector of predictions
+        torch::Tensor predict(const torch::Tensor&); // Return mx1 tensor of predictions
         //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>>&);
+        torch::Tensor predict_tensor(const torch::Tensor& samples, const bool proba);
+        vector<vector<double>> predict_proba(const vector<vector<int>>&); // Return mxn vector of probabilities
+        torch::Tensor predict_proba(const torch::Tensor&); // Return mxn tensor of probabilities
         double score(const vector<vector<int>>&, const vector<int>&);
+        vector<string> topological_sort();
         vector<string> show();
         vector<string> graph(const string& title); // Returns a vector of strings representing the graph in graphviz format
+        void initialize();
+        void dump_cpt();
         inline string version() { return "0.1.0"; }
     };
 }

src/BayesNet/SPODE.cc

@@ -17,7 +17,7 @@ namespace bayesnet {
             }
         }
     }
-    vector<string> SPODE::graph(string name )
+    vector<string> SPODE::graph(const string& name)
     {
         return model.graph(name);
     }

src/BayesNet/SPODE.h

@@ -11,7 +11,7 @@ namespace bayesnet {
     public:
         explicit SPODE(int root);
         virtual ~SPODE() {};
-        vector<string> graph(string name = "SPODE") override;
+        vector<string> graph(const string& name = "SPODE") override;
     };
 }
 #endif

src/BayesNet/TAN.cc

@@ -12,9 +12,9 @@ namespace bayesnet {
         // 1. Compute mutual information between each feature and the class and set the root node
         // as the highest mutual information with the class
         auto mi = vector <pair<int, float >>();
-        Tensor class_dataset = dataset.index({ "...", -1 });
+        Tensor class_dataset = samples.index({ -1, "..." });
         for (int i = 0; i < static_cast<int>(features.size()); ++i) {
-            Tensor feature_dataset = dataset.index({ "...", i });
+            Tensor feature_dataset = samples.index({ i, "..." });
             auto mi_value = metrics.mutualInformation(class_dataset, feature_dataset);
             mi.push_back({ i, mi_value });
         }
@@ -34,7 +34,7 @@ namespace bayesnet {
             model.addEdge(className, feature);
         }
     }
-    vector<string> TAN::graph(string title)
+    vector<string> TAN::graph(const string& title)
     {
         return model.graph(title);
     }

src/BayesNet/TAN.h

@@ -11,7 +11,7 @@ namespace bayesnet {
     public:
         TAN();
         virtual ~TAN() {};
-        vector<string> graph(string name = "TAN") override;
+        vector<string> graph(const string& name = "TAN") override;
     };
 }
 #endif

src/BayesNet/TANNew.cc

@@ -0,0 +1,55 @@
+#include "TANNew.h"
+
+namespace bayesnet {
+    using namespace std;
+    TANNew::TANNew() : TAN() {}
+    TANNew::~TANNew() {}
+    TANNew& TANNew::fit(torch::Tensor& X_, torch::Tensor& y_, vector<string>& features_, string className_, map<string, vector<int>>& states_)
+    {
+        Xf = X_;
+        y = y_;
+        features = features_;
+        className = className_;
+        Xv = vector<vector<int>>();
+        yv = vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
+        // discretize input data by feature(row)
+        for (int i = 0; i < features.size(); ++i) {
+            auto* discretizer = new mdlp::CPPFImdlp();
+            auto Xt_ptr = Xf.index({ i }).data_ptr<float>();
+            auto Xt = vector<float>(Xt_ptr, Xt_ptr + Xf.size(1));
+            discretizer->fit(Xt, yv);
+            Xv.push_back(discretizer->transform(Xt));
+            auto xStates = vector<int>(discretizer->getCutPoints().size() + 1);
+            iota(xStates.begin(), xStates.end(), 0);
+            states[features[i]] = xStates;
+            discretizers[features[i]] = discretizer;
+        }
+        int n_classes = torch::max(y).item<int>() + 1;
+        auto yStates = vector<int>(n_classes);
+        iota(yStates.begin(), yStates.end(), 0);
+        states[className] = yStates;
+        // Now we have standard TAN and now we implement the proposal
+        // 1st we need to fit the model to build the TAN structure
+        cout << "TANNew: Fitting model" << endl;
+        TAN::fit(Xv, yv, features, className, states);
+        cout << "TANNew: Model fitted" << endl;
+        localDiscretizationProposal(discretizers, Xf);
+        return *this;
+    }
+
+    Tensor TANNew::predict(Tensor& X)
+    {
+        auto Xtd = torch::zeros_like(X, torch::kInt32);
+        for (int i = 0; i < X.size(0); ++i) {
+            auto Xt = vector<float>(X[i].data_ptr<float>(), X[i].data_ptr<float>() + X.size(1));
+            auto Xd = discretizers[features[i]]->transform(Xt);
+            Xtd.index_put_({ i }, torch::tensor(Xd, torch::kInt32));
+        }
+        cout << "TANNew Xtd: " << Xtd.sizes() << endl;
+        return TAN::predict(Xtd);
+    }
+    vector<string> TANNew::graph(const string& name)
+    {
+        return TAN::graph(name);
+    }
+}

src/BayesNet/TANNew.h

@@ -0,0 +1,21 @@
+#ifndef TANNEW_H
+#define TANNEW_H
+#include "TAN.h"
+#include "CPPFImdlp.h"
+
+namespace bayesnet {
+    using namespace std;
+    class TANNew : public TAN {
+    private:
+        map<string, mdlp::CPPFImdlp*> discretizers;
+        torch::Tensor Xf; // X continuous nxm tensor
+    public:
+        TANNew();
+        virtual ~TANNew();
+        TANNew& fit(torch::Tensor& X, torch::Tensor& y, vector<string>& features, string className, map<string, vector<int>>& states) override;
+        vector<string> graph(const string& name = "TAN") override;
+        Tensor predict(Tensor& X) override;
+        static inline string version() { return "0.0.1"; };
+    };
+}
+#endif // !TANNEW_H

src/Platform/Datasets.cc

@@ -207,9 +207,9 @@ namespace platform {
         if (discretize) {
             Xd = discretizeDataset(Xv, yv);
             computeStates();
-            n_samples = Xd[0].size();
-            n_features = Xd.size();
         }
+        n_samples = Xv[0].size();
+        n_features = Xv.size();
         loaded = true;
     }
     void Dataset::buildTensors()

src/Platform/Experiment.cc

@@ -104,7 +104,7 @@ namespace platform {
 
     void Experiment::cross_validation(const string& path, const string& fileName)
     {
-        auto datasets = platform::Datasets(path, true, platform::ARFF);
+        auto datasets = platform::Datasets(path, discretized, platform::ARFF);
         // Get dataset
         auto [X, y] = datasets.getTensors(fileName);
         auto states = datasets.getStates(fileName);
@@ -114,7 +114,7 @@ namespace platform {
         cout << " (" << setw(5) << samples << "," << setw(3) << features.size() << ") " << flush;
         // Prepare Result
         auto result = Result();
-        auto [values, counts] = at::_unique(y);;
+        auto [values, counts] = at::_unique(y);
         result.setSamples(X.size(1)).setFeatures(X.size(0)).setClasses(values.size(0));
         int nResults = nfolds * static_cast<int>(randomSeeds.size());
         auto accuracy_test = torch::zeros({ nResults }, torch::kFloat64);

src/Platform/Models.h

@@ -6,6 +6,7 @@
 #include "TAN.h"
 #include "KDB.h"
 #include "SPODE.h"
+#include "TANNew.h"
 namespace platform {
     class Models {
     private:

src/Platform/main.cc

@@ -99,7 +99,6 @@ int main(int argc, char** argv)
         filesToTest = platform::Datasets(path, true, platform::ARFF).getNames();
         saveResults = true;
     }
-
     /*
     * Begin Processing
     */

src/Platform/modelRegister.h

@@ -2,6 +2,8 @@
 #define MODEL_REGISTER_H
 static platform::Registrar registrarT("TAN",
     [](void) -> bayesnet::BaseClassifier* { return new bayesnet::TAN();});
+static platform::Registrar registrarTN("TANNew",
+    [](void) -> bayesnet::BaseClassifier* { return new bayesnet::TANNew();});
 static platform::Registrar registrarS("SPODE",
     [](void) -> bayesnet::BaseClassifier* { return new bayesnet::SPODE(2);});
 static platform::Registrar registrarK("KDB",