From 06db8f51cec69c664fc9b4e891f57af199683aef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ricardo=20Monta=C3=B1ana?= Date: Mon, 7 Aug 2023 12:49:37 +0200 Subject: [PATCH] Refactor library and models to lighten data stored Refactro Ensemble to inherit from Classifier insted of BaseClassifier --- src/BayesNet/AODE.cc | 2 +- src/BayesNet/AODE.h | 2 +- src/BayesNet/AODELd.cc | 16 ++++++---- src/BayesNet/AODELd.h | 4 ++- src/BayesNet/BaseClassifier.h | 1 + src/BayesNet/BayesMetrics.cc | 10 +++--- src/BayesNet/BayesMetrics.h | 10 +++--- src/BayesNet/Classifier.cc | 60 ++++++++++++++++------------------- src/BayesNet/Classifier.h | 14 ++++---- src/BayesNet/Ensemble.cc | 50 +++-------------------------- src/BayesNet/Ensemble.h | 17 ++-------- src/BayesNet/KDB.cc | 5 +-- src/BayesNet/KDB.h | 2 +- src/BayesNet/KDBLd.cc | 9 ++---- src/BayesNet/Mst.cc | 2 +- src/BayesNet/Mst.h | 2 +- src/BayesNet/Network.cc | 26 +++++++-------- src/BayesNet/Network.h | 6 ++-- src/BayesNet/Node.cc | 20 +++++++++--- src/BayesNet/Node.h | 2 +- src/BayesNet/Proposal.cc | 22 ++++++------- src/BayesNet/Proposal.h | 9 +++--- src/BayesNet/SPODE.cc | 2 +- src/BayesNet/SPODE.h | 2 +- src/BayesNet/SPODELd.cc | 10 ++---- src/BayesNet/TAN.cc | 6 ++-- src/BayesNet/TAN.h | 2 +- src/BayesNet/TANLd.cc | 10 ++---- 28 files changed, 134 insertions(+), 189 deletions(-) diff --git a/src/BayesNet/AODE.cc b/src/BayesNet/AODE.cc index 6ec9361..66c71da 100644 --- a/src/BayesNet/AODE.cc +++ b/src/BayesNet/AODE.cc @@ -2,7 +2,7 @@ namespace bayesnet { AODE::AODE() : Ensemble() {} - void AODE::train() + void AODE::buildModel() { models.clear(); for (int i = 0; i < features.size(); ++i) { diff --git a/src/BayesNet/AODE.h b/src/BayesNet/AODE.h index 9a698e1..5447fc0 100644 --- a/src/BayesNet/AODE.h +++ b/src/BayesNet/AODE.h @@ -5,7 +5,7 @@ namespace bayesnet { class AODE : public Ensemble { protected: - void train() override; + void buildModel() override; public: AODE(); virtual ~AODE() {}; diff --git a/src/BayesNet/AODELd.cc b/src/BayesNet/AODELd.cc index 861aa71..18e3761 100644 --- a/src/BayesNet/AODELd.cc +++ b/src/BayesNet/AODELd.cc @@ -2,27 +2,31 @@ namespace bayesnet { using namespace std; - AODELd::AODELd() : Ensemble(), Proposal(Ensemble::Xv, Ensemble::yv, features, className) {} + AODELd::AODELd() : Ensemble(), Proposal(dataset, features, className) {} AODELd& AODELd::fit(torch::Tensor& X_, torch::Tensor& y_, vector& features_, string className_, map>& states_) { features = features_; className = className_; states = states_; - train(); - for (const auto& model : models) { - model->fit(X_, y_, features_, className_, states_); - } + buildModel(); + trainModel(); n_models = models.size(); fitted = true; return *this; } - void AODELd::train() + void AODELd::buildModel() { models.clear(); for (int i = 0; i < features.size(); ++i) { models.push_back(std::make_unique(i)); } } + void AODELd::trainModel() + { + for (const auto& model : models) { + model->fit(dataset, features, className, states); + } + } Tensor AODELd::predict(Tensor& X) { return Ensemble::predict(X); diff --git a/src/BayesNet/AODELd.h b/src/BayesNet/AODELd.h index 33a0dff..c8db41d 100644 --- a/src/BayesNet/AODELd.h +++ b/src/BayesNet/AODELd.h @@ -7,13 +7,15 @@ namespace bayesnet { using namespace std; class AODELd : public Ensemble, public Proposal { + private: + void trainModel(); + void buildModel() override; public: AODELd(); virtual ~AODELd() = default; AODELd& fit(torch::Tensor& X, torch::Tensor& y, vector& features, string className, map>& states) override; vector graph(const string& name = "AODE") override; Tensor predict(Tensor& X) override; - void train() override; static inline string version() { return "0.0.1"; }; }; } diff --git a/src/BayesNet/BaseClassifier.h b/src/BayesNet/BaseClassifier.h index 0ae9a1d..e95fafc 100644 --- a/src/BayesNet/BaseClassifier.h +++ b/src/BayesNet/BaseClassifier.h @@ -10,6 +10,7 @@ namespace bayesnet { virtual BaseClassifier& fit(vector>& X, vector& y, vector& features, string className, map>& states) = 0; // X is nxm tensor, y is nx1 tensor virtual BaseClassifier& fit(torch::Tensor& X, torch::Tensor& y, vector& features, string className, map>& states) = 0; + virtual BaseClassifier& fit(torch::Tensor& dataset, vector& features, string className, map>& states) = 0; virtual ~BaseClassifier() = default; torch::Tensor virtual predict(torch::Tensor& X) = 0; vector virtual predict(vector>& X) = 0; diff --git a/src/BayesNet/BayesMetrics.cc b/src/BayesNet/BayesMetrics.cc index c80fb65..8952ead 100644 --- a/src/BayesNet/BayesMetrics.cc +++ b/src/BayesNet/BayesMetrics.cc @@ -2,7 +2,7 @@ #include "Mst.h" namespace bayesnet { //samples is nxm tensor used to fit the model - Metrics::Metrics(torch::Tensor& samples, vector& features, string& className, int classNumStates) + Metrics::Metrics(const torch::Tensor& samples, const vector& features, const string& className, const int classNumStates) : samples(samples) , features(features) , className(className) @@ -76,7 +76,7 @@ namespace bayesnet { std::vector v(matrix.data_ptr(), matrix.data_ptr() + matrix.numel()); return v; } - double Metrics::entropy(torch::Tensor& feature) + double Metrics::entropy(const torch::Tensor& feature) { torch::Tensor counts = feature.bincount(); int totalWeight = counts.sum().item(); @@ -86,7 +86,7 @@ namespace bayesnet { return entropy.nansum().item(); } // H(Y|X) = sum_{x in X} p(x) H(Y|X=x) - double Metrics::conditionalEntropy(torch::Tensor& firstFeature, torch::Tensor& secondFeature) + double Metrics::conditionalEntropy(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature) { int numSamples = firstFeature.sizes()[0]; torch::Tensor featureCounts = secondFeature.bincount(); @@ -115,7 +115,7 @@ namespace bayesnet { return entropyValue; } // I(X;Y) = H(Y) - H(Y|X) - double Metrics::mutualInformation(torch::Tensor& firstFeature, torch::Tensor& secondFeature) + double Metrics::mutualInformation(const torch::Tensor& firstFeature, const torch::Tensor& secondFeature) { return entropy(firstFeature) - conditionalEntropy(firstFeature, secondFeature); } @@ -124,7 +124,7 @@ namespace bayesnet { and the indices of the weights as nodes of this square matrix using Kruskal algorithm */ - vector> Metrics::maximumSpanningTree(vector features, Tensor& weights, int root) + vector> Metrics::maximumSpanningTree(const vector& features, const Tensor& weights, const int root) { auto mst = MST(features, weights, root); return mst.maximumSpanningTree(); diff --git a/src/BayesNet/BayesMetrics.h b/src/BayesNet/BayesMetrics.h index 183cfcc..2a2fff3 100644 --- a/src/BayesNet/BayesMetrics.h +++ b/src/BayesNet/BayesMetrics.h @@ -14,15 +14,15 @@ namespace bayesnet { int classNumStates = 0; public: Metrics() = default; - Metrics(Tensor&, vector&, string&, int); + Metrics(const Tensor&, const vector&, const string&, const int); Metrics(const vector>&, const vector&, const vector&, const string&, const int); - double entropy(Tensor&); - double conditionalEntropy(Tensor&, Tensor&); - double mutualInformation(Tensor&, Tensor&); + double entropy(const Tensor&); + double conditionalEntropy(const Tensor&, const Tensor&); + double mutualInformation(const Tensor&, const Tensor&); vector conditionalEdgeWeights(); // To use in Python Tensor conditionalEdge(); vector> doCombinations(const vector&); - vector> maximumSpanningTree(vector features, Tensor& weights, int root); + vector> maximumSpanningTree(const vector& features, const Tensor& weights, const int root); }; } #endif \ No newline at end of file diff --git a/src/BayesNet/Classifier.cc b/src/BayesNet/Classifier.cc index 4d9a4c7..c84ebe6 100644 --- a/src/BayesNet/Classifier.cc +++ b/src/BayesNet/Classifier.cc @@ -7,59 +7,54 @@ namespace bayesnet { Classifier::Classifier(Network model) : model(model), m(0), n(0), metrics(Metrics()), fitted(false) {} Classifier& Classifier::build(vector& features, string className, map>& states) { - Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1); - samples = torch::cat({ X, ytmp }, 0); this->features = features; this->className = className; this->states = states; checkFitParameters(); auto n_classes = states[className].size(); - metrics = Metrics(samples, features, className, n_classes); + metrics = Metrics(dataset, features, className, n_classes); model.initialize(); - train(); - if (Xv.empty()) { - // fit with tensors - model.fit(X, y, features, className); - } else { - // fit with vectors - model.fit(Xv, yv, features, className); - } + buildModel(); + m = dataset.size(1); + n = dataset.size(0); + trainModel(); fitted = true; return *this; } + void Classifier::trainModel() + { + model.fit(dataset, features, className); + } + void Classifier::buildDataset(Tensor& ytmp) + { + ytmp = torch::transpose(ytmp.view({ ytmp.size(0), 1 }), 0, 1); + dataset = torch::cat({ dataset, ytmp }, 0); + } // X is nxm where n is the number of features and m the number of samples Classifier& Classifier::fit(torch::Tensor& X, torch::Tensor& y, vector& features, string className, map>& states) { - this->X = X; - this->y = y; - Xv = vector>(); - yv = vector(y.data_ptr(), y.data_ptr() + y.size(0)); + dataset = X; + buildDataset(y); return build(features, className, states); } - void Classifier::generateTensorXFromVector() - { - X = torch::zeros({ static_cast(Xv.size()), static_cast(Xv[0].size()) }, kInt32); - for (int i = 0; i < Xv.size(); ++i) { - X.index_put_({ i, "..." }, torch::tensor(Xv[i], kInt32)); - } - } // X is nxm where n is the number of features and m the number of samples Classifier& Classifier::fit(vector>& X, vector& y, vector& features, string className, map>& states) { - Xv = X; - generateTensorXFromVector(); - this->y = torch::tensor(y, kInt32); - yv = y; + dataset = torch::zeros({ static_cast(X.size()), static_cast(X[0].size()) }, kInt32); + for (int i = 0; i < X.size(); ++i) { + dataset.index_put_({ i, "..." }, torch::tensor(X[i], kInt32)); + } + auto ytmp = torch::tensor(y, kInt32); + buildDataset(ytmp); + return build(features, className, states); + } + Classifier& Classifier::fit(torch::Tensor& dataset, vector& features, string className, map>& states) + { + this->dataset = dataset; return build(features, className, states); } void Classifier::checkFitParameters() { - auto sizes = X.sizes(); - m = sizes[1]; - n = sizes[0]; - if (m != y.size(0)) { - throw invalid_argument("X and y must have the same number of samples"); - } if (n != features.size()) { throw invalid_argument("X and features must have the same number of features"); } @@ -141,5 +136,4 @@ namespace bayesnet { { model.dump_cpt(); } - } \ No newline at end of file diff --git a/src/BayesNet/Classifier.h b/src/BayesNet/Classifier.h index 03c46c6..d492d81 100644 --- a/src/BayesNet/Classifier.h +++ b/src/BayesNet/Classifier.h @@ -10,28 +10,26 @@ using namespace torch; namespace bayesnet { class Classifier : public BaseClassifier { private: - bool fitted; + void buildDataset(torch::Tensor& y); Classifier& build(vector& features, string className, map>& states); protected: + bool fitted; Network model; int m, n; // m: number of samples, n: number of features - Tensor X; // nxm tensor - vector> Xv; // nxm vector - Tensor y; - vector yv; - Tensor samples; // (n+1)xm tensor + Tensor dataset; // (n+1)xm tensor Metrics metrics; vector features; string className; map> states; void checkFitParameters(); - void generateTensorXFromVector(); - virtual void train() = 0; + virtual void buildModel() = 0; + void trainModel(); public: Classifier(Network model); virtual ~Classifier() = default; Classifier& fit(vector>& X, vector& y, vector& features, string className, map>& states) override; Classifier& fit(torch::Tensor& X, torch::Tensor& y, vector& features, string className, map>& states) override; + Classifier& fit(torch::Tensor& dataset, vector& features, string className, map>& states) override; void addNodes(); int getNumberOfNodes() override; int getNumberOfEdges() override; diff --git a/src/BayesNet/Ensemble.cc b/src/BayesNet/Ensemble.cc index 8cbd17c..d38430d 100644 --- a/src/BayesNet/Ensemble.cc +++ b/src/BayesNet/Ensemble.cc @@ -3,54 +3,15 @@ namespace bayesnet { using namespace torch; - Ensemble::Ensemble() : n_models(0), metrics(Metrics()), fitted(false) {} - Ensemble& Ensemble::build(vector& features, string className, map>& states) + Ensemble::Ensemble() : Classifier(Network()) {} + + void Ensemble::trainModel() { - Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1); - samples = torch::cat({ X, ytmp }, 0); - this->features = features; - this->className = className; - this->states = states; - auto n_classes = states[className].size(); - metrics = Metrics(samples, features, className, n_classes); - // Build models - train(); - // Train models n_models = models.size(); for (auto i = 0; i < n_models; ++i) { - if (Xv.empty()) { - // fit with tensors - models[i]->fit(X, y, features, className, states); - } else { - // fit with vectors - models[i]->fit(Xv, yv, features, className, states); - } + // fit with vectors + models[i]->fit(dataset, features, className, states); } - fitted = true; - return *this; - } - void Ensemble::generateTensorXFromVector() - { - X = torch::zeros({ static_cast(Xv.size()), static_cast(Xv[0].size()) }, kInt32); - for (int i = 0; i < Xv.size(); ++i) { - X.index_put_({ i, "..." }, torch::tensor(Xv[i], kInt32)); - } - } - Ensemble& Ensemble::fit(torch::Tensor& X, torch::Tensor& y, vector& features, string className, map>& states) - { - this->X = X; - this->y = y; - Xv = vector>(); - yv = vector(y.data_ptr(), y.data_ptr() + y.size(0)); - return build(features, className, states); - } - Ensemble& Ensemble::fit(vector>& X, vector& y, vector& features, string className, map>& states) - { - Xv = X; - generateTensorXFromVector(); - this->y = torch::tensor(y, kInt32); - yv = y; - return build(features, className, states); } vector Ensemble::voting(Tensor& y_pred) { @@ -132,7 +93,6 @@ namespace bayesnet { } } return (double)correct / y_pred.size(); - } vector Ensemble::show() { diff --git a/src/BayesNet/Ensemble.h b/src/BayesNet/Ensemble.h index 322032e..8efa0b7 100644 --- a/src/BayesNet/Ensemble.h +++ b/src/BayesNet/Ensemble.h @@ -8,30 +8,17 @@ using namespace std; using namespace torch; namespace bayesnet { - class Ensemble : public BaseClassifier { + class Ensemble : public Classifier { private: Ensemble& build(vector& features, string className, map>& states); protected: unsigned n_models; - bool fitted; vector> models; - Tensor X; - vector> Xv; - Tensor y; - vector yv; - Tensor samples; - Metrics metrics; - vector features; - string className; - map> states; - void virtual train() = 0; + void trainModel(); vector voting(Tensor& y_pred); - void generateTensorXFromVector(); public: Ensemble(); virtual ~Ensemble() = default; - Ensemble& fit(vector>& X, vector& y, vector& features, string className, map>& states) override; - Ensemble& fit(torch::Tensor& X, torch::Tensor& y, vector& features, string className, map>& states) override; Tensor predict(Tensor& X) override; vector predict(vector>& X) override; float score(Tensor& X, Tensor& y) override; diff --git a/src/BayesNet/KDB.cc b/src/BayesNet/KDB.cc index a0ab434..6988671 100644 --- a/src/BayesNet/KDB.cc +++ b/src/BayesNet/KDB.cc @@ -4,7 +4,7 @@ namespace bayesnet { using namespace torch; KDB::KDB(int k, float theta) : Classifier(Network()), k(k), theta(theta) {} - void KDB::train() + void KDB::buildModel() { /* 1. For each feature Xi, compute mutual information, I(X;C), @@ -28,9 +28,10 @@ namespace bayesnet { // 1. For each feature Xi, compute mutual information, I(X;C), // where C is the class. addNodes(); + const Tensor& y = dataset.index({ -1, "..." }); vector mi; for (auto i = 0; i < features.size(); i++) { - Tensor firstFeature = X.index({ i, "..." }); + Tensor firstFeature = dataset.index({ i, "..." }); mi.push_back(metrics.mutualInformation(firstFeature, y)); } // 2. Compute class conditional mutual information I(Xi;XjIC), f or each diff --git a/src/BayesNet/KDB.h b/src/BayesNet/KDB.h index 11a69d7..028bee8 100644 --- a/src/BayesNet/KDB.h +++ b/src/BayesNet/KDB.h @@ -11,7 +11,7 @@ namespace bayesnet { float theta; void add_m_edges(int idx, vector& S, Tensor& weights); protected: - void train() override; + void buildModel() override; public: explicit KDB(int k, float theta = 0.03); virtual ~KDB() {}; diff --git a/src/BayesNet/KDBLd.cc b/src/BayesNet/KDBLd.cc index d2cbed4..63344af 100644 --- a/src/BayesNet/KDBLd.cc +++ b/src/BayesNet/KDBLd.cc @@ -2,7 +2,7 @@ namespace bayesnet { using namespace std; - KDBLd::KDBLd(int k) : KDB(k), Proposal(KDB::Xv, KDB::yv, features, className) {} + KDBLd::KDBLd(int k) : KDB(k), Proposal(dataset, features, className) {} KDBLd& KDBLd::fit(torch::Tensor& X_, torch::Tensor& y_, vector& features_, string className_, map>& states_) { // This first part should go in a Classifier method called fit_local_discretization o fit_float... @@ -12,15 +12,10 @@ namespace bayesnet { y = y_; // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y fit_local_discretization(states, y); - generateTensorXFromVector(); // 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(KDB::Xv, KDB::yv, features, className, states); + KDB::fit(dataset, features, className, states); localDiscretizationProposal(states, model); - generateTensorXFromVector(); - Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1); - samples = torch::cat({ X, ytmp }, 0); - model.fit(KDB::Xv, KDB::yv, features, className); return *this; } Tensor KDBLd::predict(Tensor& X) diff --git a/src/BayesNet/Mst.cc b/src/BayesNet/Mst.cc index 3a48d05..b915d76 100644 --- a/src/BayesNet/Mst.cc +++ b/src/BayesNet/Mst.cc @@ -94,7 +94,7 @@ namespace bayesnet { return result; } - MST::MST(vector& features, Tensor& weights, int root) : features(features), weights(weights), root(root) {} + MST::MST(const vector& features, const Tensor& weights, const int root) : features(features), weights(weights), root(root) {} vector> MST::maximumSpanningTree() { auto num_features = features.size(); diff --git a/src/BayesNet/Mst.h b/src/BayesNet/Mst.h index 71a46a5..e0f3372 100644 --- a/src/BayesNet/Mst.h +++ b/src/BayesNet/Mst.h @@ -13,7 +13,7 @@ namespace bayesnet { int root = 0; public: MST() = default; - MST(vector& features, Tensor& weights, int root); + MST(const vector& features, const Tensor& weights, const int root); vector> maximumSpanningTree(); }; class Graph { diff --git a/src/BayesNet/Network.cc b/src/BayesNet/Network.cc index 2a37de4..5b6307a 100644 --- a/src/BayesNet/Network.cc +++ b/src/BayesNet/Network.cc @@ -20,7 +20,6 @@ namespace bayesnet { classNumStates = 0; fitted = false; nodes.clear(); - dataset.clear(); samples = torch::Tensor(); } float Network::getmaxThreads() @@ -134,18 +133,22 @@ namespace bayesnet { classNumStates = nodes[className]->getNumStates(); } // X comes in nxm, where n is the number of features and m the number of samples - void Network::fit(torch::Tensor& X, torch::Tensor& y, const vector& featureNames, const string& className) + void Network::fit(const torch::Tensor& X, const torch::Tensor& y, const vector& featureNames, const string& className) { checkFitData(X.size(1), X.size(0), y.size(0), featureNames, className); this->className = className; - dataset.clear(); Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1); samples = torch::cat({ X , ytmp }, 0); for (int i = 0; i < featureNames.size(); ++i) { auto row_feature = X.index({ i, "..." }); - dataset[featureNames[i]] = vector(row_feature.data_ptr(), row_feature.data_ptr() + row_feature.size(0));; } - dataset[className] = vector(y.data_ptr(), y.data_ptr() + y.size(0)); + completeFit(); + } + void Network::fit(const torch::Tensor& samples, const vector& featureNames, const string& className) + { + checkFitData(samples.size(1), samples.size(0) - 1, samples.size(1), featureNames, className); + this->className = className; + this->samples = samples; completeFit(); } // input_data comes in nxm, where n is the number of features and m the number of samples @@ -153,14 +156,11 @@ namespace bayesnet { { checkFitData(input_data[0].size(), input_data.size(), labels.size(), featureNames, className); this->className = className; - dataset.clear(); - // Build dataset & tensor of samples (nxm) (n+1 because of the class) + // Build tensor of samples (nxm) (n+1 because of the class) samples = torch::zeros({ static_cast(input_data.size() + 1), static_cast(input_data[0].size()) }, torch::kInt32); for (int i = 0; i < featureNames.size(); ++i) { - dataset[featureNames[i]] = input_data[i]; samples.index_put_({ i, "..." }, torch::tensor(input_data[i], torch::kInt32)); } - dataset[className] = labels; samples.index_put_({ -1, "..." }, torch::tensor(labels, torch::kInt32)); completeFit(); } @@ -188,7 +188,7 @@ namespace bayesnet { auto& pair = *std::next(nodes.begin(), nextNodeIndex); ++nextNodeIndex; lock.unlock(); - pair.second->computeCPT(dataset, laplaceSmoothing); + pair.second->computeCPT(samples, features, laplaceSmoothing); lock.lock(); nodes[pair.first] = std::move(pair.second); lock.unlock(); @@ -328,12 +328,12 @@ namespace bayesnet { mutex mtx; for (int i = 0; i < classNumStates; ++i) { threads.emplace_back([this, &result, &evidence, i, &mtx]() { - auto completeEvidence = map(evidence); - completeEvidence[getClassName()] = i; + auto completeEvidence = map(evidence); + completeEvidence[getClassName()] = i; double factor = computeFactor(completeEvidence); lock_guard lock(mtx); result[i] = factor; - }); + }); } for (auto& thread : threads) { thread.join(); diff --git a/src/BayesNet/Network.h b/src/BayesNet/Network.h index b27125c..616235a 100644 --- a/src/BayesNet/Network.h +++ b/src/BayesNet/Network.h @@ -8,11 +8,10 @@ namespace bayesnet { class Network { private: map> nodes; - map> dataset; bool fitted; float maxThreads = 0.95; int classNumStates; - vector features; // Including class + vector features; // Including classname string className; int laplaceSmoothing = 1; torch::Tensor samples; // nxm tensor used to fit the model @@ -44,7 +43,8 @@ namespace bayesnet { int getClassNumStates(); string getClassName(); void fit(const vector>&, const vector&, const vector&, const string&); - void fit(torch::Tensor&, torch::Tensor&, const vector&, const string&); + void fit(const torch::Tensor&, const torch::Tensor&, const vector&, const string&); + void fit(const torch::Tensor&, const vector&, const string&); vector predict(const vector>&); // Return mx1 vector of predictions torch::Tensor predict(const torch::Tensor&); // Return mx1 tensor of predictions //Computes the conditional edge weight of variable index u and v conditioned on class_node diff --git a/src/BayesNet/Node.cc b/src/BayesNet/Node.cc index 3fca064..6669819 100644 --- a/src/BayesNet/Node.cc +++ b/src/BayesNet/Node.cc @@ -84,7 +84,7 @@ namespace bayesnet { } return result; } - void Node::computeCPT(map>& dataset, const int laplaceSmoothing) + void Node::computeCPT(const torch::Tensor& dataset, const vector& features, const int laplaceSmoothing) { dimensions.clear(); // Get dimensions of the CPT @@ -94,10 +94,22 @@ namespace bayesnet { // Create a tensor of zeros with the dimensions of the CPT cpTable = torch::zeros(dimensions, torch::kFloat) + laplaceSmoothing; // Fill table with counts - for (int n_sample = 0; n_sample < dataset[name].size(); ++n_sample) { + auto pos = find(features.begin(), features.end(), name); + if (pos == features.end()) { + throw logic_error("Feature " + name + " not found in dataset"); + } + int name_index = pos - features.begin(); + for (int n_sample = 0; n_sample < dataset.size(1); ++n_sample) { torch::List> coordinates; - coordinates.push_back(torch::tensor(dataset[name][n_sample])); - transform(parents.begin(), parents.end(), back_inserter(coordinates), [&dataset, &n_sample](const auto& parent) { return torch::tensor(dataset[parent->getName()][n_sample]); }); + coordinates.push_back(dataset.index({ name_index, n_sample })); + for (auto parent : parents) { + pos = find(features.begin(), features.end(), parent->getName()); + if (pos == features.end()) { + throw logic_error("Feature parent " + parent->getName() + " not found in dataset"); + } + int parent_index = pos - features.begin(); + coordinates.push_back(dataset.index({ parent_index, n_sample })); + } // Increment the count of the corresponding coordinate cpTable.index_put_({ coordinates }, cpTable.index({ coordinates }) + 1); } diff --git a/src/BayesNet/Node.h b/src/BayesNet/Node.h index b923dec..f4eb320 100644 --- a/src/BayesNet/Node.h +++ b/src/BayesNet/Node.h @@ -26,7 +26,7 @@ namespace bayesnet { vector& getParents(); vector& getChildren(); torch::Tensor& getCPT(); - void computeCPT(map>&, const int); + void computeCPT(const torch::Tensor&, const vector&, const int); int getNumStates() const; void setNumStates(int); unsigned minFill(); diff --git a/src/BayesNet/Proposal.cc b/src/BayesNet/Proposal.cc index c1d3626..19992c6 100644 --- a/src/BayesNet/Proposal.cc +++ b/src/BayesNet/Proposal.cc @@ -2,7 +2,7 @@ #include "ArffFiles.h" namespace bayesnet { - Proposal::Proposal(vector>& Xv_, vector& yv_, vector& features_, string& className_) : Xv(Xv_), yv(yv_), pFeatures(features_), pClassName(className_) {} + Proposal::Proposal(torch::Tensor& dataset_, vector& features_, string& className_) : pDataset(dataset_), pFeatures(features_), pClassName(className_), m(dataset_.size(1)), n(dataset_.size(0) - 1) {} Proposal::~Proposal() { for (auto& [key, value] : discretizers) { @@ -16,7 +16,6 @@ namespace bayesnet { auto order = model.topological_sort(); auto& nodes = model.getNodes(); vector indicesToReDiscretize; - auto n_samples = Xf.size(1); bool upgrade = false; // Flag to check if we need to upgrade the model for (auto feature : order) { auto nodeParents = nodes[feature]->getParents(); @@ -30,13 +29,13 @@ namespace bayesnet { parents.erase(remove(parents.begin(), parents.end(), pClassName), parents.end()); // Get the indices of the parents vector indices; + indices.push_back(-1); // Add class index transform(parents.begin(), parents.end(), back_inserter(indices), [&](const auto& p) {return find(pFeatures.begin(), pFeatures.end(), p) - pFeatures.begin(); }); // Now we fit the discretizer of the feature, conditioned on its parents and the class i.e. discretizer.fit(X[index], X[indices] + y) - vector yJoinParents; - transform(yv.begin(), yv.end(), back_inserter(yJoinParents), [&](const auto& p) {return to_string(p); }); + vector yJoinParents(indices.size()); for (auto idx : indices) { - for (int i = 0; i < n_samples; ++i) { - yJoinParents[i] += to_string(Xv[idx][i]); + for (int i = 0; i < n; ++i) { + yJoinParents[i] += to_string(pDataset.index({ idx, i }).item()); } } auto arff = ArffFiles(); @@ -59,7 +58,7 @@ namespace bayesnet { for (auto index : indicesToReDiscretize) { auto Xt_ptr = Xf.index({ index }).data_ptr(); auto Xt = vector(Xt_ptr, Xt_ptr + Xf.size(1)); - Xv[index] = discretizers[pFeatures[index]]->transform(Xt); + pDataset.index_put_({ index, "..." }, torch::tensor(discretizers[pFeatures[index]]->transform(Xt))); auto xStates = vector(discretizers[pFeatures[index]]->getCutPoints().size() + 1); iota(xStates.begin(), xStates.end(), 0); //Update new states of the feature/node @@ -69,16 +68,15 @@ namespace bayesnet { } void Proposal::fit_local_discretization(map>& states, torch::Tensor& y) { - // Sharing Xv and yv with Classifier - Xv = vector>(); - yv = vector(y.data_ptr(), y.data_ptr() + y.size(0)); + pDataset = torch::zeros({ n + 1, m }, kInt32); + auto yv = vector(y.data_ptr(), y.data_ptr() + y.size(0)); // discretize input data by feature(row) - for (int i = 0; i < pFeatures.size(); ++i) { + for (auto i = 0; i < pFeatures.size(); ++i) { auto* discretizer = new mdlp::CPPFImdlp(); auto Xt_ptr = Xf.index({ i }).data_ptr(); auto Xt = vector(Xt_ptr, Xt_ptr + Xf.size(1)); discretizer->fit(Xt, yv); - Xv.push_back(discretizer->transform(Xt)); + pDataset.index_put_({ i, "..." }, torch::tensor(discretizer->transform(Xt))); auto xStates = vector(discretizer->getCutPoints().size() + 1); iota(xStates.begin(), xStates.end(), 0); states[pFeatures[i]] = xStates; diff --git a/src/BayesNet/Proposal.h b/src/BayesNet/Proposal.h index a5650b4..606ed5a 100644 --- a/src/BayesNet/Proposal.h +++ b/src/BayesNet/Proposal.h @@ -10,20 +10,21 @@ namespace bayesnet { class Proposal { public: - Proposal(vector>& Xv_, vector& yv_, vector& features_, string& className_); + Proposal(torch::Tensor& pDataset, vector& features_, string& className_); virtual ~Proposal(); protected: torch::Tensor prepareX(torch::Tensor& X); void localDiscretizationProposal(map>& states, Network& model); void fit_local_discretization(map>& states, torch::Tensor& y); torch::Tensor Xf; // X continuous nxm tensor + torch::Tensor y; // y discrete nx1 tensor map discretizers; + int m, n; private: + torch::Tensor& pDataset; // (n+1)xm tensor vector& pFeatures; string& pClassName; - vector>& Xv; // X discrete nxm vector - vector& yv; }; } -#endif \ No newline at end of file +#endif \ No newline at end of file diff --git a/src/BayesNet/SPODE.cc b/src/BayesNet/SPODE.cc index a627cca..eba6542 100644 --- a/src/BayesNet/SPODE.cc +++ b/src/BayesNet/SPODE.cc @@ -4,7 +4,7 @@ namespace bayesnet { SPODE::SPODE(int root) : Classifier(Network()), root(root) {} - void SPODE::train() + void SPODE::buildModel() { // 0. Add all nodes to the model addNodes(); diff --git a/src/BayesNet/SPODE.h b/src/BayesNet/SPODE.h index 4625714..d441e66 100644 --- a/src/BayesNet/SPODE.h +++ b/src/BayesNet/SPODE.h @@ -7,7 +7,7 @@ namespace bayesnet { private: int root; protected: - void train() override; + void buildModel() override; public: explicit SPODE(int root); virtual ~SPODE() {}; diff --git a/src/BayesNet/SPODELd.cc b/src/BayesNet/SPODELd.cc index f7df9b6..8b9fe2f 100644 --- a/src/BayesNet/SPODELd.cc +++ b/src/BayesNet/SPODELd.cc @@ -2,7 +2,7 @@ namespace bayesnet { using namespace std; - SPODELd::SPODELd(int root) : SPODE(root), Proposal(SPODE::Xv, SPODE::yv, features, className) {} + SPODELd::SPODELd(int root) : SPODE(root), Proposal(dataset, features, className) {} SPODELd& SPODELd::fit(torch::Tensor& X_, torch::Tensor& y_, vector& features_, string className_, map>& states_) { // This first part should go in a Classifier method called fit_local_discretization o fit_float... @@ -12,15 +12,11 @@ namespace bayesnet { y = y_; // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y fit_local_discretization(states, y); - generateTensorXFromVector(); // 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(SPODE::Xv, SPODE::yv, features, className, states); + SPODE::fit(dataset, features, className, states); localDiscretizationProposal(states, model); - generateTensorXFromVector(); - Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1); - samples = torch::cat({ X, ytmp }, 0); - model.fit(SPODE::Xv, SPODE::yv, features, className); + //model.fit(SPODE::Xv, SPODE::yv, features, className); return *this; } Tensor SPODELd::predict(Tensor& X) diff --git a/src/BayesNet/TAN.cc b/src/BayesNet/TAN.cc index f47d7c5..c77275c 100644 --- a/src/BayesNet/TAN.cc +++ b/src/BayesNet/TAN.cc @@ -5,16 +5,16 @@ namespace bayesnet { TAN::TAN() : Classifier(Network()) {} - void TAN::train() + void TAN::buildModel() { // 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 = vector >(); - Tensor class_dataset = samples.index({ -1, "..." }); + Tensor class_dataset = dataset.index({ -1, "..." }); for (int i = 0; i < static_cast(features.size()); ++i) { - Tensor feature_dataset = samples.index({ i, "..." }); + Tensor feature_dataset = dataset.index({ i, "..." }); auto mi_value = metrics.mutualInformation(class_dataset, feature_dataset); mi.push_back({ i, mi_value }); } diff --git a/src/BayesNet/TAN.h b/src/BayesNet/TAN.h index 5c7cf49..6d95e21 100644 --- a/src/BayesNet/TAN.h +++ b/src/BayesNet/TAN.h @@ -7,7 +7,7 @@ namespace bayesnet { class TAN : public Classifier { private: protected: - void train() override; + void buildModel() override; public: TAN(); virtual ~TAN() {}; diff --git a/src/BayesNet/TANLd.cc b/src/BayesNet/TANLd.cc index f0fe110..49ffa96 100644 --- a/src/BayesNet/TANLd.cc +++ b/src/BayesNet/TANLd.cc @@ -2,7 +2,7 @@ namespace bayesnet { using namespace std; - TANLd::TANLd() : TAN(), Proposal(TAN::Xv, TAN::yv, features, className) {} + TANLd::TANLd() : TAN(), Proposal(dataset, features, className) {} TANLd& TANLd::fit(torch::Tensor& X_, torch::Tensor& y_, vector& features_, string className_, map>& states_) { // This first part should go in a Classifier method called fit_local_discretization o fit_float... @@ -12,15 +12,11 @@ namespace bayesnet { y = y_; // Fills vectors Xv & yv with the data from tensors X_ (discretized) & y fit_local_discretization(states, y); - generateTensorXFromVector(); // 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(TAN::Xv, TAN::yv, features, className, states); + TAN::fit(dataset, features, className, states); localDiscretizationProposal(states, model); - generateTensorXFromVector(); - Tensor ytmp = torch::transpose(y.view({ y.size(0), 1 }), 0, 1); - samples = torch::cat({ X, ytmp }, 0); - model.fit(TAN::Xv, TAN::yv, features, className); + //model.fit(dataset, features, className); return *this; } Tensor TANLd::predict(Tensor& X)