Fix typo in CHANGELOG

Add mdlp as library in lib/
Fix tests to reach 99.1% of coverage

Reviewed-on: #31

.clang-uml

@@ -1,4 +1,4 @@
-compilation_database_dir: build_debug
+compilation_database_dir: build_Debug
 output_directory: diagrams
 diagrams:
   BayesNet:

.gitmodules

@@ -16,3 +16,6 @@
 [submodule "tests/lib/Files"]
 	path = tests/lib/Files
 	url = https://github.com/rmontanana/ArffFiles
+[submodule "lib/mdlp"]
+	path = lib/mdlp
+	url = https://github.com/rmontanana/mdlp

.vscode/launch.json

@@ -16,7 +16,7 @@
             "name": "test",
             "program": "${workspaceFolder}/build_Debug/tests/TestBayesNet",
             "args": [
-                "[Network]"
+                "No features selected"
             ],
             "cwd": "${workspaceFolder}/build_Debug/tests"
         },

CHANGELOG.md

@@ -9,22 +9,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Add a new hyperparameter to the BoostAODE class, *alphablock*, to control the way α is computed, with the last model or with the ensmble built so far. Default value is *false*.
+- Add a new hyperparameter to the SPODE class, *parent*, to set the root node of the model. If no value is set the root parameter of the constructor is used.
+- Add a new hyperparameter to the TAN class, *parent*, to set the root node of the model. If not set the first feature is used as root.
+
+## [1.0.6] 2024-11-23
+
+### Fixed
+
+- Prevent existing edges to be added to the network in the `add_edge` method.
+- Don't allow to add nodes or edges on already fiited networks.
+- Number of threads spawned
+- Network class tests
+
+### Added
+
 - Library logo generated with <https://openart.ai> to README.md
 - Link to the coverage report in the README.md coverage label.
 - *convergence_best* hyperparameter to the BoostAODE class, to control the way the prior accuracy is computed if convergence is set. Default value is *false*.
 - SPnDE model.
 - A2DE model.
+- BoostA2DE model.
 - A2DE & SPnDE tests.
 - Add tests to reach 99% of coverage.
 - Add tests to check the correct version of the mdlp, folding and json libraries.
 - Library documentation generated with Doxygen.
 - Link to documentation in the README.md.
-- Three types of smoothing the Bayesian Network OLD_LAPLACE, LAPLACE and CESTNIK.
+- Three types of smoothing the Bayesian Network ORIGINAL, LAPLACE and CESTNIK.
 
 ### Internal
 
+- Fixed doxygen optional dependency
+- Add env parallel variable to Makefile
+- Add CountingSemaphore class to manage the number of threads spawned.
 - Ignore CUDA language in CMake CodeCoverage module.
-- Remove mdlp library from submodules and add it as a dependency.
+- Update mdlp library as a git submodule.
 - Create library ShuffleArffFile to limit the number of samples with a parameter and shuffle them.
 - Refactor catch2 library location to test/lib
 - Refactor loadDataset function in tests.
@@ -35,6 +54,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add a Makefile target (doc) to generate the documentation.
 - Add a Makefile target (doc-install) to install the documentation.
 
+### Libraries versions
+
+- mdlp: 2.0.1
+- Folding: 1.1.0
+- json: 3.11
+- ArffFiles: 1.1.0
+
 ## [1.0.5] 2024-04-20
 
 ### Added

CMakeLists.txt

@@ -65,15 +65,9 @@ endif (ENABLE_CLANG_TIDY)
 # External libraries - dependencies of BayesNet
 # ---------------------------------------------
 
-find_library(FImdlp NAMES libfimdlp.a REQUIRED)
-find_path(FImdlp_INCLUDE_DIRS REQUIRED NAMES fimdlp)
-
-message(STATUS "FImdlp=${FImdlp}")
-message(STATUS "FImdlp_INCLUDE_DIRS=${FImdlp_INCLUDE_DIRS}")
-
-
 # include(FetchContent)
 add_git_submodule("lib/json")
+add_git_submodule("lib/mdlp")
 
 # Subdirectories
 # --------------

Makefile

@@ -43,7 +43,7 @@ setup: ## Install dependencies for tests and coverage
 	fi
 	@echo "* You should install plantuml & graphviz for the diagrams"
 
-diagrams: ## Create an UML class diagram & depnendency of the project (diagrams/BayesNet.png)
+diagrams: ## Create an UML class diagram & dependency of the project (diagrams/BayesNet.png)
 	@which $(plantuml) || (echo ">>> Please install plantuml"; exit 1)
 	@which $(dot) || (echo ">>> Please install graphviz"; exit 1)
 	@which $(clang-uml) || (echo ">>> Please install clang-uml"; exit 1)
@@ -172,7 +172,7 @@ docdir = ""
 doc-install: ## Install documentation
 	@echo ">>> Installing documentation..."
 	@if [ "$(docdir)" = "" ]; then \
-		echo "docdir parameter has to be set when calling doc-install"; \
+		echo "docdir parameter has to be set when calling doc-install, i.e. docdir=../bayesnet_help"; \
 		exit 1; \
 	fi
 	@if [ ! -d $(docdir) ]; then \

README.md

@@ -7,9 +7,10 @@
 [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=rmontanana_BayesNet&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=rmontanana_BayesNet)
 [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=rmontanana_BayesNet&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=rmontanana_BayesNet)
 ![Gitea Last Commit](https://img.shields.io/gitea/last-commit/rmontanana/bayesnet?gitea_url=https://gitea.rmontanana.es:3000&logo=gitea)
-[![Coverage Badge](https://img.shields.io/badge/Coverage-97,1%25-green)](html/index.html)
+[![Coverage Badge](https://img.shields.io/badge/Coverage-99,1%25-green)](html/index.html)
+[![DOI](https://zenodo.org/badge/667782806.svg)](https://doi.org/10.5281/zenodo.14210344)
 
-Bayesian Network Classifiers using libtorch from scratch
+Bayesian Network Classifiers library
 
 ## Dependencies
 
@@ -17,7 +18,7 @@ The only external dependency is [libtorch](https://pytorch.org/cppdocs/installin
 
 ```bash
 wget https://download.pytorch.org/libtorch/nightly/cpu/libtorch-shared-with-deps-latest.zip
-unzip libtorch-shared-with-deps-latest.zips
+unzip libtorch-shared-with-deps-latest.zip
 ```
 
 ## Setup
@@ -71,6 +72,8 @@ make sample fname=tests/data/glass.arff
 
 #### - AODE
 
+#### - A2DE
+
 #### - [BoostAODE](docs/BoostAODE.md)
 
 #### - BoostA2DE

bayesnet/CMakeLists.txt

@@ -4,10 +4,9 @@ include_directories(
     ${BayesNet_SOURCE_DIR}/lib/json/include
     ${BayesNet_SOURCE_DIR}
     ${CMAKE_BINARY_DIR}/configured_files/include
-    ${FImdlp_INCLUDE_DIRS}
 )
 
 file(GLOB_RECURSE Sources "*.cc")
 
 add_library(BayesNet ${Sources})
-target_link_libraries(BayesNet ${FImdlp} "${TORCH_LIBRARIES}")
+target_link_libraries(BayesNet fimdlp "${TORCH_LIBRARIES}")

bayesnet/classifiers/Proposal.h

@@ -9,7 +9,7 @@
 #include <string>
 #include <map>
 #include <torch/torch.h>
-#include <fimdlp/CPPFImdlp.h>
+#include <CPPFImdlp.h>
 #include "bayesnet/network/Network.h"
 #include "Classifier.h"
 

bayesnet/classifiers/SPODE.cc

@@ -8,14 +8,29 @@
 
 namespace bayesnet {
 
-    SPODE::SPODE(int root) : Classifier(Network()), root(root) {}
+    SPODE::SPODE(int root) : Classifier(Network()), root(root)
+    {
+        validHyperparameters = { "parent" };
+    }
 
+    void SPODE::setHyperparameters(const nlohmann::json& hyperparameters_)
+    {
+        auto hyperparameters = hyperparameters_;
+        if (hyperparameters.contains("parent")) {
+            root = hyperparameters["parent"];
+            hyperparameters.erase("parent");
+        }
+        Classifier::setHyperparameters(hyperparameters);
+    }
     void SPODE::buildModel(const torch::Tensor& weights)
     {
         // 0. Add all nodes to the model
         addNodes();
         // 1. Add edges from the class node to all other nodes
         // 2. Add edges from the root node to all other nodes
+        if (root >= static_cast<int>(features.size())) {
+            throw std::invalid_argument("The parent node is not in the dataset");
+        }
         for (int i = 0; i < static_cast<int>(features.size()); ++i) {
             model.addEdge(className, features[i]);
             if (i != root) {

bayesnet/classifiers/SPODE.h

@@ -10,14 +10,15 @@
 
 namespace bayesnet {
     class SPODE : public Classifier {
-    private:
-        int root;
-    protected:
-        void buildModel(const torch::Tensor& weights) override;
     public:
         explicit SPODE(int root);
         virtual ~SPODE() = default;
+        void setHyperparameters(const nlohmann::json& hyperparameters_) override;
         std::vector<std::string> graph(const std::string& name = "SPODE") const override;
+    protected:
+        void buildModel(const torch::Tensor& weights) override;
+    private:
+        int root;
     };
 }
 #endif

bayesnet/classifiers/TAN.cc

@@ -7,8 +7,20 @@
 #include "TAN.h"
 
 namespace bayesnet {
-    TAN::TAN() : Classifier(Network()) {}
+    TAN::TAN() : Classifier(Network())
+    {
+        validHyperparameters = { "parent" };
+    }
 
+    void TAN::setHyperparameters(const nlohmann::json& hyperparameters_)
+    {
+        auto hyperparameters = hyperparameters_;
+        if (hyperparameters.contains("parent")) {
+            parent = hyperparameters["parent"];
+            hyperparameters.erase("parent");
+        }
+        Classifier::setHyperparameters(hyperparameters);
+    }
     void TAN::buildModel(const torch::Tensor& weights)
     {
         // 0. Add all nodes to the model
@@ -23,7 +35,10 @@ namespace bayesnet {
             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;
+        auto root = parent == -1 ? mi[mi.size() - 1].first : parent;
+        if (root >= static_cast<int>(features.size())) {
+            throw std::invalid_argument("The parent node is not in the dataset");
+        }
         // 2. Compute mutual information between each feature and the class
         auto weights_matrix = metrics.conditionalEdge(weights);
         // 3. Compute the maximum spanning tree

bayesnet/classifiers/TAN.h

@@ -9,13 +9,15 @@
 #include "Classifier.h"
 namespace bayesnet {
     class TAN : public Classifier {
-    private:
-    protected:
-        void buildModel(const torch::Tensor& weights) override;
     public:
         TAN();
         virtual ~TAN() = default;
+        void setHyperparameters(const nlohmann::json& hyperparameters_) override;
         std::vector<std::string> graph(const std::string& name = "TAN") const override;
+    protected:
+        void buildModel(const torch::Tensor& weights) override;
+    private:
+        int parent = -1;
     };
 }
 #endif

bayesnet/ensembles/AODELd.cc

@@ -20,7 +20,8 @@ namespace bayesnet {
         // 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
+        // 1st we need to fit the model to build the normal AODE structure, Ensemble::fit  
+        // calls buildModel to initialize the base models
         Ensemble::fit(dataset, features, className, states, smoothing);
         return *this;
 

bayesnet/ensembles/Boost.cc

@@ -12,7 +12,7 @@
 namespace bayesnet {
     Boost::Boost(bool predict_voting) : Ensemble(predict_voting)
     {
-        validHyperparameters = { "order", "convergence", "convergence_best", "bisection", "threshold", "maxTolerance",
+        validHyperparameters = { "alpha_block", "order", "convergence", "convergence_best", "bisection", "threshold", "maxTolerance",
         "predict_voting", "select_features", "block_update" };
     }
     void Boost::setHyperparameters(const nlohmann::json& hyperparameters_)
@@ -26,6 +26,10 @@ namespace bayesnet {
             }
             hyperparameters.erase("order");
         }
+        if (hyperparameters.contains("alpha_block")) {
+            alpha_block = hyperparameters["alpha_block"];
+            hyperparameters.erase("alpha_block");
+        }
         if (hyperparameters.contains("convergence")) {
             convergence = hyperparameters["convergence"];
             hyperparameters.erase("convergence");
@@ -66,6 +70,12 @@ namespace bayesnet {
             block_update = hyperparameters["block_update"];
             hyperparameters.erase("block_update");
         }
+        if (block_update && alpha_block) {
+            throw std::invalid_argument("alpha_block and block_update cannot be true at the same time");
+        }
+        if (block_update && !bisection) {
+            throw std::invalid_argument("block_update needs bisection to be true");
+        }
         Classifier::setHyperparameters(hyperparameters);
     }
     void Boost::buildModel(const torch::Tensor& weights)

bayesnet/ensembles/Boost.h

@@ -45,8 +45,8 @@ namespace bayesnet {
         std::string select_features_algorithm = Orders.DESC; // Selected feature selection algorithm
         FeatureSelect* featureSelector = nullptr;
         double threshold = -1;
-        bool block_update = false;
+        bool block_update = false; // if true, use block update algorithm, only meaningful if bisection is true
-
+        bool alpha_block = false; // if true, the alpha is computed with the ensemble built so far and the new model
     };
 }
 #endif

bayesnet/ensembles/BoostA2DE.cc

@@ -59,6 +59,9 @@ namespace bayesnet {
         std::vector<int> featuresUsed;
         if (selectFeatures) {
             featuresUsed = initializeModels(smoothing);
+            if (featuresUsed.size() == 0) {
+                return;
+            }
             auto ypred = predict(X_train);
             std::tie(weights_, alpha_t, finished) = update_weights(y_train, ypred, weights_);
             // Update significance of the models

bayesnet/ensembles/BoostAODE.cc

@@ -92,7 +92,25 @@ namespace bayesnet {
                 model->fit(dataset, features, className, states, weights_, smoothing);
                 alpha_t = 0.0;
                 if (!block_update) {
-                    auto ypred = model->predict(X_train);
+                    torch::Tensor ypred;
+                    if (alpha_block) {
+                        //
+                        // Compute the prediction with the current ensemble + model
+                        //
+                        // Add the model to the ensemble
+                        n_models++;
+                        models.push_back(std::move(model));
+                        significanceModels.push_back(1);
+                        // Compute the prediction
+                        ypred = predict(X_train);
+                        // Remove the model from the ensemble
+                        model = std::move(models.back());
+                        models.pop_back();
+                        significanceModels.pop_back();
+                        n_models--;
+                    } else {
+                        ypred = model->predict(X_train);
+                    }
                     // Step 3.1: Compute the classifier amout of say
                     std::tie(weights_, alpha_t, finished) = update_weights(y_train, ypred, weights_);
                 }

bayesnet/network/Network.cc

@@ -209,7 +209,7 @@ namespace bayesnet {
             pthread_setname_np(threadName.c_str());
 #endif
             double numStates = static_cast<double>(node.second->getNumStates());
-            double smoothing_factor = 0.0;
+            double smoothing_factor;
             switch (smoothing) {
                 case Smoothing_t::ORIGINAL:
                     smoothing_factor = 1.0 / n_samples;
@@ -221,7 +221,7 @@ namespace bayesnet {
                     smoothing_factor = 1 / numStates;
                     break;
                 default:
-                    throw std::invalid_argument("Smoothing method not recognized " + std::to_string(static_cast<int>(smoothing)));
+                    smoothing_factor = 0.0; // No smoothing 
             }
             node.second->computeCPT(samples, features, smoothing_factor, weights);
             semaphore.release();
@@ -234,16 +234,6 @@ namespace bayesnet {
         for (auto& thread : threads) {
             thread.join();
         }
-        // std::fstream file;
-        // file.open("cpt.txt", std::fstream::out | std::fstream::app);
-        // file << std::string(80, '*') << std::endl;
-        // for (const auto& item : graph("Test")) {
-        //     file << item << std::endl;
-        // }
-        // file << std::string(80, '-') << std::endl;
-        // file << dump_cpt() << std::endl;
-        // file << std::string(80, '=') << std::endl;
-        // file.close();
         fitted = true;
     }
     torch::Tensor Network::predict_tensor(const torch::Tensor& samples, const bool proba)

bayesnet/utils/Mst.cc

@@ -53,14 +53,14 @@ namespace bayesnet {
         }
     }
 
-    void insertElement(std::list<int>& variables, int variable)
+    void MST::insertElement(std::list<int>& variables, int variable)
     {
         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)
+    std::vector<std::pair<int, int>> MST::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

bayesnet/utils/Mst.h

@@ -14,6 +14,8 @@ namespace bayesnet {
     public:
         MST() = default;
         MST(const std::vector<std::string>& features, const torch::Tensor& weights, const int root);
+        void insertElement(std::list<int>& variables, int variable);
+        std::vector<std::pair<int, int>> reorder(std::vector<std::pair<float, std::pair<int, int>>> T, int root_original);
         std::vector<std::pair<int, int>> maximumSpanningTree();
     private:
         torch::Tensor weights;

diagrams/BayesNet.puml

@@ -1,36 +1,16 @@
 @startuml
 title clang-uml class diagram model
-class "bayesnet::Metrics" as C_0000736965376885623323
+class "bayesnet::Node" as C_0010428199432536647474
-class C_0000736965376885623323 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0010428199432536647474 #aliceblue;line:blue;line.dotted;text:blue {
-+Metrics() = default : void
-+Metrics(const torch::Tensor & samples, const std::vector<std::string> & features, const std::string & className, const int classNumStates) : void
-+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) : void
-..
-+SelectKBestWeighted(const torch::Tensor & weights, bool ascending = false, unsigned int k = 0) : std::vector<int>
-+conditionalEdge(const torch::Tensor & weights) : torch::Tensor
-+conditionalEdgeWeights(std::vector<float> & weights) : std::vector<float>
-#doCombinations<T>(const std::vector<T> & source) : std::vector<std::pair<T, T> >
-#entropy(const torch::Tensor & feature, const torch::Tensor & weights) : double
-+getScoresKBest() const : std::vector<double>
-+maximumSpanningTree(const std::vector<std::string> & features, const torch::Tensor & weights, const int root) : std::vector<std::pair<int,int>>
-+mutualInformation(const torch::Tensor & firstFeature, const torch::Tensor & secondFeature, const torch::Tensor & weights) : double
-#pop_first<T>(std::vector<T> & v) : T
-__
-#className : std::string
-#features : std::vector<std::string>
-#samples : torch::Tensor
-}
-class "bayesnet::Node" as C_0001303524929067080934
-class C_0001303524929067080934 #aliceblue;line:blue;line.dotted;text:blue {
 +Node(const std::string &) : void
 ..
 +addChild(Node *) : void
 +addParent(Node *) : void
 +clear() : void
-+computeCPT(const torch::Tensor & dataset, const std::vector<std::string> & features, const double laplaceSmoothing, const torch::Tensor & weights) : void
++computeCPT(const torch::Tensor & dataset, const std::vector<std::string> & features, const double smoothing, const torch::Tensor & weights) : void
 +getCPT() : torch::Tensor &
 +getChildren() : std::vector<Node *> &
-+getFactorValue(std::map<std::string,int> &) : float
++getFactorValue(std::map<std::string,int> &) : double
 +getName() const : std::string
 +getNumStates() const : int
 +getParents() : std::vector<Node *> &
@@ -41,24 +21,29 @@ class C_0001303524929067080934 #aliceblue;line:blue;line.dotted;text:blue {
 +setNumStates(int) : void
 __
 }
-class "bayesnet::Network" as C_0001186707649890429575
+enum "bayesnet::Smoothing_t" as C_0013393078277439680282
-class C_0001186707649890429575 #aliceblue;line:blue;line.dotted;text:blue {
+enum C_0013393078277439680282 {
+NONE
+ORIGINAL
+LAPLACE
+CESTNIK
+}
+class "bayesnet::Network" as C_0009493661199123436603
+class C_0009493661199123436603 #aliceblue;line:blue;line.dotted;text:blue {
 +Network() : void
-+Network(float) : void
 +Network(const Network &) : void
 +~Network() = default : void
 ..
 +addEdge(const std::string &, const std::string &) : void
 +addNode(const std::string &) : void
 +dump_cpt() const : std::string
-+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
++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, const Smoothing_t smoothing) : 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 & 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, const Smoothing_t smoothing) : 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 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 Smoothing_t smoothing) : void
 +getClassName() const : std::string
 +getClassNumStates() const : int
 +getEdges() const : std::vector<std::pair<std::string,std::string>>
 +getFeatures() const : std::vector<std::string>
-+getMaxThreads() const : float
 +getNodes() : std::map<std::string,std::unique_ptr<Node>> &
 +getNumEdges() const : int
 +getSamples() : torch::Tensor &
@@ -76,21 +61,21 @@ class C_0001186707649890429575 #aliceblue;line:blue;line.dotted;text:blue {
 +version() : std::string
 __
 }
-enum "bayesnet::status_t" as C_0000738420730783851375
+enum "bayesnet::status_t" as C_0005907365846270811004
-enum C_0000738420730783851375 {
+enum C_0005907365846270811004 {
 NORMAL
 WARNING
 ERROR
 }
-abstract "bayesnet::BaseClassifier" as C_0000327135989451974539
+abstract "bayesnet::BaseClassifier" as C_0002617087915615796317
-abstract C_0000327135989451974539 #aliceblue;line:blue;line.dotted;text:blue {
+abstract C_0002617087915615796317 #aliceblue;line:blue;line.dotted;text:blue {
 +~BaseClassifier() = default : void
 ..
 {abstract} +dump_cpt() const = 0 : std::string
-{abstract} +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 : BaseClassifier &
+{abstract} +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, const Smoothing_t smoothing) = 0 : BaseClassifier &
-{abstract} +fit(torch::Tensor & dataset, const std::vector<std::string> & features, const std::string & className, std::map<std::string,std::vector<int>> & states) = 0 : BaseClassifier &
+{abstract} +fit(torch::Tensor & dataset, const std::vector<std::string> & features, const std::string & className, std::map<std::string,std::vector<int>> & states, const Smoothing_t smoothing) = 0 : BaseClassifier &
-{abstract} +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 : BaseClassifier &
+{abstract} +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, const Smoothing_t smoothing) = 0 : BaseClassifier &
-{abstract} +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 : BaseClassifier &
+{abstract} +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, const Smoothing_t smoothing) = 0 : BaseClassifier &
 {abstract} +getClassNumStates() const = 0 : int
 {abstract} +getNotes() const = 0 : std::vector<std::string>
 {abstract} +getNumberOfEdges() const = 0 : int
@@ -109,12 +94,35 @@ abstract C_0000327135989451974539 #aliceblue;line:blue;line.dotted;text:blue {
 {abstract} +setHyperparameters(const nlohmann::json & hyperparameters) = 0 : void
 {abstract} +show() const = 0 : std::vector<std::string>
 {abstract} +topological_order() = 0 : std::vector<std::string>
-{abstract} #trainModel(const torch::Tensor & weights) = 0 : void
+{abstract} #trainModel(const torch::Tensor & weights, const Smoothing_t smoothing) = 0 : void
 __
 #validHyperparameters : std::vector<std::string>
 }
-abstract "bayesnet::Classifier" as C_0002043996622900301644
+class "bayesnet::Metrics" as C_0005895723015084986588
-abstract C_0002043996622900301644 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0005895723015084986588 #aliceblue;line:blue;line.dotted;text:blue {
++Metrics() = default : void
++Metrics(const torch::Tensor & samples, const std::vector<std::string> & features, const std::string & className, const int classNumStates) : void
++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) : void
+..
++SelectKBestWeighted(const torch::Tensor & weights, bool ascending = false, unsigned int k = 0) : std::vector<int>
++SelectKPairs(const torch::Tensor & weights, std::vector<int> & featuresExcluded, bool ascending = false, unsigned int k = 0) : std::vector<std::pair<int,int>>
++conditionalEdge(const torch::Tensor & weights) : torch::Tensor
++conditionalEntropy(const torch::Tensor & firstFeature, const torch::Tensor & secondFeature, const torch::Tensor & labels, const torch::Tensor & weights) : double
++conditionalMutualInformation(const torch::Tensor & firstFeature, const torch::Tensor & secondFeature, const torch::Tensor & labels, const torch::Tensor & weights) : double
+#doCombinations<T>(const std::vector<T> & source) : std::vector<std::pair<T, T> >
++entropy(const torch::Tensor & feature, const torch::Tensor & weights) : double
++getScoresKBest() const : std::vector<double>
++getScoresKPairs() const : std::vector<std::pair<std::pair<int,int>,double>>
++maximumSpanningTree(const std::vector<std::string> & features, const torch::Tensor & weights, const int root) : std::vector<std::pair<int,int>>
++mutualInformation(const torch::Tensor & firstFeature, const torch::Tensor & secondFeature, const torch::Tensor & weights) : double
+#pop_first<T>(std::vector<T> & v) : T
+__
+#className : std::string
+#features : std::vector<std::string>
+#samples : torch::Tensor
+}
+abstract "bayesnet::Classifier" as C_0016351972983202413152
+abstract C_0016351972983202413152 #aliceblue;line:blue;line.dotted;text:blue {
 +Classifier(Network model) : void
 +~Classifier() = default : void
 ..
@@ -123,10 +131,10 @@ abstract C_0002043996622900301644 #aliceblue;line:blue;line.dotted;text:blue {
 {abstract} #buildModel(const torch::Tensor & weights) = 0 : void
 #checkFitParameters() : void
 +dump_cpt() const : std::string
-+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) : 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, const Smoothing_t smoothing) : 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) : 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, const Smoothing_t smoothing) : Classifier &
-+fit(torch::Tensor & dataset, const std::vector<std::string> & features, const std::string & className, std::map<std::string,std::vector<int>> & states) : Classifier &
++fit(torch::Tensor & dataset, const std::vector<std::string> & features, const std::string & className, std::map<std::string,std::vector<int>> & states, const Smoothing_t smoothing) : 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) : 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, const Smoothing_t smoothing) : Classifier &
 +getClassNumStates() const : int
 +getNotes() const : std::vector<std::string>
 +getNumberOfEdges() const : int
@@ -143,7 +151,7 @@ abstract C_0002043996622900301644 #aliceblue;line:blue;line.dotted;text:blue {
 +setHyperparameters(const nlohmann::json & hyperparameters) : void
 +show() const : std::vector<std::string>
 +topological_order() : std::vector<std::string>
-#trainModel(const torch::Tensor & weights) : void
+#trainModel(const torch::Tensor & weights, const Smoothing_t smoothing) : void
 __
 #className : std::string
 #dataset : torch::Tensor
@@ -157,8 +165,8 @@ __
 #states : std::map<std::string,std::vector<int>>
 #status : status_t
 }
-class "bayesnet::KDB" as C_0001112865019015250005
+class "bayesnet::KDB" as C_0008902920152122000044
-class C_0001112865019015250005 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0008902920152122000044 #aliceblue;line:blue;line.dotted;text:blue {
 +KDB(int k, float theta = 0.03) : void
 +~KDB() = default : void
 ..
@@ -167,8 +175,26 @@ class C_0001112865019015250005 #aliceblue;line:blue;line.dotted;text:blue {
 +setHyperparameters(const nlohmann::json & hyperparameters_) : void
 __
 }
-class "bayesnet::TAN" as C_0001760994424884323017
+class "bayesnet::SPODE" as C_0004096182510460307610
-class C_0001760994424884323017 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0004096182510460307610 #aliceblue;line:blue;line.dotted;text:blue {
++SPODE(int root) : void
++~SPODE() = default : void
+..
+#buildModel(const torch::Tensor & weights) : void
++graph(const std::string & name = "SPODE") const : std::vector<std::string>
+__
+}
+class "bayesnet::SPnDE" as C_0016268916386101512883
+class C_0016268916386101512883 #aliceblue;line:blue;line.dotted;text:blue {
++SPnDE(std::vector<int> parents) : void
++~SPnDE() = default : void
+..
+#buildModel(const torch::Tensor & weights) : void
++graph(const std::string & name = "SPnDE") const : std::vector<std::string>
+__
+}
+class "bayesnet::TAN" as C_0014087955399074584137
+class C_0014087955399074584137 #aliceblue;line:blue;line.dotted;text:blue {
 +TAN() : void
 +~TAN() = default : void
 ..
@@ -176,8 +202,8 @@ class C_0001760994424884323017 #aliceblue;line:blue;line.dotted;text:blue {
 +graph(const std::string & name = "TAN") const : std::vector<std::string>
 __
 }
-class "bayesnet::Proposal" as C_0002219995589162262979
+class "bayesnet::Proposal" as C_0017759964713298103839
-class C_0002219995589162262979 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0017759964713298103839 #aliceblue;line:blue;line.dotted;text:blue {
 +Proposal(torch::Tensor & pDataset, std::vector<std::string> & features_, std::string & className_) : void
 +~Proposal() : void
 ..
@@ -190,74 +216,42 @@ __
 #discretizers : map<std::string,mdlp::CPPFImdlp *>
 #y : torch::Tensor
 }
-class "bayesnet::TANLd" as C_0001668829096702037834
+class "bayesnet::KDBLd" as C_0002756018222998454702
-class C_0001668829096702037834 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0002756018222998454702 #aliceblue;line:blue;line.dotted;text:blue {
-+TANLd() : void
++KDBLd(int k) : void
-+~TANLd() = default : void
++~KDBLd() = default : void
 ..
-+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) : TANLd &
++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, const Smoothing_t smoothing) : KDBLd &
-+graph(const std::string & name = "TAN") const : std::vector<std::string>
++graph(const std::string & name = "KDB") const : std::vector<std::string>
 +predict(torch::Tensor & X) : torch::Tensor
 {static} +version() : std::string
 __
 }
-abstract "bayesnet::FeatureSelect" as C_0001695326193250580823
+class "bayesnet::SPODELd" as C_0010957245114062042836
-abstract C_0001695326193250580823 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0010957245114062042836 #aliceblue;line:blue;line.dotted;text:blue {
-+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) : void
++SPODELd(int root) : void
-+~FeatureSelect() : void
++~SPODELd() = default : void
 ..
-#computeMeritCFS() : double
++commonFit(const std::vector<std::string> & features, const std::string & className, std::map<std::string,std::vector<int>> & states, const Smoothing_t smoothing) : SPODELd &
-#computeSuFeatures(const int a, const int b) : double
++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, const Smoothing_t smoothing) : SPODELd &
-#computeSuLabels() : void
++fit(torch::Tensor & dataset, const std::vector<std::string> & features, const std::string & className, std::map<std::string,std::vector<int>> & states, const Smoothing_t smoothing) : SPODELd &
-{abstract} +fit() = 0 : void
++graph(const std::string & name = "SPODELd") const : std::vector<std::string>
-+getFeatures() const : std::vector<int>
++predict(torch::Tensor & X) : torch::Tensor
-+getScores() const : std::vector<double>
+{static} +version() : std::string
-#initialize() : void
-#symmetricalUncertainty(int a, int b) : double
-__
-#fitted : bool
-#maxFeatures : int
-#selectedFeatures : std::vector<int>
-#selectedScores : std::vector<double>
-#suFeatures : std::map<std::pair<int,int>,double>
-#suLabels : std::vector<double>
-#weights : const torch::Tensor &
-}
-class "bayesnet::CFS" as C_0000011627355691342494
-class C_0000011627355691342494 #aliceblue;line:blue;line.dotted;text:blue {
-+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) : void
-+~CFS() : void
-..
-+fit() : void
 __
 }
-class "bayesnet::FCBF" as C_0000144682015341746929
+class "bayesnet::TANLd" as C_0013350632773616302678
-class C_0000144682015341746929 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0013350632773616302678 #aliceblue;line:blue;line.dotted;text:blue {
-+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) : void
++TANLd() : void
-+~FCBF() : void
++~TANLd() = default : void
 ..
-+fit() : void
++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, const Smoothing_t smoothing) : TANLd &
++graph(const std::string & name = "TANLd") const : std::vector<std::string>
++predict(torch::Tensor & X) : torch::Tensor
 __
 }
-class "bayesnet::IWSS" as C_0000008268514674428553
+class "bayesnet::Ensemble" as C_0015881931090842884611
-class C_0000008268514674428553 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0015881931090842884611 #aliceblue;line:blue;line.dotted;text:blue {
-+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) : void
-+~IWSS() : void
-..
-+fit() : void
-__
-}
-class "bayesnet::SPODE" as C_0000512022813807538451
-class C_0000512022813807538451 #aliceblue;line:blue;line.dotted;text:blue {
-+SPODE(int root) : void
-+~SPODE() = default : void
-..
-#buildModel(const torch::Tensor & weights) : void
-+graph(const std::string & name = "SPODE") const : std::vector<std::string>
-__
-}
-class "bayesnet::Ensemble" as C_0001985241386355360576
-class C_0001985241386355360576 #aliceblue;line:blue;line.dotted;text:blue {
 +Ensemble(bool predict_voting = true) : void
 +~Ensemble() = default : void
 ..
@@ -280,7 +274,7 @@ class C_0001985241386355360576 #aliceblue;line:blue;line.dotted;text:blue {
 +score(torch::Tensor & X, torch::Tensor & y) : float
 +show() const : std::vector<std::string>
 +topological_order() : std::vector<std::string>
-#trainModel(const torch::Tensor & weights) : void
+#trainModel(const torch::Tensor & weights, const Smoothing_t smoothing) : void
 #voting(torch::Tensor & votes) : torch::Tensor
 __
 #models : std::vector<std::unique_ptr<Classifier>>
@@ -288,41 +282,223 @@ __
 #predict_voting : bool
 #significanceModels : std::vector<double>
 }
-class "bayesnet::(anonymous_45089536)" as C_0001186398587753535158
+class "bayesnet::A2DE" as C_0001410789567057647859
-class C_0001186398587753535158 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0001410789567057647859 #aliceblue;line:blue;line.dotted;text:blue {
++A2DE(bool predict_voting = false) : void
++~A2DE() : void
+..
+#buildModel(const torch::Tensor & weights) : void
++graph(const std::string & title = "A2DE") const : std::vector<std::string>
++setHyperparameters(const nlohmann::json & hyperparameters) : void
+__
+}
+class "bayesnet::AODE" as C_0006288892608974306258
+class C_0006288892608974306258 #aliceblue;line:blue;line.dotted;text:blue {
++AODE(bool predict_voting = false) : void
++~AODE() : void
+..
+#buildModel(const torch::Tensor & weights) : void
++graph(const std::string & title = "AODE") const : std::vector<std::string>
++setHyperparameters(const nlohmann::json & hyperparameters) : void
+__
+}
+abstract "bayesnet::FeatureSelect" as C_0013562609546004646591
+abstract C_0013562609546004646591 #aliceblue;line:blue;line.dotted;text:blue {
++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) : void
++~FeatureSelect() : void
+..
+#computeMeritCFS() : double
+#computeSuFeatures(const int a, const int b) : double
+#computeSuLabels() : void
+{abstract} +fit() = 0 : void
++getFeatures() const : std::vector<int>
++getScores() const : std::vector<double>
+#initialize() : void
+#symmetricalUncertainty(int a, int b) : double
+__
+#fitted : bool
+#maxFeatures : int
+#selectedFeatures : std::vector<int>
+#selectedScores : std::vector<double>
+#suFeatures : std::map<std::pair<int,int>,double>
+#suLabels : std::vector<double>
+#weights : const torch::Tensor &
+}
+class "bayesnet::(anonymous_60342586)" as C_0005584545181746538542
+class C_0005584545181746538542 #aliceblue;line:blue;line.dotted;text:blue {
 __
 +CFS : std::string
 +FCBF : std::string
 +IWSS : std::string
 }
-class "bayesnet::(anonymous_45090163)" as C_0000602764946063116717
+class "bayesnet::(anonymous_60343240)" as C_0016227156982041949444
-class C_0000602764946063116717 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0016227156982041949444 #aliceblue;line:blue;line.dotted;text:blue {
 __
 +ASC : std::string
 +DESC : std::string
 +RAND : std::string
 }
-class "bayesnet::BoostAODE" as C_0000358471592399852382
+class "bayesnet::Boost" as C_0009819322948617116148
-class C_0000358471592399852382 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0009819322948617116148 #aliceblue;line:blue;line.dotted;text:blue {
++Boost(bool predict_voting = false) : void
++~Boost() = default : void
+..
+#buildModel(const torch::Tensor & weights) : void
+#featureSelection(torch::Tensor & weights_) : std::vector<int>
++setHyperparameters(const nlohmann::json & hyperparameters_) : void
+#update_weights(torch::Tensor & ytrain, torch::Tensor & ypred, torch::Tensor & weights) : std::tuple<torch::Tensor &,double,bool>
+#update_weights_block(int k, torch::Tensor & ytrain, torch::Tensor & weights) : std::tuple<torch::Tensor &,double,bool>
+__
+#X_test : torch::Tensor
+#X_train : torch::Tensor
+#bisection : bool
+#block_update : bool
+#convergence : bool
+#convergence_best : bool
+#featureSelector : FeatureSelect *
+#maxTolerance : int
+#order_algorithm : std::string
+#selectFeatures : bool
+#select_features_algorithm : std::string
+#threshold : double
+#y_test : torch::Tensor
+#y_train : torch::Tensor
+}
+class "bayesnet::AODELd" as C_0003898187834670349177
+class C_0003898187834670349177 #aliceblue;line:blue;line.dotted;text:blue {
++AODELd(bool predict_voting = true) : void
++~AODELd() = default : void
+..
+#buildModel(const torch::Tensor & weights) : void
++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_, const Smoothing_t smoothing) : AODELd &
++graph(const std::string & name = "AODELd") const : std::vector<std::string>
+#trainModel(const torch::Tensor & weights, const Smoothing_t smoothing) : void
+__
+}
+class "bayesnet::(anonymous_60275628)" as C_0009086919615463763584
+class C_0009086919615463763584 #aliceblue;line:blue;line.dotted;text:blue {
+__
++CFS : std::string
++FCBF : std::string
++IWSS : std::string
+}
+class "bayesnet::(anonymous_60276282)" as C_0015251985607563196159
+class C_0015251985607563196159 #aliceblue;line:blue;line.dotted;text:blue {
+__
++ASC : std::string
++DESC : std::string
++RAND : std::string
+}
+class "bayesnet::BoostA2DE" as C_0000272055465257861326
+class C_0000272055465257861326 #aliceblue;line:blue;line.dotted;text:blue {
++BoostA2DE(bool predict_voting = false) : void
++~BoostA2DE() = default : void
+..
++graph(const std::string & title = "BoostA2DE") const : std::vector<std::string>
+#trainModel(const torch::Tensor & weights, const Smoothing_t smoothing) : void
+__
+}
+class "bayesnet::(anonymous_60275502)" as C_0016033655851510053155
+class C_0016033655851510053155 #aliceblue;line:blue;line.dotted;text:blue {
+__
++CFS : std::string
++FCBF : std::string
++IWSS : std::string
+}
+class "bayesnet::(anonymous_60276156)" as C_0000379522761622473555
+class C_0000379522761622473555 #aliceblue;line:blue;line.dotted;text:blue {
+__
++ASC : std::string
++DESC : std::string
++RAND : std::string
+}
+class "bayesnet::BoostAODE" as C_0002867772739198819061
+class C_0002867772739198819061 #aliceblue;line:blue;line.dotted;text:blue {
 +BoostAODE(bool predict_voting = false) : void
 +~BoostAODE() = default : void
 ..
-#buildModel(const torch::Tensor & weights) : void
 +graph(const std::string & title = "BoostAODE") const : std::vector<std::string>
-+setHyperparameters(const nlohmann::json & hyperparameters_) : void
+#trainModel(const torch::Tensor & weights, const Smoothing_t smoothing) : void
-#trainModel(const torch::Tensor & weights) : void
 __
 }
-class "bayesnet::MST" as C_0000131858426172291700
+class "bayesnet::CFS" as C_0000093018845530739957
-class C_0000131858426172291700 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0000093018845530739957 #aliceblue;line:blue;line.dotted;text:blue {
++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) : void
++~CFS() : void
+..
++fit() : void
+__
+}
+class "bayesnet::FCBF" as C_0001157456122733975432
+class C_0001157456122733975432 #aliceblue;line:blue;line.dotted;text:blue {
++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) : void
++~FCBF() : void
+..
++fit() : void
+__
+}
+class "bayesnet::IWSS" as C_0000066148117395428429
+class C_0000066148117395428429 #aliceblue;line:blue;line.dotted;text:blue {
++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) : void
++~IWSS() : void
+..
++fit() : void
+__
+}
+class "bayesnet::(anonymous_60730495)" as C_0004857727320042830573
+class C_0004857727320042830573 #aliceblue;line:blue;line.dotted;text:blue {
+__
++CFS : std::string
++FCBF : std::string
++IWSS : std::string
+}
+class "bayesnet::(anonymous_60731150)" as C_0000076541533312623385
+class C_0000076541533312623385 #aliceblue;line:blue;line.dotted;text:blue {
+__
++ASC : std::string
++DESC : std::string
++RAND : std::string
+}
+class "bayesnet::(anonymous_60653004)" as C_0001444063444142949758
+class C_0001444063444142949758 #aliceblue;line:blue;line.dotted;text:blue {
+__
++CFS : std::string
++FCBF : std::string
++IWSS : std::string
+}
+class "bayesnet::(anonymous_60653658)" as C_0007139277546931322856
+class C_0007139277546931322856 #aliceblue;line:blue;line.dotted;text:blue {
+__
++ASC : std::string
++DESC : std::string
++RAND : std::string
+}
+class "bayesnet::(anonymous_60731375)" as C_0010493853592456211189
+class C_0010493853592456211189 #aliceblue;line:blue;line.dotted;text:blue {
+__
++CFS : std::string
++FCBF : std::string
++IWSS : std::string
+}
+class "bayesnet::(anonymous_60732030)" as C_0007011438637915849564
+class C_0007011438637915849564 #aliceblue;line:blue;line.dotted;text:blue {
+__
++ASC : std::string
++DESC : std::string
++RAND : std::string
+}
+class "bayesnet::MST" as C_0001054867409378333602
+class C_0001054867409378333602 #aliceblue;line:blue;line.dotted;text:blue {
 +MST() = default : void
 +MST(const std::vector<std::string> & features, const torch::Tensor & weights, const int root) : void
 ..
++insertElement(std::list<int> & variables, int variable) : void
 +maximumSpanningTree() : std::vector<std::pair<int,int>>
++reorder(std::vector<std::pair<float,std::pair<int,int>>> T, int root_original) : std::vector<std::pair<int,int>>
 __
 }
-class "bayesnet::Graph" as C_0001197041682001898467
+class "bayesnet::Graph" as C_0009576333456015187741
-class C_0001197041682001898467 #aliceblue;line:blue;line.dotted;text:blue {
+class C_0009576333456015187741 #aliceblue;line:blue;line.dotted;text:blue {
 +Graph(int V) : void
 ..
 +addEdge(int u, int v, float wt) : void
@@ -332,81 +508,73 @@ class C_0001197041682001898467 #aliceblue;line:blue;line.dotted;text:blue {
 +union_set(int u, int v) : void
 __
 }
-class "bayesnet::KDBLd" as C_0000344502277874806837
+C_0010428199432536647474 --> C_0010428199432536647474 : -parents
-class C_0000344502277874806837 #aliceblue;line:blue;line.dotted;text:blue {
+C_0010428199432536647474 --> C_0010428199432536647474 : -children
-+KDBLd(int k) : void
+C_0009493661199123436603 ..> C_0013393078277439680282
-+~KDBLd() = default : void
+C_0009493661199123436603 o-- C_0010428199432536647474 : -nodes
-..
+C_0002617087915615796317 ..> C_0013393078277439680282
-+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) : KDBLd &
+C_0002617087915615796317 ..> C_0005907365846270811004
-+graph(const std::string & name = "KDB") const : std::vector<std::string>
+C_0016351972983202413152 ..> C_0013393078277439680282
-+predict(torch::Tensor & X) : torch::Tensor
+C_0016351972983202413152 o-- C_0009493661199123436603 : #model
-{static} +version() : std::string
+C_0016351972983202413152 o-- C_0005895723015084986588 : #metrics
-__
+C_0016351972983202413152 o-- C_0005907365846270811004 : #status
-}
+C_0002617087915615796317 <|-- C_0016351972983202413152
-class "bayesnet::AODE" as C_0000786111576121788282
-class C_0000786111576121788282 #aliceblue;line:blue;line.dotted;text:blue {
-+AODE(bool predict_voting = false) : void
-+~AODE() : void
-..
-#buildModel(const torch::Tensor & weights) : void
-+graph(const std::string & title = "AODE") const : std::vector<std::string>
-+setHyperparameters(const nlohmann::json & hyperparameters) : void
-__
-}
-class "bayesnet::SPODELd" as C_0001369655639257755354
-class C_0001369655639257755354 #aliceblue;line:blue;line.dotted;text:blue {
-+SPODELd(int root) : void
-+~SPODELd() = default : void
-..
-+commonFit(const std::vector<std::string> & features, const std::string & className, std::map<std::string,std::vector<int>> & states) : SPODELd &
-+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) : SPODELd &
-+fit(torch::Tensor & dataset, const std::vector<std::string> & features, const std::string & className, std::map<std::string,std::vector<int>> & states) : SPODELd &
-+graph(const std::string & name = "SPODE") const : std::vector<std::string>
-+predict(torch::Tensor & X) : torch::Tensor
-{static} +version() : std::string
-__
-}
-class "bayesnet::AODELd" as C_0000487273479333793647
-class C_0000487273479333793647 #aliceblue;line:blue;line.dotted;text:blue {
-+AODELd(bool predict_voting = true) : void
-+~AODELd() = default : void
-..
-#buildModel(const torch::Tensor & weights) : void
-+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_) : AODELd &
-+graph(const std::string & name = "AODELd") const : std::vector<std::string>
-#trainModel(const torch::Tensor & weights) : void
-__
-}
-C_0001303524929067080934 --> C_0001303524929067080934 : -parents
-C_0001303524929067080934 --> C_0001303524929067080934 : -children
-C_0001186707649890429575 o-- C_0001303524929067080934 : -nodes
-C_0000327135989451974539 ..> C_0000738420730783851375
-C_0002043996622900301644 o-- C_0001186707649890429575 : #model
-C_0002043996622900301644 o-- C_0000736965376885623323 : #metrics
-C_0002043996622900301644 o-- C_0000738420730783851375 : #status
-C_0000327135989451974539 <|-- C_0002043996622900301644
-C_0002043996622900301644 <|-- C_0001112865019015250005
-C_0002043996622900301644 <|-- C_0001760994424884323017
-C_0002219995589162262979 ..> C_0001186707649890429575
-C_0001760994424884323017 <|-- C_0001668829096702037834
-C_0002219995589162262979 <|-- C_0001668829096702037834
-C_0000736965376885623323 <|-- C_0001695326193250580823
-C_0001695326193250580823 <|-- C_0000011627355691342494
-C_0001695326193250580823 <|-- C_0000144682015341746929
-C_0001695326193250580823 <|-- C_0000008268514674428553
-C_0002043996622900301644 <|-- C_0000512022813807538451
-C_0001985241386355360576 o-- C_0002043996622900301644 : #models
-C_0002043996622900301644 <|-- C_0001985241386355360576
-C_0000358471592399852382 --> C_0001695326193250580823 : -featureSelector
-C_0001985241386355360576 <|-- C_0000358471592399852382
-C_0001112865019015250005 <|-- C_0000344502277874806837
-C_0002219995589162262979 <|-- C_0000344502277874806837
-C_0001985241386355360576 <|-- C_0000786111576121788282
-C_0000512022813807538451 <|-- C_0001369655639257755354
-C_0002219995589162262979 <|-- C_0001369655639257755354
-C_0001985241386355360576 <|-- C_0000487273479333793647
-C_0002219995589162262979 <|-- C_0000487273479333793647
 
-'Generated with clang-uml, version 0.5.1
+C_0016351972983202413152 <|-- C_0008902920152122000044
-'LLVM version clang version 17.0.6 (Fedora 17.0.6-2.fc39)
+
+C_0016351972983202413152 <|-- C_0004096182510460307610
+
+C_0016351972983202413152 <|-- C_0016268916386101512883
+
+C_0016351972983202413152 <|-- C_0014087955399074584137
+
+C_0017759964713298103839 ..> C_0009493661199123436603
+C_0002756018222998454702 ..> C_0013393078277439680282
+C_0008902920152122000044 <|-- C_0002756018222998454702
+
+C_0017759964713298103839 <|-- C_0002756018222998454702
+
+C_0010957245114062042836 ..> C_0013393078277439680282
+C_0004096182510460307610 <|-- C_0010957245114062042836
+
+C_0017759964713298103839 <|-- C_0010957245114062042836
+
+C_0013350632773616302678 ..> C_0013393078277439680282
+C_0014087955399074584137 <|-- C_0013350632773616302678
+
+C_0017759964713298103839 <|-- C_0013350632773616302678
+
+C_0015881931090842884611 ..> C_0013393078277439680282
+C_0015881931090842884611 o-- C_0016351972983202413152 : #models
+C_0016351972983202413152 <|-- C_0015881931090842884611
+
+C_0015881931090842884611 <|-- C_0001410789567057647859
+
+C_0015881931090842884611 <|-- C_0006288892608974306258
+
+C_0005895723015084986588 <|-- C_0013562609546004646591
+
+C_0009819322948617116148 --> C_0013562609546004646591 : #featureSelector
+C_0015881931090842884611 <|-- C_0009819322948617116148
+
+C_0003898187834670349177 ..> C_0013393078277439680282
+C_0015881931090842884611 <|-- C_0003898187834670349177
+
+C_0017759964713298103839 <|-- C_0003898187834670349177
+
+C_0000272055465257861326 ..> C_0013393078277439680282
+C_0009819322948617116148 <|-- C_0000272055465257861326
+
+C_0002867772739198819061 ..> C_0013393078277439680282
+C_0009819322948617116148 <|-- C_0002867772739198819061
+
+C_0013562609546004646591 <|-- C_0000093018845530739957
+
+C_0013562609546004646591 <|-- C_0001157456122733975432
+
+C_0013562609546004646591 <|-- C_0000066148117395428429
+
+
+'Generated with clang-uml, version 0.5.5
+'LLVM version clang version 18.1.8 (Fedora 18.1.8-5.fc41)
 @enduml

diagrams/dependency.svg

@@ -1,128 +1,314 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<!-- Generated by graphviz version 8.1.0 (20230707.0739)
+<!-- Generated by graphviz version 12.1.0 (20240811.2233)
  -->
 <!-- Title: BayesNet Pages: 1 -->
-<svg width="1632pt" height="288pt"
+<svg width="3725pt" height="432pt"
- viewBox="0.00 0.00 1631.95 287.80" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+ viewBox="0.00 0.00 3724.84 431.80" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 283.8)">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 427.8)">
 <title>BayesNet</title>
-<polygon fill="white" stroke="none" points="-4,4 -4,-283.8 1627.95,-283.8 1627.95,4 -4,4"/>
+<polygon fill="white" stroke="none" points="-4,4 -4,-427.8 3720.84,-427.8 3720.84,4 -4,4"/>
-<!-- node1 -->
+<!-- node0 -->
 <g id="node1" class="node">
+<title>node0</title>
+<polygon fill="none" stroke="black" points="1655.43,-398.35 1655.43,-413.26 1625.69,-423.8 1583.63,-423.8 1553.89,-413.26 1553.89,-398.35 1583.63,-387.8 1625.69,-387.8 1655.43,-398.35"/>
+<text text-anchor="middle" x="1604.66" y="-401.53" font-family="Times,serif" font-size="12.00">BayesNet</text>
+</g>
+<!-- node1 -->
+<g id="node2" class="node">
 <title>node1</title>
-<polygon fill="none" stroke="black" points="826.43,-254.35 826.43,-269.26 796.69,-279.8 754.63,-279.8 724.89,-269.26 724.89,-254.35 754.63,-243.8 796.69,-243.8 826.43,-254.35"/>
+<polygon fill="none" stroke="black" points="413.32,-257.8 372.39,-273.03 206.66,-279.8 40.93,-273.03 0,-257.8 114.69,-245.59 298.64,-245.59 413.32,-257.8"/>
-<text text-anchor="middle" x="775.66" y="-257.53" font-family="Times,serif" font-size="12.00">BayesNet</text>
+<text text-anchor="middle" x="206.66" y="-257.53" font-family="Times,serif" font-size="12.00">/home/rmontanana/Code/libtorch/lib/libc10.so</text>
+</g>
+<!-- node0&#45;&gt;node1 -->
+<g id="edge1" class="edge">
+<title>node0&#45;&gt;node1</title>
+<path fill="none" stroke="black" d="M1553.59,-400.53C1451.65,-391.91 1215.69,-371.61 1017.66,-351.8 773.36,-327.37 488.07,-295.22 329.31,-277.01"/>
+<polygon fill="black" stroke="black" points="329.93,-273.56 319.6,-275.89 329.14,-280.51 329.93,-273.56"/>
 </g>
 <!-- node2 -->
-<g id="node2" class="node">
+<g id="node3" class="node">
 <title>node2</title>
-<polygon fill="none" stroke="black" points="413.32,-185.8 372.39,-201.03 206.66,-207.8 40.93,-201.03 0,-185.8 114.69,-173.59 298.64,-173.59 413.32,-185.8"/>
+<polygon fill="none" stroke="black" points="894.21,-257.8 848.35,-273.03 662.66,-279.8 476.98,-273.03 431.12,-257.8 559.61,-245.59 765.71,-245.59 894.21,-257.8"/>
-<text text-anchor="middle" x="206.66" y="-185.53" font-family="Times,serif" font-size="12.00">/home/rmontanana/Code/libtorch/lib/libc10.so</text>
+<text text-anchor="middle" x="662.66" y="-257.53" font-family="Times,serif" font-size="12.00">/home/rmontanana/Code/libtorch/lib/libc10_cuda.so</text>
 </g>
-<!-- node1&#45;&gt;node2 -->
+<!-- node0&#45;&gt;node2 -->
-<g id="edge1" class="edge">
+<g id="edge2" class="edge">
-<title>node1&#45;&gt;node2</title>
+<title>node0&#45;&gt;node2</title>
-<path fill="none" stroke="black" d="M724.41,-254.5C634.7,-243.46 447.04,-220.38 324.01,-205.24"/>
+<path fill="none" stroke="black" d="M1555.34,-397.37C1408.12,-375.18 969.52,-309.06 767.13,-278.55"/>
-<polygon fill="black" stroke="black" points="324.77,-201.69 314.42,-203.94 323.92,-208.63 324.77,-201.69"/>
+<polygon fill="black" stroke="black" points="767.81,-275.12 757.4,-277.09 766.77,-282.04 767.81,-275.12"/>
 </g>
 <!-- node3 -->
-<g id="node3" class="node">
+<g id="node4" class="node">
 <title>node3</title>
-<polygon fill="none" stroke="black" points="857.68,-185.8 815.49,-201.03 644.66,-207.8 473.84,-201.03 431.65,-185.8 549.86,-173.59 739.46,-173.59 857.68,-185.8"/>
+<polygon fill="none" stroke="black" points="1338.68,-257.8 1296.49,-273.03 1125.66,-279.8 954.84,-273.03 912.65,-257.8 1030.86,-245.59 1220.46,-245.59 1338.68,-257.8"/>
-<text text-anchor="middle" x="644.66" y="-185.53" font-family="Times,serif" font-size="12.00">/home/rmontanana/Code/libtorch/lib/libkineto.a</text>
+<text text-anchor="middle" x="1125.66" y="-257.53" font-family="Times,serif" font-size="12.00">/home/rmontanana/Code/libtorch/lib/libkineto.a</text>
 </g>
-<!-- node1&#45;&gt;node3 -->
+<!-- node0&#45;&gt;node3 -->
-<g id="edge2" class="edge">
+<g id="edge3" class="edge">
-<title>node1&#45;&gt;node3</title>
+<title>node0&#45;&gt;node3</title>
-<path fill="none" stroke="black" d="M747.56,-245.79C729.21,-235.98 704.97,-223.03 684.63,-212.16"/>
+<path fill="none" stroke="black" d="M1566.68,-393.54C1484.46,-369.17 1289.3,-311.32 1188.44,-281.41"/>
-<polygon fill="black" stroke="black" points="686.47,-208.64 676,-207.02 683.17,-214.82 686.47,-208.64"/>
+<polygon fill="black" stroke="black" points="1189.53,-278.09 1178.95,-278.6 1187.54,-284.8 1189.53,-278.09"/>
 </g>
 <!-- node4 -->
-<g id="node4" class="node">
-<title>node4</title>
-<polygon fill="none" stroke="black" points="939.33,-182.35 939.33,-197.26 920.78,-207.8 894.54,-207.8 875.99,-197.26 875.99,-182.35 894.54,-171.8 920.78,-171.8 939.33,-182.35"/>
-<text text-anchor="middle" x="907.66" y="-185.53" font-family="Times,serif" font-size="12.00">mdlp</text>
-</g>
-<!-- node1&#45;&gt;node4 -->
-<g id="edge3" class="edge">
-<title>node1&#45;&gt;node4</title>
-<path fill="none" stroke="black" d="M803.66,-245.96C824.66,-234.82 853.45,-219.56 875.41,-207.91"/>
-<polygon fill="black" stroke="black" points="876.78,-210.61 883.97,-202.84 873.5,-204.43 876.78,-210.61"/>
-</g>
-<!-- node9 -->
 <g id="node5" class="node">
-<title>node9</title>
+<title>node4</title>
-<polygon fill="none" stroke="black" points="1107.74,-195.37 1032.66,-207.8 957.58,-195.37 986.26,-175.24 1079.06,-175.24 1107.74,-195.37"/>
+<polygon fill="none" stroke="black" points="1552.26,-257.8 1532.93,-273.03 1454.66,-279.8 1376.4,-273.03 1357.07,-257.8 1411.23,-245.59 1498.1,-245.59 1552.26,-257.8"/>
-<text text-anchor="middle" x="1032.66" y="-185.53" font-family="Times,serif" font-size="12.00">torch_library</text>
+<text text-anchor="middle" x="1454.66" y="-257.53" font-family="Times,serif" font-size="12.00">/usr/lib64/libcuda.so</text>
 </g>
-<!-- node1&#45;&gt;node9 -->
+<!-- node0&#45;&gt;node4 -->
 <g id="edge4" class="edge">
-<title>node1&#45;&gt;node9</title>
+<title>node0&#45;&gt;node4</title>
-<path fill="none" stroke="black" d="M815.25,-250.02C860.25,-237.77 933.77,-217.74 982.68,-204.42"/>
+<path fill="none" stroke="black" d="M1586.27,-387.39C1559.5,-362.05 1509.72,-314.92 1479.65,-286.46"/>
-<polygon fill="black" stroke="black" points="983.3,-207.61 992.02,-201.6 981.46,-200.85 983.3,-207.61"/>
+<polygon fill="black" stroke="black" points="1482.13,-283.99 1472.46,-279.65 1477.31,-289.07 1482.13,-283.99"/>
-</g>
-<!-- node10 -->
-<g id="node6" class="node">
-<title>node10</title>
-<polygon fill="none" stroke="black" points="1159.81,-113.8 1086.89,-129.03 791.66,-135.8 496.43,-129.03 423.52,-113.8 627.82,-101.59 955.5,-101.59 1159.81,-113.8"/>
-<text text-anchor="middle" x="791.66" y="-113.53" font-family="Times,serif" font-size="12.00">&#45;Wl,&#45;&#45;no&#45;as&#45;needed,&quot;/home/rmontanana/Code/libtorch/lib/libtorch.so&quot; &#45;Wl,&#45;&#45;as&#45;needed</text>
-</g>
-<!-- node9&#45;&gt;node10 -->
-<g id="edge5" class="edge">
-<title>node9&#45;&gt;node10</title>
-<path fill="none" stroke="black" stroke-dasharray="5,2" d="M985.62,-175.14C949.2,-164.56 898.31,-149.78 857.79,-138.01"/>
-<polygon fill="black" stroke="black" points="859.04,-134.44 848.46,-135.01 857.09,-141.16 859.04,-134.44"/>
 </g>
 <!-- node5 -->
-<g id="node7" class="node">
+<g id="node6" class="node">
 <title>node5</title>
-<polygon fill="none" stroke="black" points="1371.56,-123.37 1274.66,-135.8 1177.77,-123.37 1214.78,-103.24 1334.55,-103.24 1371.56,-123.37"/>
+<polygon fill="none" stroke="black" points="1873.26,-257.8 1843.23,-273.03 1721.66,-279.8 1600.09,-273.03 1570.06,-257.8 1654.19,-245.59 1789.13,-245.59 1873.26,-257.8"/>
-<text text-anchor="middle" x="1274.66" y="-113.53" font-family="Times,serif" font-size="12.00">torch_cpu_library</text>
+<text text-anchor="middle" x="1721.66" y="-257.53" font-family="Times,serif" font-size="12.00">/usr/local/cuda/lib64/libcudart.so</text>
 </g>
-<!-- node9&#45;&gt;node5 -->
+<!-- node0&#45;&gt;node5 -->
-<g id="edge6" class="edge">
+<g id="edge5" class="edge">
-<title>node9&#45;&gt;node5</title>
+<title>node0&#45;&gt;node5</title>
-<path fill="none" stroke="black" stroke-dasharray="5,2" d="M1079.61,-175.22C1120.66,-163.35 1180.2,-146.13 1222.68,-133.84"/>
+<path fill="none" stroke="black" d="M1619.76,-387.77C1628.83,-377.46 1640.53,-363.98 1650.66,-351.8 1668.32,-330.59 1687.84,-306.03 1701.94,-288.1"/>
-<polygon fill="black" stroke="black" points="1223.46,-136.97 1232.09,-130.83 1221.51,-130.24 1223.46,-136.97"/>
+<polygon fill="black" stroke="black" points="1704.43,-290.59 1707.84,-280.56 1698.92,-286.27 1704.43,-290.59"/>
 </g>
 <!-- node6 -->
-<g id="node8" class="node">
+<g id="node7" class="node">
 <title>node6</title>
-<polygon fill="none" stroke="black" points="1191.4,-27.9 1114.6,-43.12 803.66,-49.9 492.72,-43.12 415.93,-27.9 631.1,-15.68 976.22,-15.68 1191.4,-27.9"/>
+<polygon fill="none" stroke="black" points="2231.79,-257.8 2198.1,-273.03 2061.66,-279.8 1925.23,-273.03 1891.53,-257.8 1985.95,-245.59 2137.38,-245.59 2231.79,-257.8"/>
-<text text-anchor="middle" x="803.66" y="-27.63" font-family="Times,serif" font-size="12.00">&#45;Wl,&#45;&#45;no&#45;as&#45;needed,&quot;/home/rmontanana/Code/libtorch/lib/libtorch_cpu.so&quot; &#45;Wl,&#45;&#45;as&#45;needed</text>
+<text text-anchor="middle" x="2061.66" y="-257.53" font-family="Times,serif" font-size="12.00">/usr/local/cuda/lib64/libnvToolsExt.so</text>
 </g>
-<!-- node5&#45;&gt;node6 -->
+<!-- node0&#45;&gt;node6 -->
-<g id="edge7" class="edge">
+<g id="edge6" class="edge">
-<title>node5&#45;&gt;node6</title>
+<title>node0&#45;&gt;node6</title>
-<path fill="none" stroke="black" stroke-dasharray="5,2" d="M1210.16,-105.31C1130.55,-91.13 994.37,-66.87 901.77,-50.38"/>
+<path fill="none" stroke="black" d="M1642.06,-393.18C1721.31,-368.56 1906.71,-310.95 2002.32,-281.24"/>
-<polygon fill="black" stroke="black" points="902.44,-46.77 891.98,-48.46 901.22,-53.66 902.44,-46.77"/>
+<polygon fill="black" stroke="black" points="2003.28,-284.61 2011.79,-278.3 2001.21,-277.92 2003.28,-284.61"/>
 </g>
 <!-- node7 -->
-<g id="node9" class="node">
+<g id="node8" class="node">
 <title>node7</title>
-<polygon fill="none" stroke="black" points="1339.72,-37.46 1274.66,-49.9 1209.61,-37.46 1234.46,-17.34 1314.87,-17.34 1339.72,-37.46"/>
+<polygon fill="none" stroke="black" points="2541.44,-257.8 2512.56,-273.03 2395.66,-279.8 2278.76,-273.03 2249.89,-257.8 2330.79,-245.59 2460.54,-245.59 2541.44,-257.8"/>
-<text text-anchor="middle" x="1274.66" y="-27.63" font-family="Times,serif" font-size="12.00">caffe2::mkl</text>
+<text text-anchor="middle" x="2395.66" y="-257.53" font-family="Times,serif" font-size="12.00">/usr/local/cuda/lib64/libnvrtc.so</text>
 </g>
-<!-- node5&#45;&gt;node7 -->
+<!-- node0&#45;&gt;node7 -->
-<g id="edge8" class="edge">
+<g id="edge7" class="edge">
-<title>node5&#45;&gt;node7</title>
+<title>node0&#45;&gt;node7</title>
-<path fill="none" stroke="black" stroke-dasharray="5,2" d="M1274.66,-102.95C1274.66,-91.56 1274.66,-75.07 1274.66,-60.95"/>
+<path fill="none" stroke="black" d="M1651.19,-396.45C1780.36,-373.26 2144.76,-307.85 2311.05,-277.99"/>
-<polygon fill="black" stroke="black" points="1278.16,-61.27 1274.66,-51.27 1271.16,-61.27 1278.16,-61.27"/>
+<polygon fill="black" stroke="black" points="2311.47,-281.47 2320.7,-276.26 2310.24,-274.58 2311.47,-281.47"/>
 </g>
 <!-- node8 -->
-<g id="node10" class="node">
+<g id="node9" class="node">
 <title>node8</title>
-<polygon fill="none" stroke="black" points="1623.95,-41.76 1490.66,-63.8 1357.37,-41.76 1408.28,-6.09 1573.04,-6.09 1623.95,-41.76"/>
+<polygon fill="none" stroke="black" points="1642.01,-326.35 1642.01,-341.26 1620.13,-351.8 1589.19,-351.8 1567.31,-341.26 1567.31,-326.35 1589.19,-315.8 1620.13,-315.8 1642.01,-326.35"/>
-<text text-anchor="middle" x="1490.66" y="-34.75" font-family="Times,serif" font-size="12.00">dummy</text>
+<text text-anchor="middle" x="1604.66" y="-329.53" font-family="Times,serif" font-size="12.00">fimdlp</text>
-<text text-anchor="middle" x="1490.66" y="-20.5" font-family="Times,serif" font-size="12.00">(protobuf::libprotobuf)</text>
 </g>
-<!-- node5&#45;&gt;node8 -->
+<!-- node0&#45;&gt;node8 -->
+<g id="edge8" class="edge">
+<title>node0&#45;&gt;node8</title>
+<path fill="none" stroke="black" d="M1604.66,-387.5C1604.66,-380.21 1604.66,-371.53 1604.66,-363.34"/>
+<polygon fill="black" stroke="black" points="1608.16,-363.42 1604.66,-353.42 1601.16,-363.42 1608.16,-363.42"/>
+</g>
+<!-- node19 -->
+<g id="node10" class="node">
+<title>node19</title>
+<polygon fill="none" stroke="black" points="2709.74,-267.37 2634.66,-279.8 2559.58,-267.37 2588.26,-247.24 2681.06,-247.24 2709.74,-267.37"/>
+<text text-anchor="middle" x="2634.66" y="-257.53" font-family="Times,serif" font-size="12.00">torch_library</text>
+</g>
+<!-- node0&#45;&gt;node19 -->
+<g id="edge29" class="edge">
+<title>node0&#45;&gt;node19</title>
+<path fill="none" stroke="black" d="M1655.87,-399.32C1798.23,-383.79 2210.64,-336.94 2550.66,-279.8 2559.43,-278.33 2568.68,-276.62 2577.72,-274.86"/>
+<polygon fill="black" stroke="black" points="2578.38,-278.3 2587.5,-272.92 2577.01,-271.43 2578.38,-278.3"/>
+</g>
+<!-- node8&#45;&gt;node1 -->
 <g id="edge9" class="edge">
-<title>node5&#45;&gt;node8</title>
+<title>node8&#45;&gt;node1</title>
-<path fill="none" stroke="black" stroke-dasharray="5,2" d="M1310.82,-102.76C1341.68,-90.77 1386.88,-73.21 1424.25,-58.7"/>
+<path fill="none" stroke="black" d="M1566.84,-331.58C1419.81,-326.72 872.06,-307.69 421.66,-279.8 401.07,-278.53 379.38,-277.02 358.03,-275.43"/>
-<polygon fill="black" stroke="black" points="1425.01,-61.77 1433.06,-54.89 1422.47,-55.25 1425.01,-61.77"/>
+<polygon fill="black" stroke="black" points="358.3,-271.94 348.06,-274.67 357.77,-278.92 358.3,-271.94"/>
+</g>
+<!-- node8&#45;&gt;node2 -->
+<g id="edge10" class="edge">
+<title>node8&#45;&gt;node2</title>
+<path fill="none" stroke="black" d="M1566.86,-330C1445.11,-320.95 1057.97,-292.18 831.67,-275.36"/>
+<polygon fill="black" stroke="black" points="832.09,-271.89 821.86,-274.63 831.57,-278.87 832.09,-271.89"/>
+</g>
+<!-- node8&#45;&gt;node3 -->
+<g id="edge11" class="edge">
+<title>node8&#45;&gt;node3</title>
+<path fill="none" stroke="black" d="M1567.08,-327.31C1495.4,-316.84 1336.86,-293.67 1230.62,-278.14"/>
+<polygon fill="black" stroke="black" points="1231.44,-274.72 1221.04,-276.74 1230.42,-281.65 1231.44,-274.72"/>
+</g>
+<!-- node8&#45;&gt;node4 -->
+<g id="edge12" class="edge">
+<title>node8&#45;&gt;node4</title>
+<path fill="none" stroke="black" d="M1578.53,-320.61C1555.96,-310.08 1522.92,-294.66 1496.64,-282.4"/>
+<polygon fill="black" stroke="black" points="1498.12,-279.22 1487.58,-278.17 1495.16,-285.57 1498.12,-279.22"/>
+</g>
+<!-- node8&#45;&gt;node5 -->
+<g id="edge13" class="edge">
+<title>node8&#45;&gt;node5</title>
+<path fill="none" stroke="black" d="M1627.78,-318.97C1644.15,-309.18 1666.44,-295.84 1685.2,-284.62"/>
+<polygon fill="black" stroke="black" points="1686.83,-287.73 1693.61,-279.59 1683.23,-281.72 1686.83,-287.73"/>
+</g>
+<!-- node8&#45;&gt;node6 -->
+<g id="edge14" class="edge">
+<title>node8&#45;&gt;node6</title>
+<path fill="none" stroke="black" d="M1642.45,-327.02C1712.36,-316.31 1863.89,-293.1 1964.32,-277.71"/>
+<polygon fill="black" stroke="black" points="1964.84,-281.18 1974.2,-276.2 1963.78,-274.26 1964.84,-281.18"/>
+</g>
+<!-- node8&#45;&gt;node7 -->
+<g id="edge15" class="edge">
+<title>node8&#45;&gt;node7</title>
+<path fill="none" stroke="black" d="M1642.33,-330.01C1740.75,-322.64 2013.75,-301.7 2240.66,-279.8 2254.16,-278.5 2268.32,-277.06 2282.35,-275.58"/>
+<polygon fill="black" stroke="black" points="2282.49,-279.08 2292.06,-274.54 2281.75,-272.12 2282.49,-279.08"/>
+</g>
+<!-- node8&#45;&gt;node19 -->
+<g id="edge16" class="edge">
+<title>node8&#45;&gt;node19</title>
+<path fill="none" stroke="black" d="M1642.25,-332.63C1770.06,-331.64 2199.48,-324.94 2550.66,-279.8 2560.1,-278.59 2570.07,-276.92 2579.71,-275.1"/>
+<polygon fill="black" stroke="black" points="2580.21,-278.57 2589.34,-273.21 2578.86,-271.7 2580.21,-278.57"/>
+</g>
+<!-- node20 -->
+<g id="node11" class="node">
+<title>node20</title>
+<polygon fill="none" stroke="black" points="2606.81,-185.8 2533.89,-201.03 2238.66,-207.8 1943.43,-201.03 1870.52,-185.8 2074.82,-173.59 2402.5,-173.59 2606.81,-185.8"/>
+<text text-anchor="middle" x="2238.66" y="-185.53" font-family="Times,serif" font-size="12.00">&#45;Wl,&#45;&#45;no&#45;as&#45;needed,&quot;/home/rmontanana/Code/libtorch/lib/libtorch.so&quot; &#45;Wl,&#45;&#45;as&#45;needed</text>
+</g>
+<!-- node19&#45;&gt;node20 -->
+<g id="edge17" class="edge">
+<title>node19&#45;&gt;node20</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M2583.63,-250.21C2572.76,-248.03 2561.34,-245.79 2550.66,-243.8 2482.14,-231.05 2404.92,-217.93 2344.44,-207.93"/>
+<polygon fill="black" stroke="black" points="2345.28,-204.52 2334.84,-206.34 2344.14,-211.42 2345.28,-204.52"/>
+</g>
+<!-- node9 -->
+<g id="node12" class="node">
+<title>node9</title>
+<polygon fill="none" stroke="black" points="2542.56,-123.37 2445.66,-135.8 2348.77,-123.37 2385.78,-103.24 2505.55,-103.24 2542.56,-123.37"/>
+<text text-anchor="middle" x="2445.66" y="-113.53" font-family="Times,serif" font-size="12.00">torch_cpu_library</text>
+</g>
+<!-- node19&#45;&gt;node9 -->
+<g id="edge18" class="edge">
+<title>node19&#45;&gt;node9</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M2635.72,-246.84C2636.4,-227.49 2634.61,-192.58 2615.66,-171.8 2601.13,-155.87 2551.93,-141.56 2510.18,-131.84"/>
+<polygon fill="black" stroke="black" points="2511.2,-128.48 2500.67,-129.68 2509.65,-135.31 2511.2,-128.48"/>
+</g>
+<!-- node13 -->
+<g id="node16" class="node">
+<title>node13</title>
+<polygon fill="none" stroke="black" points="3056.45,-195.37 2953.66,-207.8 2850.87,-195.37 2890.13,-175.24 3017.19,-175.24 3056.45,-195.37"/>
+<text text-anchor="middle" x="2953.66" y="-185.53" font-family="Times,serif" font-size="12.00">torch_cuda_library</text>
+</g>
+<!-- node19&#45;&gt;node13 -->
+<g id="edge22" class="edge">
+<title>node19&#45;&gt;node13</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M2685.21,-249.71C2741.11,-237.45 2831.21,-217.67 2891.42,-204.46"/>
+<polygon fill="black" stroke="black" points="2891.8,-207.96 2900.82,-202.4 2890.3,-201.13 2891.8,-207.96"/>
+</g>
+<!-- node10 -->
+<g id="node13" class="node">
+<title>node10</title>
+<polygon fill="none" stroke="black" points="2362.4,-27.9 2285.6,-43.12 1974.66,-49.9 1663.72,-43.12 1586.93,-27.9 1802.1,-15.68 2147.22,-15.68 2362.4,-27.9"/>
+<text text-anchor="middle" x="1974.66" y="-27.63" font-family="Times,serif" font-size="12.00">&#45;Wl,&#45;&#45;no&#45;as&#45;needed,&quot;/home/rmontanana/Code/libtorch/lib/libtorch_cpu.so&quot; &#45;Wl,&#45;&#45;as&#45;needed</text>
+</g>
+<!-- node9&#45;&gt;node10 -->
+<g id="edge19" class="edge">
+<title>node9&#45;&gt;node10</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M2381.16,-105.31C2301.63,-91.15 2165.65,-66.92 2073.05,-50.43"/>
+<polygon fill="black" stroke="black" points="2073.93,-47.03 2063.48,-48.72 2072.71,-53.92 2073.93,-47.03"/>
+</g>
+<!-- node11 -->
+<g id="node14" class="node">
+<title>node11</title>
+<polygon fill="none" stroke="black" points="2510.72,-37.46 2445.66,-49.9 2380.61,-37.46 2405.46,-17.34 2485.87,-17.34 2510.72,-37.46"/>
+<text text-anchor="middle" x="2445.66" y="-27.63" font-family="Times,serif" font-size="12.00">caffe2::mkl</text>
+</g>
+<!-- node9&#45;&gt;node11 -->
+<g id="edge20" class="edge">
+<title>node9&#45;&gt;node11</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M2445.66,-102.95C2445.66,-91.68 2445.66,-75.4 2445.66,-61.37"/>
+<polygon fill="black" stroke="black" points="2449.16,-61.78 2445.66,-51.78 2442.16,-61.78 2449.16,-61.78"/>
+</g>
+<!-- node12 -->
+<g id="node15" class="node">
+<title>node12</title>
+<polygon fill="none" stroke="black" points="2794.95,-41.76 2661.66,-63.8 2528.37,-41.76 2579.28,-6.09 2744.04,-6.09 2794.95,-41.76"/>
+<text text-anchor="middle" x="2661.66" y="-34.75" font-family="Times,serif" font-size="12.00">dummy</text>
+<text text-anchor="middle" x="2661.66" y="-20.5" font-family="Times,serif" font-size="12.00">(protobuf::libprotobuf)</text>
+</g>
+<!-- node9&#45;&gt;node12 -->
+<g id="edge21" class="edge">
+<title>node9&#45;&gt;node12</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M2481.82,-102.76C2512.55,-90.82 2557.5,-73.36 2594.77,-58.89"/>
+<polygon fill="black" stroke="black" points="2595.6,-62.32 2603.65,-55.44 2593.06,-55.79 2595.6,-62.32"/>
+</g>
+<!-- node13&#45;&gt;node9 -->
+<g id="edge28" class="edge">
+<title>node13&#45;&gt;node9</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M2880.59,-179.79C2799.97,-169.71 2666.42,-152.57 2551.66,-135.8 2540.2,-134.13 2528.06,-132.27 2516.24,-130.41"/>
+<polygon fill="black" stroke="black" points="2516.96,-126.98 2506.54,-128.86 2515.87,-133.89 2516.96,-126.98"/>
+</g>
+<!-- node14 -->
+<g id="node17" class="node">
+<title>node14</title>
+<polygon fill="none" stroke="black" points="3346.69,-113.8 3268.85,-129.03 2953.66,-135.8 2638.48,-129.03 2560.63,-113.8 2778.75,-101.59 3128.58,-101.59 3346.69,-113.8"/>
+<text text-anchor="middle" x="2953.66" y="-113.53" font-family="Times,serif" font-size="12.00">&#45;Wl,&#45;&#45;no&#45;as&#45;needed,&quot;/home/rmontanana/Code/libtorch/lib/libtorch_cuda.so&quot; &#45;Wl,&#45;&#45;as&#45;needed</text>
+</g>
+<!-- node13&#45;&gt;node14 -->
+<g id="edge23" class="edge">
+<title>node13&#45;&gt;node14</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M2953.66,-174.97C2953.66,-167.13 2953.66,-157.01 2953.66,-147.53"/>
+<polygon fill="black" stroke="black" points="2957.16,-147.59 2953.66,-137.59 2950.16,-147.59 2957.16,-147.59"/>
+</g>
+<!-- node15 -->
+<g id="node18" class="node">
+<title>node15</title>
+<polygon fill="none" stroke="black" points="3514.74,-123.37 3439.66,-135.8 3364.58,-123.37 3393.26,-103.24 3486.06,-103.24 3514.74,-123.37"/>
+<text text-anchor="middle" x="3439.66" y="-113.53" font-family="Times,serif" font-size="12.00">torch::cudart</text>
+</g>
+<!-- node13&#45;&gt;node15 -->
+<g id="edge24" class="edge">
+<title>node13&#45;&gt;node15</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M3028.35,-180.51C3109.24,-171.17 3241.96,-154.78 3355.66,-135.8 3364.43,-134.34 3373.69,-132.63 3382.72,-130.88"/>
+<polygon fill="black" stroke="black" points="3383.38,-134.31 3392.51,-128.93 3382.02,-127.45 3383.38,-134.31"/>
+</g>
+<!-- node17 -->
+<g id="node20" class="node">
+<title>node17</title>
+<polygon fill="none" stroke="black" points="3716.84,-123.37 3624.66,-135.8 3532.48,-123.37 3567.69,-103.24 3681.63,-103.24 3716.84,-123.37"/>
+<text text-anchor="middle" x="3624.66" y="-113.53" font-family="Times,serif" font-size="12.00">torch::nvtoolsext</text>
+</g>
+<!-- node13&#45;&gt;node17 -->
+<g id="edge26" class="edge">
+<title>node13&#45;&gt;node17</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M3033.64,-183.25C3144.1,-175.14 3349.47,-158.53 3523.66,-135.8 3534.84,-134.35 3546.67,-132.57 3558.15,-130.72"/>
+<polygon fill="black" stroke="black" points="3558.68,-134.18 3567.98,-129.1 3557.54,-127.27 3558.68,-134.18"/>
+</g>
+<!-- node16 -->
+<g id="node19" class="node">
+<title>node16</title>
+<polygon fill="none" stroke="black" points="3510.78,-27.9 3496.7,-43.12 3439.66,-49.9 3382.63,-43.12 3368.54,-27.9 3408.01,-15.68 3471.31,-15.68 3510.78,-27.9"/>
+<text text-anchor="middle" x="3439.66" y="-27.63" font-family="Times,serif" font-size="12.00">CUDA::cudart</text>
+</g>
+<!-- node15&#45;&gt;node16 -->
+<g id="edge25" class="edge">
+<title>node15&#45;&gt;node16</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M3439.66,-102.95C3439.66,-91.68 3439.66,-75.4 3439.66,-61.37"/>
+<polygon fill="black" stroke="black" points="3443.16,-61.78 3439.66,-51.78 3436.16,-61.78 3443.16,-61.78"/>
+</g>
+<!-- node18 -->
+<g id="node21" class="node">
+<title>node18</title>
+<polygon fill="none" stroke="black" points="3714.32,-27.9 3696.56,-43.12 3624.66,-49.9 3552.77,-43.12 3535.01,-27.9 3584.76,-15.68 3664.56,-15.68 3714.32,-27.9"/>
+<text text-anchor="middle" x="3624.66" y="-27.63" font-family="Times,serif" font-size="12.00">CUDA::nvToolsExt</text>
+</g>
+<!-- node17&#45;&gt;node18 -->
+<g id="edge27" class="edge">
+<title>node17&#45;&gt;node18</title>
+<path fill="none" stroke="black" stroke-dasharray="5,2" d="M3624.66,-102.95C3624.66,-91.68 3624.66,-75.4 3624.66,-61.37"/>
+<polygon fill="black" stroke="black" points="3628.16,-61.78 3624.66,-51.78 3621.16,-61.78 3628.16,-61.78"/>
 </g>
 </g>
 </svg>

sample/CMakeLists.txt

@@ -8,7 +8,6 @@ find_package(Torch REQUIRED)
 find_library(BayesNet NAMES libBayesNet BayesNet libBayesNet.a  REQUIRED)
 find_path(Bayesnet_INCLUDE_DIRS REQUIRED NAMES bayesnet)
 find_library(FImdlp NAMES libfimdlp.a  PATHS REQUIRED)
-find_path(FImdlp_INCLUDE_DIRS REQUIRED NAMES fimdlp)
 
 message(STATUS "FImdlp=${FImdlp}")
 message(STATUS "FImdlp_INCLUDE_DIRS=${FImdlp_INCLUDE_DIRS}")
@@ -23,4 +22,4 @@ include_directories(
 )
 
 add_executable(bayesnet_sample sample.cc) 
-target_link_libraries(bayesnet_sample ${FImdlp} "${TORCH_LIBRARIES}" "${BayesNet}")
+target_link_libraries(bayesnet_sample fimdlp "${TORCH_LIBRARIES}" "${BayesNet}")

sample/sample.cc

@@ -5,7 +5,7 @@
 // ***************************************************************
 
 #include <ArffFiles.hpp>
-#include <fimdlp/CPPFImdlp.h>
+#include <CPPFImdlp.h>
 #include <bayesnet/ensembles/BoostAODE.h>
 
 std::vector<mdlp::labels_t> discretizeDataset(std::vector<mdlp::samples_t>& X, mdlp::labels_t& y)

tests/CMakeLists.txt

@@ -6,13 +6,12 @@ if(ENABLE_TESTING)
         ${BayesNet_SOURCE_DIR}/lib/json/include
         ${BayesNet_SOURCE_DIR}
         ${CMAKE_BINARY_DIR}/configured_files/include
-        ${FImdlp_INCLUDE_DIRS}
     )
     file(GLOB_RECURSE BayesNet_SOURCES "${BayesNet_SOURCE_DIR}/bayesnet/*.cc")
     add_executable(TestBayesNet TestBayesNetwork.cc TestBayesNode.cc TestBayesClassifier.cc 
         TestBayesModels.cc TestBayesMetrics.cc TestFeatureSelection.cc TestBoostAODE.cc TestA2DE.cc 
-        TestUtils.cc TestBayesEnsemble.cc TestModulesVersions.cc TestBoostA2DE.cc ${BayesNet_SOURCES})
+        TestUtils.cc TestBayesEnsemble.cc TestModulesVersions.cc TestBoostA2DE.cc TestMST.cc ${BayesNet_SOURCES})
-    target_link_libraries(TestBayesNet PUBLIC "${TORCH_LIBRARIES}" mdlp PRIVATE Catch2::Catch2WithMain)
+    target_link_libraries(TestBayesNet PUBLIC "${TORCH_LIBRARIES}" fimdlp PRIVATE Catch2::Catch2WithMain)
     add_test(NAME BayesNetworkTest COMMAND TestBayesNet)
     add_test(NAME A2DE COMMAND TestBayesNet "[A2DE]")
     add_test(NAME BoostA2DE COMMAND TestBayesNet "[BoostA2DE]")
@@ -25,4 +24,5 @@ if(ENABLE_TESTING)
     add_test(NAME Modules COMMAND TestBayesNet "[Modules]")
     add_test(NAME Network COMMAND TestBayesNet "[Network]")
     add_test(NAME Node COMMAND TestBayesNet "[Node]")
+    add_test(NAME MST COMMAND TestBayesNet "[MST]")
 endif(ENABLE_TESTING)

tests/TestA2DE.cc

@@ -45,5 +45,5 @@ TEST_CASE("Test graph", "[A2DE]")
     auto graph = clf.graph();
     REQUIRE(graph.size() == 78);
     REQUIRE(graph[0] == "digraph BayesNet {\nlabel=<BayesNet A2DE_0>\nfontsize=30\nfontcolor=blue\nlabelloc=t\nlayout=circo\n");
-    REQUIRE(graph[1] == "class [shape=circle, fontcolor=red, fillcolor=lightblue, style=filled ] \n");
+    REQUIRE(graph[1] == "\"class\" [shape=circle, fontcolor=red, fillcolor=lightblue, style=filled ] \n");
 }

tests/TestBayesClassifier.cc

@@ -85,7 +85,7 @@ TEST_CASE("Dump_cpt", "[Classifier]")
     auto raw = RawDatasets("iris", true);
     model.fit(raw.Xt, raw.yt, raw.features, raw.className, raw.states, raw.smoothing);
     auto cpt = model.dump_cpt();
-    REQUIRE(cpt.size() == 1713);
+    REQUIRE(cpt.size() == 1718);
 }
 TEST_CASE("Not fitted model", "[Classifier]")
 {

tests/TestBayesModels.cc

@@ -27,13 +27,13 @@ TEST_CASE("Test Bayesian Classifiers score & version", "[Models]")
     map <pair<std::string, std::string>, float> scores{
         // Diabetes
         {{"diabetes", "AODE"}, 0.82161}, {{"diabetes", "KDB"}, 0.852865}, {{"diabetes", "SPODE"}, 0.802083}, {{"diabetes", "TAN"}, 0.821615},
-        {{"diabetes", "AODELd"}, 0.8138f}, {{"diabetes", "KDBLd"}, 0.80208f}, {{"diabetes", "SPODELd"}, 0.78646f}, {{"diabetes", "TANLd"}, 0.8099f},  {{"diabetes", "BoostAODE"}, 0.83984f},
+        {{"diabetes", "AODELd"}, 0.8125f}, {{"diabetes", "KDBLd"}, 0.80208f}, {{"diabetes", "SPODELd"}, 0.7890625f}, {{"diabetes", "TANLd"}, 0.803385437f},  {{"diabetes", "BoostAODE"}, 0.83984f},
         // Ecoli
         {{"ecoli", "AODE"}, 0.889881}, {{"ecoli", "KDB"}, 0.889881}, {{"ecoli", "SPODE"}, 0.880952}, {{"ecoli", "TAN"}, 0.892857},
-        {{"ecoli", "AODELd"}, 0.8869f}, {{"ecoli", "KDBLd"}, 0.875f}, {{"ecoli", "SPODELd"}, 0.84226f}, {{"ecoli", "TANLd"}, 0.86905f}, {{"ecoli", "BoostAODE"}, 0.89583f},
+        {{"ecoli", "AODELd"}, 0.875f}, {{"ecoli", "KDBLd"}, 0.880952358f}, {{"ecoli", "SPODELd"}, 0.839285731f}, {{"ecoli", "TANLd"}, 0.848214269f}, {{"ecoli", "BoostAODE"}, 0.89583f},
         // Glass
         {{"glass", "AODE"}, 0.79439}, {{"glass", "KDB"}, 0.827103}, {{"glass", "SPODE"}, 0.775701}, {{"glass", "TAN"}, 0.827103},
-        {{"glass", "AODELd"}, 0.79439f}, {{"glass", "KDBLd"}, 0.85047f}, {{"glass", "SPODELd"}, 0.79439f}, {{"glass", "TANLd"}, 0.86449f}, {{"glass", "BoostAODE"}, 0.84579f},
+        {{"glass", "AODELd"}, 0.799065411f}, {{"glass", "KDBLd"}, 0.82710278f}, {{"glass", "SPODELd"}, 0.780373812f}, {{"glass", "TANLd"}, 0.869158864f}, {{"glass", "BoostAODE"}, 0.84579f},
         // Iris
         {{"iris", "AODE"}, 0.973333}, {{"iris", "KDB"}, 0.973333}, {{"iris", "SPODE"}, 0.973333}, {{"iris", "TAN"}, 0.973333},
         {{"iris", "AODELd"}, 0.973333}, {{"iris", "KDBLd"}, 0.973333}, {{"iris", "SPODELd"}, 0.96f}, {{"iris", "TANLd"}, 0.97333f}, {{"iris", "BoostAODE"}, 0.98f}
@@ -71,10 +71,10 @@ TEST_CASE("Test Bayesian Classifiers score & version", "[Models]")
 TEST_CASE("Models features & Graph", "[Models]")
 {
     auto graph = std::vector<std::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\" [shape=circle, fontcolor=red, fillcolor=lightblue, style=filled ] \n",
-        "class -> sepallength", "class -> sepalwidth", "class -> petallength", "class -> petalwidth", "petallength [shape=circle] \n",
+        "\"class\" -> \"sepallength\"", "\"class\" -> \"sepalwidth\"", "\"class\" -> \"petallength\"", "\"class\" -> \"petalwidth\"", "\"petallength\" [shape=circle] \n",
-        "petallength -> sepallength", "petalwidth [shape=circle] \n", "sepallength [shape=circle] \n",
+        "\"petallength\" -> \"sepallength\"", "\"petalwidth\" [shape=circle] \n", "\"sepallength\" [shape=circle] \n",
-        "sepallength -> sepalwidth", "sepalwidth [shape=circle] \n", "sepalwidth -> petalwidth", "}\n"
+        "\"sepallength\" -> \"sepalwidth\"", "\"sepalwidth\" [shape=circle] \n", "\"sepalwidth\" -> \"petalwidth\"", "}\n"
         }
     );
     SECTION("Test TAN")
@@ -96,7 +96,7 @@ TEST_CASE("Models features & Graph", "[Models]")
         clf.fit(raw.Xt, raw.yt, raw.features, raw.className, raw.states, raw.smoothing);
         REQUIRE(clf.getNumberOfNodes() == 5);
         REQUIRE(clf.getNumberOfEdges() == 7);
-        REQUIRE(clf.getNumberOfStates() == 19);
+        REQUIRE(clf.getNumberOfStates() == 27);
         REQUIRE(clf.getClassNumStates() == 3);
         REQUIRE(clf.show() == std::vector<std::string>{"class -> sepallength, sepalwidth, petallength, petalwidth, ", "petallength -> sepallength, ", "petalwidth -> ", "sepallength -> sepalwidth, ", "sepalwidth -> petalwidth, "});
         REQUIRE(clf.graph("Test") == graph);
@@ -268,3 +268,35 @@ TEST_CASE("Predict, predict_proba & score without fitting", "[Models]")
     REQUIRE_THROWS_WITH(clf.score(raw.Xv, raw.yv), message);
     REQUIRE_THROWS_WITH(clf.score(raw.Xt, raw.yt), message);
 }
+TEST_CASE("TAN & SPODE with hyperparameters", "[Models]")
+{
+    auto raw = RawDatasets("iris", true);
+    auto clf = bayesnet::TAN();
+    clf.setHyperparameters({
+        {"parent", 1},
+        });
+    clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
+    auto score = clf.score(raw.Xv, raw.yv);
+    REQUIRE(score == Catch::Approx(0.973333).epsilon(raw.epsilon));
+    auto clf2 = bayesnet::SPODE(0);
+    clf2.setHyperparameters({
+        {"parent", 1},
+        });
+    clf2.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
+    auto score2 = clf2.score(raw.Xv, raw.yv);
+    REQUIRE(score2 == Catch::Approx(0.973333).epsilon(raw.epsilon));
+}
+TEST_CASE("TAN & SPODE with invalid hyperparameters", "[Models]")
+{
+    auto raw = RawDatasets("iris", true);
+    auto clf = bayesnet::TAN();
+    clf.setHyperparameters({
+        {"parent", 5},
+        });
+    REQUIRE_THROWS_AS(clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing), std::invalid_argument);
+    auto clf2 = bayesnet::SPODE(0);
+    clf2.setHyperparameters({
+        {"parent", 5},
+        });
+    REQUIRE_THROWS_AS(clf2.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing), std::invalid_argument);
+}

tests/TestBayesNetwork.cc

@@ -186,11 +186,11 @@ TEST_CASE("Test Bayesian Network", "[Network]")
         auto str = net.graph("Test Graph");
         REQUIRE(str.size() == 7);
         REQUIRE(str[0] == "digraph BayesNet {\nlabel=<BayesNet Test Graph>\nfontsize=30\nfontcolor=blue\nlabelloc=t\nlayout=circo\n");
-        REQUIRE(str[1] == "A [shape=circle] \n");
+        REQUIRE(str[1] == "\"A\" [shape=circle] \n");
-        REQUIRE(str[2] == "A -> B");
+        REQUIRE(str[2] == "\"A\" -> \"B\"");
-        REQUIRE(str[3] == "A -> C");
+        REQUIRE(str[3] == "\"A\" -> \"C\"");
-        REQUIRE(str[4] == "B [shape=circle] \n");
+        REQUIRE(str[4] == "\"B\" [shape=circle] \n");
-        REQUIRE(str[5] == "C [shape=circle] \n");
+        REQUIRE(str[5] == "\"C\" [shape=circle] \n");
         REQUIRE(str[6] == "}\n");
     }
     SECTION("Test predict")
@@ -257,9 +257,9 @@ TEST_CASE("Test Bayesian Network", "[Network]")
             REQUIRE(node->getCPT().equal(node2->getCPT()));
         }
     }
-    SECTION("Test oddities")
+    SECTION("Network oddities")
     {
-        INFO("Test oddities");
+        INFO("Network oddities");
         buildModel(net, raw.features, raw.className);
         // predict without fitting
         std::vector<std::vector<int>> test = { {1, 2, 0, 1, 1}, {0, 1, 2, 0, 1}, {0, 0, 0, 0, 1}, {2, 2, 2, 2, 1} };
@@ -329,6 +329,14 @@ TEST_CASE("Test Bayesian Network", "[Network]")
         std::string invalid_state = "Feature sepallength not found in states";
         REQUIRE_THROWS_AS(net4.fit(raw.Xv, raw.yv, raw.weightsv, raw.features, raw.className, std::map<std::string, std::vector<int>>(), raw.smoothing), std::invalid_argument);
         REQUIRE_THROWS_WITH(net4.fit(raw.Xv, raw.yv, raw.weightsv, raw.features, raw.className, std::map<std::string, std::vector<int>>(), raw.smoothing), invalid_state);
+        // Try to add node or edge to a fitted network
+        auto net5 = bayesnet::Network();
+        buildModel(net5, raw.features, raw.className);
+        net5.fit(raw.Xv, raw.yv, raw.weightsv, raw.features, raw.className, raw.states, raw.smoothing);
+        REQUIRE_THROWS_AS(net5.addNode("A"), std::logic_error);
+        REQUIRE_THROWS_WITH(net5.addNode("A"), "Cannot add node to a fitted network. Initialize first.");
+        REQUIRE_THROWS_AS(net5.addEdge("A", "B"), std::logic_error);
+        REQUIRE_THROWS_WITH(net5.addEdge("A", "B"), "Cannot add edge to a fitted network. Initialize first.");
     }
 
 }
@@ -373,7 +381,7 @@ TEST_CASE("Dump CPT", "[Network]")
  0.3333
  0.3333
  0.3333
-[ CPUFloatType{3} ]
+[ CPUDoubleType{3} ]
 * petallength: (4) : [4, 3, 3]
 (1,.,.) = 
   0.9388  0.1000  0.2000
@@ -394,7 +402,7 @@ TEST_CASE("Dump CPT", "[Network]")
   0.0204  0.1000  0.2000
   0.1250  0.0526  0.1667
   0.2000  0.0606  0.8235
-[ CPUFloatType{4,3,3} ]
+[ CPUDoubleType{4,3,3} ]
 * petalwidth: (3) : [3, 6, 3]
 (1,.,.) = 
   0.5000  0.0417  0.0714
@@ -419,12 +427,12 @@ TEST_CASE("Dump CPT", "[Network]")
   0.1111  0.0909  0.8000
   0.0667  0.2000  0.8667
   0.0303  0.2500  0.7500
-[ CPUFloatType{3,6,3} ]
+[ CPUDoubleType{3,6,3} ]
 * sepallength: (3) : [3, 3]
  0.8679  0.1321  0.0377
  0.0943  0.3019  0.0566
  0.0377  0.5660  0.9057
-[ CPUFloatType{3,3} ]
+[ CPUDoubleType{3,3} ]
 * sepalwidth: (6) : [6, 3, 3]
 (1,.,.) = 
   0.0392  0.5000  0.2857
@@ -455,7 +463,7 @@ TEST_CASE("Dump CPT", "[Network]")
   0.5098  0.0833  0.1429
   0.5000  0.0476  0.1250
   0.2857  0.0571  0.1132
-[ CPUFloatType{6,3,3} ]
+[ CPUDoubleType{6,3,3} ]
 )";
     REQUIRE(res == expected);
 }
@@ -525,6 +533,7 @@ TEST_CASE("Test Smoothing A", "[Network]")
         }
     }
 }
+
 TEST_CASE("Test Smoothing B", "[Network]")
 {
     auto net = bayesnet::Network();
@@ -549,19 +558,41 @@ TEST_CASE("Test Smoothing B", "[Network]")
         { "C", {0, 1} }
     };
     auto weights = std::vector<double>(C.size(), 1);
-    // Simple
+    // See https://www.overleaf.com/read/tfnhpfysfkfx#2d576c example for calculations
-    std::cout << "LAPLACE\n";
+    INFO("Test Smoothing B - Laplace");
     net.fit(Data, C, weights, { "X", "Y", "Z" }, "C", states, bayesnet::Smoothing_t::LAPLACE);
-    std::cout << net.dump_cpt();
+    auto laplace_values = std::vector<std::vector<float>>({ {0.377418, 0.622582}, {0.217821, 0.782179} });
-    std::cout << "Predict proba of {0, 1, 2} y {1, 2, 3} = " << net.predict_proba({ {0, 1}, {1, 2}, {2, 3} }) << std::endl;
+    auto laplace_score = net.predict_proba({ {0, 1}, {1, 2}, {2, 3} });
-    std::cout << "ORIGINAL\n";
+    for (auto i = 0; i < 2; ++i) {
+        for (auto j = 0; j < 2; ++j) {
+            REQUIRE(laplace_score.at(i).at(j) == Catch::Approx(laplace_values.at(i).at(j)).margin(threshold));
+        }
+    }
+    INFO("Test Smoothing B - Original");
     net.fit(Data, C, weights, { "X", "Y", "Z" }, "C", states, bayesnet::Smoothing_t::ORIGINAL);
-    std::cout << net.dump_cpt();
+    auto original_values = std::vector<std::vector<float>>({ {0.344769, 0.655231}, {0.0421263, 0.957874} });
-    std::cout << "Predict proba of {0, 1, 2} y {1, 2, 3} = " << net.predict_proba({ {0, 1}, {1, 2}, {2, 3} }) << std::endl;
+    auto original_score = net.predict_proba({ {0, 1}, {1, 2}, {2, 3} });
-    std::cout << "CESTNIK\n";
+    for (auto i = 0; i < 2; ++i) {
+        for (auto j = 0; j < 2; ++j) {
+            REQUIRE(original_score.at(i).at(j) == Catch::Approx(original_values.at(i).at(j)).margin(threshold));
+        }
+    }
+    INFO("Test Smoothing B - Cestnik");
     net.fit(Data, C, weights, { "X", "Y", "Z" }, "C", states, bayesnet::Smoothing_t::CESTNIK);
-    std::cout << net.dump_cpt();
+    auto cestnik_values = std::vector<std::vector<float>>({ {0.353422, 0.646578}, {0.12364, 0.87636} });
-    std::cout << "Predict proba of {0, 1, 2} y {1, 2, 3} = " << net.predict_proba({ {0, 1}, {1, 2}, {2, 3} }) << std::endl;
+    auto cestnik_score = net.predict_proba({ {0, 1}, {1, 2}, {2, 3} });
-
+    for (auto i = 0; i < 2; ++i) {
-
+        for (auto j = 0; j < 2; ++j) {
+            REQUIRE(cestnik_score.at(i).at(j) == Catch::Approx(cestnik_values.at(i).at(j)).margin(threshold));
+        }
+    }
+    INFO("Test Smoothing B - No smoothing");
+    net.fit(Data, C, weights, { "X", "Y", "Z" }, "C", states, bayesnet::Smoothing_t::NONE);
+    auto nosmooth_values = std::vector<std::vector<float>>({ {0.342465753, 0.65753424}, {0.0, 1.0} });
+    auto nosmooth_score = net.predict_proba({ {0, 1}, {1, 2}, {2, 3} });
+    for (auto i = 0; i < 2; ++i) {
+        for (auto j = 0; j < 2; ++j) {
+            REQUIRE(nosmooth_score.at(i).at(j) == Catch::Approx(nosmooth_values.at(i).at(j)).margin(threshold));
+        }
+    }
 }

tests/TestBayesNode.cc

@@ -62,15 +62,17 @@ TEST_CASE("Test Node computeCPT", "[Node]")
     // Create a vector with the names of the classes
     auto className = std::string("Class");
     // weights
-    auto weights = torch::tensor({ 1.0, 1.0, 1.0, 1.0 });
+    auto weights = torch::tensor({ 1.0, 1.0, 1.0, 1.0 }, torch::kDouble);
     std::vector<bayesnet::Node> nodes;
     for (int i = 0; i < features.size(); i++) {
         auto node = bayesnet::Node(features[i]);
         node.setNumStates(states[i]);
         nodes.push_back(node);
     }
+    // Create node class with 2 states
     nodes.push_back(bayesnet::Node(className));
     nodes[features.size()].setNumStates(2);
+    // The network is c->f1, f2, f3 y f1->f2, f3 
     for (int i = 0; i < features.size(); i++) {
         // Add class node as parent of all feature nodes
         nodes[i].addParent(&nodes[features.size()]);

tests/TestBoostA2DE.cc

@@ -27,189 +27,192 @@ TEST_CASE("Build basic model", "[BoostA2DE]")
     auto score = clf.score(raw.Xv, raw.yv);
     REQUIRE(score == Catch::Approx(0.919271).epsilon(raw.epsilon));
 }
-// TEST_CASE("Feature_select IWSS", "[BoostAODE]")
+TEST_CASE("Feature_select IWSS", "[BoostA2DE]")
-// {
+{
-//     auto raw = RawDatasets("glass", true);
+    auto raw = RawDatasets("glass", true);
-//     auto clf = bayesnet::BoostAODE();
+    auto clf = bayesnet::BoostA2DE();
-//     clf.setHyperparameters({ {"select_features", "IWSS"}, {"threshold", 0.5 } });
+    clf.setHyperparameters({ {"select_features", "IWSS"}, {"threshold", 0.5 } });
-//     clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
+    clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
-//     REQUIRE(clf.getNumberOfNodes() == 90);
+    REQUIRE(clf.getNumberOfNodes() == 140);
-//     REQUIRE(clf.getNumberOfEdges() == 153);
+    REQUIRE(clf.getNumberOfEdges() == 294);
-//     REQUIRE(clf.getNotes().size() == 2);
+    REQUIRE(clf.getNotes().size() == 4);
-//     REQUIRE(clf.getNotes()[0] == "Used features in initialization: 4 of 9 with IWSS");
+    REQUIRE(clf.getNotes()[0] == "Used features in initialization: 4 of 9 with IWSS");
-//     REQUIRE(clf.getNotes()[1] == "Number of models: 9");
+    REQUIRE(clf.getNotes()[1] == "Convergence threshold reached & 15 models eliminated");
-// }
+    REQUIRE(clf.getNotes()[2] == "Pairs not used in train: 2");
-// TEST_CASE("Feature_select FCBF", "[BoostAODE]")
+    REQUIRE(clf.getNotes()[3] == "Number of models: 14");
-// {
+}
-//     auto raw = RawDatasets("glass", true);
+TEST_CASE("Feature_select FCBF", "[BoostA2DE]")
-//     auto clf = bayesnet::BoostAODE();
+{
-//     clf.setHyperparameters({ {"select_features", "FCBF"}, {"threshold", 1e-7 } });
+    auto raw = RawDatasets("glass", true);
-//     clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
+    auto clf = bayesnet::BoostA2DE();
-//     REQUIRE(clf.getNumberOfNodes() == 90);
+    clf.setHyperparameters({ {"select_features", "FCBF"}, {"threshold", 1e-7 } });
-//     REQUIRE(clf.getNumberOfEdges() == 153);
+    clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
-//     REQUIRE(clf.getNotes().size() == 2);
+    REQUIRE(clf.getNumberOfNodes() == 110);
-//     REQUIRE(clf.getNotes()[0] == "Used features in initialization: 4 of 9 with FCBF");
+    REQUIRE(clf.getNumberOfEdges() == 231);
-//     REQUIRE(clf.getNotes()[1] == "Number of models: 9");
+    REQUIRE(clf.getNotes()[0] == "Used features in initialization: 4 of 9 with FCBF");
-// }
+    REQUIRE(clf.getNotes()[1] == "Convergence threshold reached & 15 models eliminated");
-// TEST_CASE("Test used features in train note and score", "[BoostAODE]")
+    REQUIRE(clf.getNotes()[2] == "Pairs not used in train: 2");
-// {
+    REQUIRE(clf.getNotes()[3] == "Number of models: 11");
-//     auto raw = RawDatasets("diabetes", true);
+}
-//     auto clf = bayesnet::BoostAODE(true);
+TEST_CASE("Test used features in train note and score", "[BoostA2DE]")
-//     clf.setHyperparameters({
+{
-//         {"order", "asc"},
+    auto raw = RawDatasets("diabetes", true);
-//         {"convergence", true},
+    auto clf = bayesnet::BoostA2DE(true);
-//         {"select_features","CFS"},
+    clf.setHyperparameters({
-//         });
+        {"order", "asc"},
-//     clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
+        {"convergence", true},
-//     REQUIRE(clf.getNumberOfNodes() == 72);
+        {"select_features","CFS"},
-//     REQUIRE(clf.getNumberOfEdges() == 120);
+        });
-//     REQUIRE(clf.getNotes().size() == 2);
+    clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
-//     REQUIRE(clf.getNotes()[0] == "Used features in initialization: 6 of 8 with CFS");
+    REQUIRE(clf.getNumberOfNodes() == 144);
-//     REQUIRE(clf.getNotes()[1] == "Number of models: 8");
+    REQUIRE(clf.getNumberOfEdges() == 288);
-//     auto score = clf.score(raw.Xv, raw.yv);
+    REQUIRE(clf.getNotes().size() == 2);
-//     auto scoret = clf.score(raw.Xt, raw.yt);
+    REQUIRE(clf.getNotes()[0] == "Used features in initialization: 6 of 8 with CFS");
-//     REQUIRE(score == Catch::Approx(0.809895813).epsilon(raw.epsilon));
+    REQUIRE(clf.getNotes()[1] == "Number of models: 16");
-//     REQUIRE(scoret == Catch::Approx(0.809895813).epsilon(raw.epsilon));
+    auto score = clf.score(raw.Xv, raw.yv);
-// }
+    auto scoret = clf.score(raw.Xt, raw.yt);
-// TEST_CASE("Voting vs proba", "[BoostAODE]")
+    REQUIRE(score == Catch::Approx(0.856771).epsilon(raw.epsilon));
-// {
+    REQUIRE(scoret == Catch::Approx(0.856771).epsilon(raw.epsilon));
-//     auto raw = RawDatasets("iris", true);
+}
-//     auto clf = bayesnet::BoostAODE(false);
+TEST_CASE("Voting vs proba", "[BoostA2DE]")
-//     clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
+{
-//     auto score_proba = clf.score(raw.Xv, raw.yv);
+    auto raw = RawDatasets("iris", true);
-//     auto pred_proba = clf.predict_proba(raw.Xv);
+    auto clf = bayesnet::BoostA2DE(false);
-//     clf.setHyperparameters({
+    clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
-//         {"predict_voting",true},
+    auto score_proba = clf.score(raw.Xv, raw.yv);
-//         });
+    auto pred_proba = clf.predict_proba(raw.Xv);
-//     auto score_voting = clf.score(raw.Xv, raw.yv);
+    clf.setHyperparameters({
-//     auto pred_voting = clf.predict_proba(raw.Xv);
+        {"predict_voting",true},
-//     REQUIRE(score_proba == Catch::Approx(0.97333).epsilon(raw.epsilon));
+        });
-//     REQUIRE(score_voting == Catch::Approx(0.98).epsilon(raw.epsilon));
+    auto score_voting = clf.score(raw.Xv, raw.yv);
-//     REQUIRE(pred_voting[83][2] == Catch::Approx(1.0).epsilon(raw.epsilon));
+    auto pred_voting = clf.predict_proba(raw.Xv);
-//     REQUIRE(pred_proba[83][2] == Catch::Approx(0.86121525).epsilon(raw.epsilon));
+    REQUIRE(score_proba == Catch::Approx(0.98).epsilon(raw.epsilon));
-//     REQUIRE(clf.dump_cpt() == "");
+    REQUIRE(score_voting == Catch::Approx(0.946667).epsilon(raw.epsilon));
-//     REQUIRE(clf.topological_order() == std::vector<std::string>());
+    REQUIRE(pred_voting[83][2] == Catch::Approx(0.53508).epsilon(raw.epsilon));
-// }
+    REQUIRE(pred_proba[83][2] == Catch::Approx(0.48394).epsilon(raw.epsilon));
-// TEST_CASE("Order asc, desc & random", "[BoostAODE]")
+    REQUIRE(clf.dump_cpt() == "");
-// {
+    REQUIRE(clf.topological_order() == std::vector<std::string>());
-//     auto raw = RawDatasets("glass", true);
+}
-//     std::map<std::string, double> scores{
+TEST_CASE("Order asc, desc & random", "[BoostA2DE]")
-//         {"asc", 0.83645f }, { "desc", 0.84579f }, { "rand", 0.84112 }
+{
-//     };
+    auto raw = RawDatasets("glass", true);
-//     for (const std::string& order : { "asc", "desc", "rand" }) {
+    std::map<std::string, double> scores{
-//         auto clf = bayesnet::BoostAODE();
+        {"asc", 0.752336f }, { "desc", 0.813084f }, { "rand", 0.850467 }
-//         clf.setHyperparameters({
+    };
-//             {"order", order},
+    for (const std::string& order : { "asc", "desc", "rand" }) {
-//             {"bisection", false},
+        auto clf = bayesnet::BoostA2DE();
-//             {"maxTolerance", 1},
+        clf.setHyperparameters({
-//             {"convergence", false},
+            {"order", order},
-//             });
+            {"bisection", false},
-//         clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
+            {"maxTolerance", 1},
-//         auto score = clf.score(raw.Xv, raw.yv);
+            {"convergence", false},
-//         auto scoret = clf.score(raw.Xt, raw.yt);
+            });
-//         INFO("BoostAODE order: " + order);
+        clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
-//         REQUIRE(score == Catch::Approx(scores[order]).epsilon(raw.epsilon));
+        auto score = clf.score(raw.Xv, raw.yv);
-//         REQUIRE(scoret == Catch::Approx(scores[order]).epsilon(raw.epsilon));
+        auto scoret = clf.score(raw.Xt, raw.yt);
-//     }
+        INFO("BoostA2DE order: " + order);
-// }
+        REQUIRE(score == Catch::Approx(scores[order]).epsilon(raw.epsilon));
-// TEST_CASE("Oddities", "[BoostAODE]")
+        REQUIRE(scoret == Catch::Approx(scores[order]).epsilon(raw.epsilon));
-// {
+    }
-//     auto clf = bayesnet::BoostAODE();
+}
-//     auto raw = RawDatasets("iris", true);
+TEST_CASE("Oddities2", "[BoostA2DE]")
-//     auto bad_hyper = nlohmann::json{
+{
-//         { { "order", "duck" } },
+    auto clf = bayesnet::BoostA2DE();
-//         { { "select_features", "duck" } },
+    auto raw = RawDatasets("iris", true);
-//         { { "maxTolerance", 0 } },
+    auto bad_hyper = nlohmann::json{
-//         { { "maxTolerance", 5 } },
+        { { "order", "duck" } },
-//     };
+        { { "select_features", "duck" } },
-//     for (const auto& hyper : bad_hyper.items()) {
+        { { "maxTolerance", 0 } },
-//         INFO("BoostAODE hyper: " + hyper.value().dump());
+        { { "maxTolerance", 5 } },
-//         REQUIRE_THROWS_AS(clf.setHyperparameters(hyper.value()), std::invalid_argument);
+    };
-//     }
+    for (const auto& hyper : bad_hyper.items()) {
-//     REQUIRE_THROWS_AS(clf.setHyperparameters({ {"maxTolerance", 0 } }), std::invalid_argument);
+        INFO("BoostA2DE hyper: " + hyper.value().dump());
-//     auto bad_hyper_fit = nlohmann::json{
+        REQUIRE_THROWS_AS(clf.setHyperparameters(hyper.value()), std::invalid_argument);
-//         { { "select_features","IWSS" }, { "threshold", -0.01 } },
+    }
-//         { { "select_features","IWSS" }, { "threshold", 0.51 } },
+    REQUIRE_THROWS_AS(clf.setHyperparameters({ {"maxTolerance", 0 } }), std::invalid_argument);
-//         { { "select_features","FCBF" }, { "threshold", 1e-8 } },
+    auto bad_hyper_fit = nlohmann::json{
-//         { { "select_features","FCBF" }, { "threshold", 1.01 } },
+        { { "select_features","IWSS" }, { "threshold", -0.01 } },
-//     };
+        { { "select_features","IWSS" }, { "threshold", 0.51 } },
-//     for (const auto& hyper : bad_hyper_fit.items()) {
+        { { "select_features","FCBF" }, { "threshold", 1e-8 } },
-//         INFO("BoostAODE hyper: " + hyper.value().dump());
+        { { "select_features","FCBF" }, { "threshold", 1.01 } },
-//         clf.setHyperparameters(hyper.value());
+    };
-//         REQUIRE_THROWS_AS(clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing, std::invalid_argument);
+    for (const auto& hyper : bad_hyper_fit.items()) {
-//     }
+        INFO("BoostA2DE hyper: " + hyper.value().dump());
-// }
+        clf.setHyperparameters(hyper.value());
-
+        REQUIRE_THROWS_AS(clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing), std::invalid_argument);
-// TEST_CASE("Bisection Best", "[BoostAODE]")
+    }
-// {
+}
-//     auto clf = bayesnet::BoostAODE();
+TEST_CASE("No features selected", "[BoostA2DE]")
-//     auto raw = RawDatasets("kdd_JapaneseVowels", true, 1200, true, false);
+{
-//     clf.setHyperparameters({
+    // Check that the note "No features selected in initialization" is added
-//         {"bisection", true},
+    //
-//         {"maxTolerance", 3},
+    auto raw = RawDatasets("iris", true);
-//         {"convergence", true},
+    auto clf = bayesnet::BoostA2DE();
-//         {"block_update", false},
+    clf.setHyperparameters({ {"select_features","FCBF"}, {"threshold", 1 } });
-//         {"convergence_best", false},
+    clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
-//         });
+    REQUIRE(clf.getNotes().size() == 1);
-//     clf.fit(raw.X_train, raw.y_train, raw.features, raw.className, raw.states, raw.smoothing);
+    REQUIRE(clf.getNotes()[0] == "No features selected in initialization");
-//     REQUIRE(clf.getNumberOfNodes() == 210);
+}
-//     REQUIRE(clf.getNumberOfEdges() == 378);
+TEST_CASE("Bisection Best", "[BoostA2DE]")
-//     REQUIRE(clf.getNotes().size() == 1);
+{
-//     REQUIRE(clf.getNotes().at(0) == "Number of models: 14");
+    auto clf = bayesnet::BoostA2DE();
-//     auto score = clf.score(raw.X_test, raw.y_test);
+    auto raw = RawDatasets("kdd_JapaneseVowels", true, 1200, true, false);
-//     auto scoret = clf.score(raw.X_test, raw.y_test);
+    clf.setHyperparameters({
-//     REQUIRE(score == Catch::Approx(0.991666675f).epsilon(raw.epsilon));
+        {"bisection", true},
-//     REQUIRE(scoret == Catch::Approx(0.991666675f).epsilon(raw.epsilon));
+        {"maxTolerance", 3},
-// }
+        {"convergence", true},
-// TEST_CASE("Bisection Best vs Last", "[BoostAODE]")
+        {"block_update", false},
-// {
+        {"convergence_best", false},
-//     auto raw = RawDatasets("kdd_JapaneseVowels", true, 1500, true, false);
+        });
-//     auto clf = bayesnet::BoostAODE(true);
+    clf.fit(raw.X_train, raw.y_train, raw.features, raw.className, raw.states, raw.smoothing);
-//     auto hyperparameters = nlohmann::json{
+    REQUIRE(clf.getNumberOfNodes() == 480);
-//         {"bisection", true},
+    REQUIRE(clf.getNumberOfEdges() == 1152);
-//         {"maxTolerance", 3},
+    REQUIRE(clf.getNotes().size() == 3);
-//         {"convergence", true},
+    REQUIRE(clf.getNotes().at(0) == "Convergence threshold reached & 15 models eliminated");
-//         {"convergence_best", true},
+    REQUIRE(clf.getNotes().at(1) == "Pairs not used in train: 83");
-//     };
+    REQUIRE(clf.getNotes().at(2) == "Number of models: 32");
-//     clf.setHyperparameters(hyperparameters);
+    auto score = clf.score(raw.X_test, raw.y_test);
-//     clf.fit(raw.X_train, raw.y_train, raw.features, raw.className, raw.states, raw.smoothing);
+    auto scoret = clf.score(raw.X_test, raw.y_test);
-//     auto score_best = clf.score(raw.X_test, raw.y_test);
+    REQUIRE(score == Catch::Approx(0.966667f).epsilon(raw.epsilon));
-//     REQUIRE(score_best == Catch::Approx(0.980000019f).epsilon(raw.epsilon));
+    REQUIRE(scoret == Catch::Approx(0.966667f).epsilon(raw.epsilon));
-//     // Now we will set the hyperparameter to use the last accuracy
+}
-//     hyperparameters["convergence_best"] = false;
+TEST_CASE("Block Update", "[BoostA2DE]")
-//     clf.setHyperparameters(hyperparameters);
+{
-//     clf.fit(raw.X_train, raw.y_train, raw.features, raw.className, raw.states, raw.smoothing);
+    auto clf = bayesnet::BoostA2DE();
-//     auto score_last = clf.score(raw.X_test, raw.y_test);
+    auto raw = RawDatasets("spambase", true, 500);
-//     REQUIRE(score_last == Catch::Approx(0.976666689f).epsilon(raw.epsilon));
+    clf.setHyperparameters({
-// }
+        {"bisection", true},
-
+        {"block_update", true},
-// TEST_CASE("Block Update", "[BoostAODE]")
+        {"maxTolerance", 3},
-// {
+        {"convergence", true},
-//     auto clf = bayesnet::BoostAODE();
+        });
-//     auto raw = RawDatasets("mfeat-factors", true, 500);
+    clf.fit(raw.X_train, raw.y_train, raw.features, raw.className, raw.states, raw.smoothing);
-//     clf.setHyperparameters({
+    REQUIRE(clf.getNumberOfNodes() == 58);
-//         {"bisection", true},
+    REQUIRE(clf.getNumberOfEdges() == 165);
-//         {"block_update", true},
+    REQUIRE(clf.getNotes().size() == 3);
-//         {"maxTolerance", 3},
+    REQUIRE(clf.getNotes()[0] == "Convergence threshold reached & 15 models eliminated");
-//         {"convergence", true},
+    REQUIRE(clf.getNotes()[1] == "Pairs not used in train: 1588");
-//         });
+    REQUIRE(clf.getNotes()[2] == "Number of models: 1");
-//     clf.fit(raw.X_train, raw.y_train, raw.features, raw.className, raw.states, raw.smoothing);
+    auto score = clf.score(raw.X_test, raw.y_test);
-//     REQUIRE(clf.getNumberOfNodes() == 868);
+    auto scoret = clf.score(raw.X_test, raw.y_test);
-//     REQUIRE(clf.getNumberOfEdges() == 1724);
+    REQUIRE(score == Catch::Approx(1.0f).epsilon(raw.epsilon));
-//     REQUIRE(clf.getNotes().size() == 3);
+    REQUIRE(scoret == Catch::Approx(1.0f).epsilon(raw.epsilon));
-//     REQUIRE(clf.getNotes()[0] == "Convergence threshold reached & 15 models eliminated");
+    //
-//     REQUIRE(clf.getNotes()[1] == "Used features in train: 19 of 216");
+    // std::cout << "Number of nodes " << clf.getNumberOfNodes() << std::endl;
-//     REQUIRE(clf.getNotes()[2] == "Number of models: 4");
+    // std::cout << "Number of edges " << clf.getNumberOfEdges() << std::endl;
-//     auto score = clf.score(raw.X_test, raw.y_test);
+    // std::cout << "Notes size " << clf.getNotes().size() << std::endl;
-//     auto scoret = clf.score(raw.X_test, raw.y_test);
+    // for (auto note : clf.getNotes()) {
-//     REQUIRE(score == Catch::Approx(0.99f).epsilon(raw.epsilon));
+    //     std::cout << note << std::endl;
-//     REQUIRE(scoret == Catch::Approx(0.99f).epsilon(raw.epsilon));
+    // }
-//     //
+    // std::cout << "Score " << score << std::endl;
-//     // std::cout << "Number of nodes " << clf.getNumberOfNodes() << std::endl;
+}
-//     // std::cout << "Number of edges " << clf.getNumberOfEdges() << std::endl;
+TEST_CASE("Test graph b2a2de", "[BoostA2DE]")
-//     // std::cout << "Notes size " << clf.getNotes().size() << std::endl;
+{
-//     // for (auto note : clf.getNotes()) {
+    auto raw = RawDatasets("iris", true);
-//     //     std::cout << note << std::endl;
+    auto clf = bayesnet::BoostA2DE();
-//     // }
+    clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing);
-//     // std::cout << "Score " << score << std::endl;
+    auto graph = clf.graph();
-// }
+    REQUIRE(graph.size() == 26);
+    REQUIRE(graph[0] == "digraph BayesNet {\nlabel=<BayesNet BoostA2DE_0>\nfontsize=30\nfontcolor=blue\nlabelloc=t\nlayout=circo\n");
+    REQUIRE(graph[1] == "\"class\" [shape=circle, fontcolor=red, fillcolor=lightblue, style=filled ] \n");
+}

tests/TestBoostAODE.cc

@@ -136,8 +136,16 @@ TEST_CASE("Oddities", "[BoostAODE]")
         clf.setHyperparameters(hyper.value());
         REQUIRE_THROWS_AS(clf.fit(raw.Xv, raw.yv, raw.features, raw.className, raw.states, raw.smoothing), std::invalid_argument);
     }
-}
 
+    auto bad_hyper_fit2 = nlohmann::json{
+        { { "alpha_block", true }, { "block_update", true } },
+        { { "bisection", false }, { "block_update", true } },
+    };
+    for (const auto& hyper : bad_hyper_fit2.items()) {
+        INFO("BoostAODE hyper: " << hyper.value().dump());
+        REQUIRE_THROWS_AS(clf.setHyperparameters(hyper.value()), std::invalid_argument);
+    }
+}
 TEST_CASE("Bisection Best", "[BoostAODE]")
 {
     auto clf = bayesnet::BoostAODE();
@@ -180,7 +188,6 @@ TEST_CASE("Bisection Best vs Last", "[BoostAODE]")
     auto score_last = clf.score(raw.X_test, raw.y_test);
     REQUIRE(score_last == Catch::Approx(0.976666689f).epsilon(raw.epsilon));
 }
-
 TEST_CASE("Block Update", "[BoostAODE]")
 {
     auto clf = bayesnet::BoostAODE();
@@ -211,3 +218,18 @@ TEST_CASE("Block Update", "[BoostAODE]")
     // }
     // std::cout << "Score " << score << std::endl;
 }
+TEST_CASE("Alphablock", "[BoostAODE]")
+{
+    auto clf_alpha = bayesnet::BoostAODE();
+    auto clf_no_alpha = bayesnet::BoostAODE();
+    auto raw = RawDatasets("diabetes", true);
+    clf_alpha.setHyperparameters({
+        {"alpha_block", true},
+        });
+    clf_alpha.fit(raw.X_train, raw.y_train, raw.features, raw.className, raw.states, raw.smoothing);
+    clf_no_alpha.fit(raw.X_train, raw.y_train, raw.features, raw.className, raw.states, raw.smoothing);
+    auto score_alpha = clf_alpha.score(raw.X_test, raw.y_test);
+    auto score_no_alpha = clf_no_alpha.score(raw.X_test, raw.y_test);
+    REQUIRE(score_alpha == Catch::Approx(0.720779f).epsilon(raw.epsilon));
+    REQUIRE(score_no_alpha == Catch::Approx(0.733766f).epsilon(raw.epsilon));
+}

tests/TestMST.cc

@@ -0,0 +1,72 @@
+// ***************************************************************
+// SPDX-FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
+// SPDX-FileType: SOURCE
+// SPDX-License-Identifier: MIT
+// ***************************************************************
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+#include <catch2/generators/catch_generators.hpp>
+#include <catch2/matchers/catch_matchers.hpp>
+#include <string>
+#include <vector>
+#include "TestUtils.h"
+#include "bayesnet/utils/Mst.h"
+
+
+TEST_CASE("MST::insertElement tests", "[MST]")
+{
+    bayesnet::MST mst({}, torch::tensor({}), 0);
+    SECTION("Insert into an empty list")
+    {
+        std::list<int> variables;
+        mst.insertElement(variables, 5);
+        REQUIRE(variables == std::list<int>{5});
+    }
+    SECTION("Insert a non-duplicate element")
+    {
+        std::list<int> variables = { 1, 2, 3 };
+        mst.insertElement(variables, 4);
+        REQUIRE(variables == std::list<int>{4, 1, 2, 3});
+    }
+    SECTION("Insert a duplicate element")
+    {
+        std::list<int> variables = { 1, 2, 3 };
+        mst.insertElement(variables, 2);
+        REQUIRE(variables == std::list<int>{1, 2, 3});
+    }
+}
+
+TEST_CASE("MST::reorder tests", "[MST]")
+{
+    bayesnet::MST mst({}, torch::tensor({}), 0);
+    SECTION("Reorder simple graph")
+    {
+        std::vector<std::pair<float, std::pair<int, int>>> T = { {2.0, {1, 2}}, {1.0, {0, 1}} };
+        auto result = mst.reorder(T, 0);
+        REQUIRE(result == std::vector<std::pair<int, int>>{{0, 1}, { 1, 2 }});
+    }
+    SECTION("Reorder with disconnected graph")
+    {
+        std::vector<std::pair<float, std::pair<int, int>>> T = { {2.0, {2, 3}}, {1.0, {0, 1}} };
+        auto result = mst.reorder(T, 0);
+        REQUIRE(result == std::vector<std::pair<int, int>>{{0, 1}, { 2, 3 }});
+    }
+}
+
+TEST_CASE("MST::maximumSpanningTree tests", "[MST]")
+{
+    std::vector<std::string> features = { "A", "B", "C" };
+    auto weights = torch::tensor({
+        {0.0, 1.0, 2.0},
+        {1.0, 0.0, 3.0},
+        {2.0, 3.0, 0.0}
+        });
+    bayesnet::MST mst(features, weights, 0);
+
+    SECTION("MST of a complete graph")
+    {
+        auto result = mst.maximumSpanningTree();
+        REQUIRE(result.size() == 2); // Un MST para 3 nodos tiene 2 aristas
+    }
+}

tests/TestModulesVersions.cc

@@ -7,7 +7,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers.hpp>
 #include <string>
-#include <fimdlp/CPPFImdlp.h>
+#include <CPPFImdlp.h>
 #include <folding.hpp>
 #include <nlohmann/json.hpp>
 #define TO_STR2(x) #x
@@ -16,8 +16,8 @@
 #include "TestUtils.h"
 
 std::map<std::string, std::string> modules = {
-    { "mdlp", "2.0.0" },
+    { "mdlp", "2.0.1" },
-    { "Folding", "1.1.0" },
+    { "Folding", "1.1.1" },
     { "json", "3.11" },
     { "ArffFiles", "1.1.0" }
 };

tests/TestUtils.h

@@ -12,7 +12,7 @@
 #include <map>
 #include <tuple>
 #include <ArffFiles.hpp>
-#include <fimdlp/CPPFImdlp.h>
+#include <CPPFImdlp.h>
 #include <folding.hpp>
 #include <bayesnet/network/Network.h>