Refactor library structure

bayesnet/classifiers/Classifier.cc

@@ -0,0 +1,184 @@
+#include "bayesnet/utils/bayesnetUtils.h"
+#include "Classifier.h"
+
+namespace bayesnet {
+    Classifier::Classifier(Network model) : model(model), m(0), n(0), metrics(Metrics()), fitted(false) {}
+    const std::string CLASSIFIER_NOT_FITTED = "Classifier has not been fitted";
+    Classifier& Classifier::build(const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights)
+    {
+        this->features = features;
+        this->className = className;
+        this->states = states;
+        m = dataset.size(1);
+        n = dataset.size(0) - 1;
+        checkFitParameters();
+        auto n_classes = states.at(className).size();
+        metrics = Metrics(dataset, features, className, n_classes);
+        model.initialize();
+        buildModel(weights);
+        trainModel(weights);
+        fitted = true;
+        return *this;
+    }
+    void Classifier::buildDataset(torch::Tensor& ytmp)
+    {
+        try {
+            auto yresized = torch::transpose(ytmp.view({ ytmp.size(0), 1 }), 0, 1);
+            dataset = torch::cat({ dataset, yresized }, 0);
+        }
+        catch (const std::exception& e) {
+            std::cerr << e.what() << '\n';
+            std::cout << "X dimensions: " << dataset.sizes() << "\n";
+            std::cout << "y dimensions: " << ytmp.sizes() << "\n";
+            exit(1);
+        }
+    }
+    void Classifier::trainModel(const torch::Tensor& weights)
+    {
+        model.fit(dataset, weights, features, className, states);
+    }
+    // X is nxm where n is the number of features and m the number of samples
+    Classifier& Classifier::fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states)
+    {
+        dataset = X;
+        buildDataset(y);
+        const torch::Tensor weights = torch::full({ dataset.size(1) }, 1.0 / dataset.size(1), torch::kDouble);
+        return build(features, className, states, weights);
+    }
+    // X is nxm where n is the number of features and m the number of samples
+    Classifier& Classifier::fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states)
+    {
+        dataset = torch::zeros({ static_cast<int>(X.size()), static_cast<int>(X[0].size()) }, torch::kInt32);
+        for (int i = 0; i < X.size(); ++i) {
+            dataset.index_put_({ i, "..." }, torch::tensor(X[i], torch::kInt32));
+        }
+        auto ytmp = torch::tensor(y, torch::kInt32);
+        buildDataset(ytmp);
+        const torch::Tensor weights = torch::full({ dataset.size(1) }, 1.0 / dataset.size(1), torch::kDouble);
+        return build(features, className, states, weights);
+    }
+    Classifier& Classifier::fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states)
+    {
+        this->dataset = dataset;
+        const torch::Tensor weights = torch::full({ dataset.size(1) }, 1.0 / dataset.size(1), torch::kDouble);
+        return build(features, className, states, weights);
+    }
+    Classifier& Classifier::fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights)
+    {
+        this->dataset = dataset;
+        return build(features, className, states, weights);
+    }
+    void Classifier::checkFitParameters()
+    {
+        if (torch::is_floating_point(dataset)) {
+            throw std::invalid_argument("dataset (X, y) must be of type Integer");
+        }
+        if (n != features.size()) {
+            throw std::invalid_argument("Classifier: X " + std::to_string(n) + " and features " + std::to_string(features.size()) + " must have the same number of features");
+        }
+        if (states.find(className) == states.end()) {
+            throw std::invalid_argument("className not found in states");
+        }
+        for (auto feature : features) {
+            if (states.find(feature) == states.end()) {
+                throw std::invalid_argument("feature [" + feature + "] not found in states");
+            }
+        }
+    }
+    torch::Tensor Classifier::predict(torch::Tensor& X)
+    {
+        if (!fitted) {
+            throw std::logic_error(CLASSIFIER_NOT_FITTED);
+        }
+        return model.predict(X);
+    }
+    std::vector<int> Classifier::predict(std::vector<std::vector<int>>& X)
+    {
+        if (!fitted) {
+            throw std::logic_error(CLASSIFIER_NOT_FITTED);
+        }
+        auto m_ = X[0].size();
+        auto n_ = X.size();
+        std::vector<std::vector<int>> Xd(n_, std::vector<int>(m_, 0));
+        for (auto i = 0; i < n_; i++) {
+            Xd[i] = std::vector<int>(X[i].begin(), X[i].end());
+        }
+        auto yp = model.predict(Xd);
+        return yp;
+    }
+    torch::Tensor Classifier::predict_proba(torch::Tensor& X)
+    {
+        if (!fitted) {
+            throw std::logic_error(CLASSIFIER_NOT_FITTED);
+        }
+        return model.predict_proba(X);
+    }
+    std::vector<std::vector<double>> Classifier::predict_proba(std::vector<std::vector<int>>& X)
+    {
+        if (!fitted) {
+            throw std::logic_error(CLASSIFIER_NOT_FITTED);
+        }
+        auto m_ = X[0].size();
+        auto n_ = X.size();
+        std::vector<std::vector<int>> Xd(n_, std::vector<int>(m_, 0));
+        // Convert to nxm vector
+        for (auto i = 0; i < n_; i++) {
+            Xd[i] = std::vector<int>(X[i].begin(), X[i].end());
+        }
+        auto yp = model.predict_proba(Xd);
+        return yp;
+    }
+    float Classifier::score(torch::Tensor& X, torch::Tensor& y)
+    {
+        torch::Tensor y_pred = predict(X);
+        return (y_pred == y).sum().item<float>() / y.size(0);
+    }
+    float Classifier::score(std::vector<std::vector<int>>& X, std::vector<int>& y)
+    {
+        if (!fitted) {
+            throw std::logic_error(CLASSIFIER_NOT_FITTED);
+        }
+        return model.score(X, y);
+    }
+    std::vector<std::string> Classifier::show() const
+    {
+        return model.show();
+    }
+    void Classifier::addNodes()
+    {
+        // Add all nodes to the network
+        for (const auto& feature : features) {
+            model.addNode(feature);
+        }
+        model.addNode(className);
+    }
+    int Classifier::getNumberOfNodes() const
+    {
+        // Features does not include class
+        return fitted ? model.getFeatures().size() : 0;
+    }
+    int Classifier::getNumberOfEdges() const
+    {
+        return fitted ? model.getNumEdges() : 0;
+    }
+    int Classifier::getNumberOfStates() const
+    {
+        return fitted ? model.getStates() : 0;
+    }
+    int Classifier::getClassNumStates() const
+    {
+        return fitted ? model.getClassNumStates() : 0;
+    }
+    std::vector<std::string> Classifier::topological_order()
+    {
+        return model.topological_sort();
+    }
+    void Classifier::dump_cpt() const
+    {
+        model.dump_cpt();
+    }
+    void Classifier::setHyperparameters(const nlohmann::json& hyperparameters)
+    {
+        //For classifiers that don't have hyperparameters
+    }
+}

bayesnet/classifiers/Classifier.h

@@ -0,0 +1,59 @@
+#ifndef CLASSIFIER_H
+#define CLASSIFIER_H
+#include <torch/torch.h>
+#include "bayesnet/utils/BayesMetrics.h"
+#include "bayesnet/network/Network.h"
+#include "bayesnet/BaseClassifier.h"
+
+namespace bayesnet {
+    class Classifier : public BaseClassifier {
+    public:
+        Classifier(Network model);
+        virtual ~Classifier() = default;
+        Classifier& fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) override;
+        Classifier& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) override;
+        Classifier& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states) override;
+        Classifier& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights) override;
+        void addNodes();
+        int getNumberOfNodes() const override;
+        int getNumberOfEdges() const override;
+        int getNumberOfStates() const override;
+        int getClassNumStates() const override;
+        torch::Tensor predict(torch::Tensor& X) override;
+        std::vector<int> predict(std::vector<std::vector<int>>& X) override;
+        torch::Tensor predict_proba(torch::Tensor& X) override;
+        std::vector<std::vector<double>> predict_proba(std::vector<std::vector<int>>& X) override;
+        status_t getStatus() const override { return status; }
+        std::string getVersion() override { return { project_version.begin(), project_version.end() }; };
+        float score(torch::Tensor& X, torch::Tensor& y) override;
+        float score(std::vector<std::vector<int>>& X, std::vector<int>& y) override;
+        std::vector<std::string> show() const override;
+        std::vector<std::string> topological_order()  override;
+        std::vector<std::string> getNotes() const override { return notes; }
+        void dump_cpt() const override;
+        void setHyperparameters(const nlohmann::json& hyperparameters) override; //For classifiers that don't have hyperparameters
+    protected:
+        bool fitted;
+        unsigned int m, n; // m: number of samples, n: number of features
+        Network model;
+        Metrics metrics;
+        std::vector<std::string> features;
+        std::string className;
+        std::map<std::string, std::vector<int>> states;
+        torch::Tensor dataset; // (n+1)xm tensor
+        status_t status = NORMAL;
+        std::vector<std::string> notes; // Used to store messages occurred during the fit process
+        void checkFitParameters();
+        virtual void buildModel(const torch::Tensor& weights) = 0;
+        void trainModel(const torch::Tensor& weights) override;
+        void buildDataset(torch::Tensor& y);
+    private:
+        Classifier& build(const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights);
+    };
+}
+#endif
+
+
+
+
+

bayesnet/classifiers/KDB.cc

@@ -0,0 +1,101 @@
+#include "KDB.h"
+
+namespace bayesnet {
+    KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta)
+    {
+        validHyperparameters = { "k", "theta" };
+
+    }
+    void KDB::setHyperparameters(const nlohmann::json& hyperparameters)
+    {
+        if (hyperparameters.contains("k")) {
+            k = hyperparameters["k"];
+        }
+        if (hyperparameters.contains("theta")) {
+            theta = hyperparameters["theta"];
+        }
+    }
+    void KDB::buildModel(const torch::Tensor& weights)
+    {
+        /*
+        1. For each feature Xi, compute mutual information, I(X;C),
+        where C is the class.
+        2. Compute class conditional mutual information I(Xi;XjIC), f or each
+        pair of features Xi and Xj, where i#j.
+        3. Let the used variable list, S, be empty.
+        4. Let the DAG network being constructed, BN, begin with a single
+        class node, C.
+        5. Repeat until S includes all domain features
+        5.1. Select feature Xmax which is not in S and has the largest value
+        I(Xmax;C).
+        5.2. Add a node to BN representing Xmax.
+        5.3. Add an arc from C to Xmax in BN.
+        5.4. Add m = min(lSl,/c) arcs from m distinct features Xj in S with
+        the highest value for I(Xmax;X,jC).
+        5.5. Add Xmax to S.
+        Compute the conditional probabilility infered by the structure of BN by
+        using counts from DB, and output BN.
+        */
+        // 1. For each feature Xi, compute mutual information, I(X;C),
+        // where C is the class.
+        addNodes();
+        const torch::Tensor& y = dataset.index({ -1, "..." });
+        std::vector<double> mi;
+        for (auto i = 0; i < features.size(); i++) {
+            torch::Tensor firstFeature = dataset.index({ i, "..." });
+            mi.push_back(metrics.mutualInformation(firstFeature, y, weights));
+        }
+        // 2. Compute class conditional mutual information I(Xi;XjIC), f or each
+        auto conditionalEdgeWeights = metrics.conditionalEdge(weights);
+        // 3. Let the used variable list, S, be empty.
+        std::vector<int> S;
+        // 4. Let the DAG network being constructed, BN, begin with a single
+        // class node, C.
+        // 5. Repeat until S includes all domain features
+        // 5.1. Select feature Xmax which is not in S and has the largest value
+        // I(Xmax;C).
+        auto order = argsort(mi);
+        for (auto idx : order) {
+            // 5.2. Add a node to BN representing Xmax.
+            // 5.3. Add an arc from C to Xmax in BN.
+            model.addEdge(className, features[idx]);
+            // 5.4. Add m = min(lSl,/c) arcs from m distinct features Xj in S with
+            // the highest value for I(Xmax;X,jC).
+            add_m_edges(idx, S, conditionalEdgeWeights);
+            // 5.5. Add Xmax to S.
+            S.push_back(idx);
+        }
+    }
+    void KDB::add_m_edges(int idx, std::vector<int>& S, torch::Tensor& weights)
+    {
+        auto n_edges = std::min(k, static_cast<int>(S.size()));
+        auto cond_w = clone(weights);
+        bool exit_cond = k == 0;
+        int num = 0;
+        while (!exit_cond) {
+            auto max_minfo = argmax(cond_w.index({ idx, "..." })).item<int>();
+            auto belongs = find(S.begin(), S.end(), max_minfo) != S.end();
+            if (belongs && cond_w.index({ idx, max_minfo }).item<float>() > theta) {
+                try {
+                    model.addEdge(features[max_minfo], features[idx]);
+                    num++;
+                }
+                catch (const std::invalid_argument& e) {
+                    // Loops are not allowed
+                }
+            }
+            cond_w.index_put_({ idx, max_minfo }, -1);
+            auto candidates_mask = cond_w.index({ idx, "..." }).gt(theta);
+            auto candidates = candidates_mask.nonzero();
+            exit_cond = num == n_edges || candidates.size(0) == 0;
+        }
+    }
+    std::vector<std::string> KDB::graph(const std::string& title) const
+    {
+        std::string header{ title };
+        if (title == "KDB") {
+            header += " (k=" + std::to_string(k) + ", theta=" + std::to_string(theta) + ")";
+        }
+        return model.graph(header);
+    }
+}

bayesnet/classifiers/KDB.h

@@ -0,0 +1,21 @@
+#ifndef KDB_H
+#define KDB_H
+#include <torch/torch.h>
+#include "bayesnet/utils/bayesnetUtils.h"
+#include "Classifier.h"
+namespace bayesnet {
+    class KDB : public Classifier {
+    private:
+        int k;
+        float theta;
+        void add_m_edges(int idx, std::vector<int>& S, torch::Tensor& weights);
+    protected:
+        void buildModel(const torch::Tensor& weights) override;
+    public:
+        explicit KDB(int k, float theta = 0.03);
+        virtual ~KDB() = default;
+        void setHyperparameters(const nlohmann::json& hyperparameters) override;
+        std::vector<std::string> graph(const std::string& name = "KDB") const override;
+    };
+}
+#endif

bayesnet/classifiers/KDBLd.cc

@@ -0,0 +1,29 @@
+#include "KDBLd.h"
+
+namespace bayesnet {
+    KDBLd::KDBLd(int k) : KDB(k), Proposal(dataset, features, className) {}
+    KDBLd& KDBLd::fit(torch::Tensor& X_, torch::Tensor& y_, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_)
+    {
+        checkInput(X_, y_);
+        features = features_;
+        className = className_;
+        Xf = X_;
+        y = y_;
+        // Fills std::vectors Xv & yv with the data from tensors X_ (discretized) & y
+        states = fit_local_discretization(y);
+        // We have discretized the input data
+        // 1st we need to fit the model to build the normal KDB structure, KDB::fit initializes the base Bayesian network
+        KDB::fit(dataset, features, className, states);
+        states = localDiscretizationProposal(states, model);
+        return *this;
+    }
+    torch::Tensor KDBLd::predict(torch::Tensor& X)
+    {
+        auto Xt = prepareX(X);
+        return KDB::predict(Xt);
+    }
+    std::vector<std::string> KDBLd::graph(const std::string& name) const
+    {
+        return KDB::graph(name);
+    }
+}

bayesnet/classifiers/KDBLd.h

@@ -0,0 +1,18 @@
+#ifndef KDBLD_H
+#define KDBLD_H
+#include "Proposal.h"
+#include "KDB.h"
+
+namespace bayesnet {
+    class KDBLd : public KDB, public Proposal {
+    private:
+    public:
+        explicit KDBLd(int k);
+        virtual ~KDBLd() = default;
+        KDBLd& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, map<std::string, std::vector<int>>& states) override;
+        std::vector<std::string> graph(const std::string& name = "KDB") const override;
+        torch::Tensor predict(torch::Tensor& X) override;
+        static inline std::string version() { return "0.0.1"; };
+    };
+}
+#endif // !KDBLD_H

bayesnet/classifiers/Proposal.cc

@@ -0,0 +1,110 @@
+#include <ArffFiles.h>
+#include "Proposal.h"
+
+namespace bayesnet {
+    Proposal::Proposal(torch::Tensor& dataset_, std::vector<std::string>& features_, std::string& className_) : pDataset(dataset_), pFeatures(features_), pClassName(className_) {}
+    Proposal::~Proposal()
+    {
+        for (auto& [key, value] : discretizers) {
+            delete value;
+        }
+    }
+    void Proposal::checkInput(const torch::Tensor& X, const torch::Tensor& y)
+    {
+        if (!torch::is_floating_point(X)) {
+            throw std::invalid_argument("X must be a floating point tensor");
+        }
+        if (torch::is_floating_point(y)) {
+            throw std::invalid_argument("y must be an integer tensor");
+        }
+    }
+    map<std::string, std::vector<int>> Proposal::localDiscretizationProposal(const map<std::string, std::vector<int>>& oldStates, Network& model)
+    {
+        // order of local discretization is important. no good 0, 1, 2...
+        // although we rediscretize features after the local discretization of every feature
+        auto order = model.topological_sort();
+        auto& nodes = model.getNodes();
+        map<std::string, std::vector<int>> states = oldStates;
+        std::vector<int> indicesToReDiscretize;
+        bool upgrade = false; // Flag to check if we need to upgrade the model
+        for (auto feature : order) {
+            auto nodeParents = nodes[feature]->getParents();
+            if (nodeParents.size() < 2) continue; // Only has class as parent
+            upgrade = true;
+            int index = find(pFeatures.begin(), pFeatures.end(), feature) - pFeatures.begin();
+            indicesToReDiscretize.push_back(index); // We need to re-discretize this feature
+            std::vector<std::string> parents;
+            transform(nodeParents.begin(), nodeParents.end(), back_inserter(parents), [](const auto& p) { return p->getName(); });
+            // Remove class as parent as it will be added later
+            parents.erase(remove(parents.begin(), parents.end(), pClassName), parents.end());
+            // Get the indices of the parents
+            std::vector<int> indices;
+            indices.push_back(-1); // Add class index
+            transform(parents.begin(), parents.end(), back_inserter(indices), [&](const auto& p) {return find(pFeatures.begin(), pFeatures.end(), p) - pFeatures.begin(); });
+            // Now we fit the discretizer of the feature, conditioned on its parents and the class i.e. discretizer.fit(X[index], X[indices] + y)
+            std::vector<std::string> yJoinParents(Xf.size(1));
+            for (auto idx : indices) {
+                for (int i = 0; i < Xf.size(1); ++i) {
+                    yJoinParents[i] += to_string(pDataset.index({ idx, i }).item<int>());
+                }
+            }
+            auto arff = ArffFiles();
+            auto yxv = arff.factorize(yJoinParents);
+            auto xvf_ptr = Xf.index({ index }).data_ptr<float>();
+            auto xvf = std::vector<mdlp::precision_t>(xvf_ptr, xvf_ptr + Xf.size(1));
+            discretizers[feature]->fit(xvf, yxv);
+        }
+        if (upgrade) {
+            // Discretize again X (only the affected indices) with the new fitted discretizers
+            for (auto index : indicesToReDiscretize) {
+                auto Xt_ptr = Xf.index({ index }).data_ptr<float>();
+                auto Xt = std::vector<float>(Xt_ptr, Xt_ptr + Xf.size(1));
+                pDataset.index_put_({ index, "..." }, torch::tensor(discretizers[pFeatures[index]]->transform(Xt)));
+                auto xStates = std::vector<int>(discretizers[pFeatures[index]]->getCutPoints().size() + 1);
+                iota(xStates.begin(), xStates.end(), 0);
+                //Update new states of the feature/node
+                states[pFeatures[index]] = xStates;
+            }
+            const torch::Tensor weights = torch::full({ pDataset.size(1) }, 1.0 / pDataset.size(1), torch::kDouble);
+            model.fit(pDataset, weights, pFeatures, pClassName, states);
+        }
+        return states;
+    }
+    map<std::string, std::vector<int>> Proposal::fit_local_discretization(const torch::Tensor& y)
+    {
+        // Discretize the continuous input data and build pDataset (Classifier::dataset)
+        int m = Xf.size(1);
+        int n = Xf.size(0);
+        map<std::string, std::vector<int>> states;
+        pDataset = torch::zeros({ n + 1, m }, torch::kInt32);
+        auto yv = std::vector<int>(y.data_ptr<int>(), y.data_ptr<int>() + y.size(0));
+        // discretize input data by feature(row)
+        for (auto i = 0; i < pFeatures.size(); ++i) {
+            auto* discretizer = new mdlp::CPPFImdlp();
+            auto Xt_ptr = Xf.index({ i }).data_ptr<float>();
+            auto Xt = std::vector<float>(Xt_ptr, Xt_ptr + Xf.size(1));
+            discretizer->fit(Xt, yv);
+            pDataset.index_put_({ i, "..." }, torch::tensor(discretizer->transform(Xt)));
+            auto xStates = std::vector<int>(discretizer->getCutPoints().size() + 1);
+            iota(xStates.begin(), xStates.end(), 0);
+            states[pFeatures[i]] = xStates;
+            discretizers[pFeatures[i]] = discretizer;
+        }
+        int n_classes = torch::max(y).item<int>() + 1;
+        auto yStates = std::vector<int>(n_classes);
+        iota(yStates.begin(), yStates.end(), 0);
+        states[pClassName] = yStates;
+        pDataset.index_put_({ n, "..." }, y);
+        return states;
+    }
+    torch::Tensor Proposal::prepareX(torch::Tensor& X)
+    {
+        auto Xtd = torch::zeros_like(X, torch::kInt32);
+        for (int i = 0; i < X.size(0); ++i) {
+            auto Xt = std::vector<float>(X[i].data_ptr<float>(), X[i].data_ptr<float>() + X.size(1));
+            auto Xd = discretizers[pFeatures[i]]->transform(Xt);
+            Xtd.index_put_({ i }, torch::tensor(Xd, torch::kInt32));
+        }
+        return Xtd;
+    }
+}

bayesnet/classifiers/Proposal.h

@@ -0,0 +1,30 @@
+#ifndef PROPOSAL_H
+#define PROPOSAL_H
+#include <string>
+#include <map>
+#include <torch/torch.h>
+#include <CPPFImdlp.h>
+#include "bayesnet/network/Network.h"
+#include "Classifier.h"
+
+namespace bayesnet {
+    class Proposal {
+    public:
+        Proposal(torch::Tensor& pDataset, std::vector<std::string>& features_, std::string& className_);
+        virtual ~Proposal();
+    protected:
+        void checkInput(const torch::Tensor& X, const torch::Tensor& y);
+        torch::Tensor prepareX(torch::Tensor& X);
+        map<std::string, std::vector<int>> localDiscretizationProposal(const map<std::string, std::vector<int>>& states, Network& model);
+        map<std::string, std::vector<int>> fit_local_discretization(const torch::Tensor& y);
+        torch::Tensor Xf; // X continuous nxm tensor
+        torch::Tensor y; // y discrete nx1 tensor
+        map<std::string, mdlp::CPPFImdlp*> discretizers;
+    private:
+        torch::Tensor& pDataset; // (n+1)xm tensor
+        std::vector<std::string>& pFeatures;
+        std::string& pClassName;
+    };
+}
+
+#endif  

bayesnet/classifiers/SPODE.cc

@@ -0,0 +1,25 @@
+#include "SPODE.h"
+
+namespace bayesnet {
+
+    SPODE::SPODE(int root) : Classifier(Network()), root(root) {}
+
+    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
+        for (int i = 0; i < static_cast<int>(features.size()); ++i) {
+            model.addEdge(className, features[i]);
+            if (i != root) {
+                model.addEdge(features[root], features[i]);
+            }
+        }
+    }
+    std::vector<std::string> SPODE::graph(const std::string& name) const
+    {
+        return model.graph(name);
+    }
+
+}

bayesnet/classifiers/SPODE.h

@@ -0,0 +1,17 @@
+#ifndef SPODE_H
+#define SPODE_H
+#include "Classifier.h"
+
+namespace bayesnet {
+    class SPODE : public Classifier {
+    private:
+        int root;
+    protected:
+        void buildModel(const torch::Tensor& weights) override;
+    public:
+        explicit SPODE(int root);
+        virtual ~SPODE() = default;
+        std::vector<std::string> graph(const std::string& name = "SPODE") const override;
+    };
+}
+#endif

bayesnet/classifiers/SPODELd.cc

@@ -0,0 +1,47 @@
+#include "SPODELd.h"
+
+namespace bayesnet {
+    SPODELd::SPODELd(int root) : SPODE(root), Proposal(dataset, features, className) {}
+    SPODELd& SPODELd::fit(torch::Tensor& X_, torch::Tensor& y_, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_)
+    {
+        checkInput(X_, y_);
+        features = features_;
+        className = className_;
+        Xf = X_;
+        y = y_;
+        // Fills std::vectors Xv & yv with the data from tensors X_ (discretized) & y
+        states = fit_local_discretization(y);
+        // We have discretized the input data
+        // 1st we need to fit the model to build the normal SPODE structure, SPODE::fit initializes the base Bayesian network
+        SPODE::fit(dataset, features, className, states);
+        states = localDiscretizationProposal(states, model);
+        return *this;
+    }
+    SPODELd& SPODELd::fit(torch::Tensor& dataset, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_)
+    {
+        if (!torch::is_floating_point(dataset)) {
+            throw std::runtime_error("Dataset must be a floating point tensor");
+        }
+        Xf = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), "..." }).clone();
+        y = dataset.index({ -1, "..." }).clone();
+        features = features_;
+        className = className_;
+        // Fills std::vectors Xv & yv with the data from tensors X_ (discretized) & y
+        states = fit_local_discretization(y);
+        // We have discretized the input data
+        // 1st we need to fit the model to build the normal SPODE structure, SPODE::fit initializes the base Bayesian network
+        SPODE::fit(dataset, features, className, states);
+        states = localDiscretizationProposal(states, model);
+        return *this;
+    }
+
+    torch::Tensor SPODELd::predict(torch::Tensor& X)
+    {
+        auto Xt = prepareX(X);
+        return SPODE::predict(Xt);
+    }
+    std::vector<std::string> SPODELd::graph(const std::string& name) const
+    {
+        return SPODE::graph(name);
+    }
+}

bayesnet/classifiers/SPODELd.h

@@ -0,0 +1,18 @@
+#ifndef SPODELD_H
+#define SPODELD_H
+#include "SPODE.h"
+#include "Proposal.h"
+
+namespace bayesnet {
+    class SPODELd : public SPODE, public Proposal {
+    public:
+        explicit SPODELd(int root);
+        virtual ~SPODELd() = default;
+        SPODELd& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, map<std::string, std::vector<int>>& states) override;
+        SPODELd& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, map<std::string, std::vector<int>>& states) override;
+        std::vector<std::string> graph(const std::string& name = "SPODE") const override;
+        torch::Tensor predict(torch::Tensor& X) override;
+        static inline std::string version() { return "0.0.1"; };
+    };
+}
+#endif // !SPODELD_H

bayesnet/classifiers/TAN.cc

@@ -0,0 +1,39 @@
+#include "TAN.h"
+
+namespace bayesnet {
+    TAN::TAN() : Classifier(Network()) {}
+
+    void TAN::buildModel(const torch::Tensor& weights)
+    {
+        // 0. Add all nodes to the model
+        addNodes();
+        // 1. Compute mutual information between each feature and the class and set the root node
+        // as the highest mutual information with the class
+        auto mi = std::vector <std::pair<int, float >>();
+        torch::Tensor class_dataset = dataset.index({ -1, "..." });
+        for (int i = 0; i < static_cast<int>(features.size()); ++i) {
+            torch::Tensor feature_dataset = dataset.index({ i, "..." });
+            auto mi_value = metrics.mutualInformation(class_dataset, feature_dataset, weights);
+            mi.push_back({ i, mi_value });
+        }
+        sort(mi.begin(), mi.end(), [](const auto& left, const auto& right) {return left.second < right.second;});
+        auto root = mi[mi.size() - 1].first;
+        // 2. Compute mutual information between each feature and the class
+        auto weights_matrix = metrics.conditionalEdge(weights);
+        // 3. Compute the maximum spanning tree
+        auto mst = metrics.maximumSpanningTree(features, weights_matrix, root);
+        // 4. Add edges from the maximum spanning tree to the model
+        for (auto i = 0; i < mst.size(); ++i) {
+            auto [from, to] = mst[i];
+            model.addEdge(features[from], features[to]);
+        }
+        // 5. Add edges from the class to all features
+        for (auto feature : features) {
+            model.addEdge(className, feature);
+        }
+    }
+    std::vector<std::string> TAN::graph(const std::string& title) const
+    {
+        return model.graph(title);
+    }
+}

bayesnet/classifiers/TAN.h

@@ -0,0 +1,15 @@
+#ifndef TAN_H
+#define TAN_H
+#include "Classifier.h"
+namespace bayesnet {
+    class TAN : public Classifier {
+    private:
+    protected:
+        void buildModel(const torch::Tensor& weights) override;
+    public:
+        TAN();
+        virtual ~TAN() = default;
+        std::vector<std::string> graph(const std::string& name = "TAN") const override;
+    };
+}
+#endif

bayesnet/classifiers/TANLd.cc

@@ -0,0 +1,30 @@
+#include "TANLd.h"
+
+namespace bayesnet {
+    TANLd::TANLd() : TAN(), Proposal(dataset, features, className) {}
+    TANLd& TANLd::fit(torch::Tensor& X_, torch::Tensor& y_, const std::vector<std::string>& features_, const std::string& className_, map<std::string, std::vector<int>>& states_)
+    {
+        checkInput(X_, y_);
+        features = features_;
+        className = className_;
+        Xf = X_;
+        y = y_;
+        // Fills std::vectors Xv & yv with the data from tensors X_ (discretized) & y
+        states = fit_local_discretization(y);
+        // We have discretized the input data
+        // 1st we need to fit the model to build the normal TAN structure, TAN::fit initializes the base Bayesian network
+        TAN::fit(dataset, features, className, states);
+        states = localDiscretizationProposal(states, model);
+        return *this;
+
+    }
+    torch::Tensor TANLd::predict(torch::Tensor& X)
+    {
+        auto Xt = prepareX(X);
+        return TAN::predict(Xt);
+    }
+    std::vector<std::string> TANLd::graph(const std::string& name) const
+    {
+        return TAN::graph(name);
+    }
+}

bayesnet/classifiers/TANLd.h

@@ -0,0 +1,18 @@
+#ifndef TANLD_H
+#define TANLD_H
+#include "TAN.h"
+#include "Proposal.h"
+
+namespace bayesnet {
+    class TANLd : public TAN, public Proposal {
+    private:
+    public:
+        TANLd();
+        virtual ~TANLd() = default;
+        TANLd& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, map<std::string, std::vector<int>>& states) override;
+        std::vector<std::string> graph(const std::string& name = "TAN") const override;
+        torch::Tensor predict(torch::Tensor& X) override;
+        static inline std::string version() { return "0.0.1"; };
+    };
+}
+#endif // !TANLD_H