Relintai/pmlpp
1
0
Fork 0
mirror of https://github.com/Relintai/pmlpp.git synced 2025-02-01 17:07:02 +01:00
Code Issues Packages Projects Releases Wiki Activity

Initial cleanup pass on MLPPMultinomialNB.

Browse Source
This commit is contained in:
Relintai 2023-02-11 09:33:09 +01:00
parent f24bf466c8
commit 7bc5a5bc1d
4 changed files with 194 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

181
mlpp/multinomial_nb/multinomial_nb.cpp
View File

@ -12,101 +12,162 @@
#include <iostream> #include <iostream>
#include <random> #include <random>
MLPPMultinomialNB::MLPPMultinomialNB(std::vector<std::vector<real_t>> pinputSet, std::vector<real_t> poutputSet, int pclass_num) { /*
inputSet = pinputSet; Ref<MLPPMatrix> MLPPMultinomialNB::get_input_set() {
outputSet = poutputSet; return _input_set;
class_num = pclass_num; }
void MLPPMultinomialNB::set_input_set(const Ref<MLPPMatrix> &val) {
_input_set = val;
y_hat.resize(outputSet.size()); _initialized = false;
Evaluate();
} }
std::vector<real_t> MLPPMultinomialNB::modelSetTest(std::vector<std::vector<real_t>> X) { Ref<MLPPVector> MLPPMultinomialNB::get_output_set() {
return _output_set;
}
void MLPPMultinomialNB::set_output_set(const Ref<MLPPMatrix> &val) {
_output_set = val;
_initialized = false;
}
real_t MLPPMultinomialNB::get_class_num() {
return _class_num;
}
void MLPPMultinomialNB::set_class_num(const real_t val) {
_class_num = val;
_initialized = false;
}
*/
std::vector<real_t> MLPPMultinomialNB::model_set_test(std::vector<std::vector<real_t>> X) {
ERR_FAIL_COND_V(!_initialized, std::vector<real_t>());
std::vector<real_t> y_hat; std::vector<real_t> y_hat;
for (uint32_t i = 0; i < X.size(); i++) { for (uint32_t i = 0; i < X.size(); i++) {
y_hat.push_back(modelTest(X[i])); y_hat.push_back(model_test(X[i]));
} }
return y_hat; return y_hat;
} }
real_t MLPPMultinomialNB::modelTest(std::vector<real_t> x) { real_t MLPPMultinomialNB::model_test(std::vector<real_t> x) {
real_t score[class_num]; ERR_FAIL_COND_V(!_initialized, 0);
computeTheta();
real_t score[_class_num];
compute_theta();
for (uint32_t j = 0; j < x.size(); j++) { for (uint32_t j = 0; j < x.size(); j++) {
for (uint32_t k = 0; k < vocab.size(); k++) { for (uint32_t k = 0; k < _vocab.size(); k++) {
if (x[j] == vocab[k]) { if (x[j] == _vocab[k]) {
for (int p = class_num - 1; p >= 0; p--) { for (int p = _class_num - 1; p >= 0; p--) {
score[p] += std::log(theta[p][vocab[k]]); score[p] += std::log(_theta[p][_vocab[k]]);
} }
} }
} }
} }
for (uint32_t i = 0; i < priors.size(); i++) { for (uint32_t i = 0; i < _priors.size(); i++) {
score[i] += std::log(priors[i]); score[i] += std::log(_priors[i]);
} }
return std::distance(score, std::max_element(score, score + sizeof(score) / sizeof(real_t))); return std::distance(score, std::max_element(score, score + sizeof(score) / sizeof(real_t)));
} }
real_t MLPPMultinomialNB::score() { real_t MLPPMultinomialNB::score() {
ERR_FAIL_COND_V(!_initialized, 0);
MLPPUtilities util; MLPPUtilities util;
return util.performance(y_hat, outputSet);
return util.performance(_y_hat, _output_set);
} }
void MLPPMultinomialNB::computeTheta() { bool MLPPMultinomialNB::is_initialized() {
return _initialized;
}
void MLPPMultinomialNB::initialize() {
if (_initialized) {
return;
}
//ERR_FAIL_COND(!_input_set.is_valid() || !_output_set.is_valid());
_initialized = true;
}
MLPPMultinomialNB::MLPPMultinomialNB(std::vector<std::vector<real_t>> p_input_set, std::vector<real_t> p_output_set, int pclass_num) {
_input_set = p_input_set;
_output_set = p_output_set;
_class_num = pclass_num;
_y_hat.resize(_output_set.size());
_initialized = true;
evaluate();
}
MLPPMultinomialNB::MLPPMultinomialNB() {
_initialized = false;
}
MLPPMultinomialNB::~MLPPMultinomialNB() {
}
void MLPPMultinomialNB::compute_theta() {
// Resizing theta for the sake of ease & proper access of the elements. // Resizing theta for the sake of ease & proper access of the elements.
theta.resize(class_num); _theta.resize(_class_num);
// Setting all values in the hasmap by default to 0. // Setting all values in the hasmap by default to 0.
for (int i = class_num - 1; i >= 0; i--) { for (int i = _class_num - 1; i >= 0; i--) {
for (uint32_t j = 0; j < vocab.size(); j++) { for (uint32_t j = 0; j < _vocab.size(); j++) {
theta[i][vocab[j]] = 0; _theta[i][_vocab[j]] = 0;
} }
} }
for (uint32_t i = 0; i < inputSet.size(); i++) { for (uint32_t i = 0; i < _input_set.size(); i++) {
for (uint32_t j = 0; j < inputSet[0].size(); j++) { for (uint32_t j = 0; j < _input_set[0].size(); j++) {
theta[outputSet[i]][inputSet[i][j]]++; _theta[_output_set[i]][_input_set[i][j]]++;
} }
} }
for (uint32_t i = 0; i < theta.size(); i++) { for (uint32_t i = 0; i < _theta.size(); i++) {
for (uint32_t j = 0; j < theta[i].size(); j++) { for (uint32_t j = 0; j < _theta[i].size(); j++) {
theta[i][j] /= priors[i] * y_hat.size(); _theta[i][j] /= _priors[i] * _y_hat.size();
} }
} }
} }
void MLPPMultinomialNB::Evaluate() { void MLPPMultinomialNB::evaluate() {
MLPPLinAlg alg; MLPPLinAlg alg;
for (uint32_t i = 0; i < outputSet.size(); i++) {
for (uint32_t i = 0; i < _output_set.size(); i++) {
// Pr(B | A) * Pr(A) // Pr(B | A) * Pr(A)
real_t score[class_num]; real_t score[_class_num];
// Easy computation of priors, i.e. Pr(C_k) // Easy computation of priors, i.e. Pr(C_k)
priors.resize(class_num); _priors.resize(_class_num);
for (uint32_t ii = 0; ii < outputSet.size(); ii++) { for (uint32_t ii = 0; ii < _output_set.size(); ii++) {
priors[int(outputSet[ii])]++; _priors[int(_output_set[ii])]++;
} }
priors = alg.scalarMultiply(real_t(1) / real_t(outputSet.size()), priors);
_priors = alg.scalarMultiply(real_t(1) / real_t(_output_set.size()), _priors);
// Evaluating Theta... // Evaluating Theta...
computeTheta(); compute_theta();
for (uint32_t j = 0; j < inputSet.size(); j++) { for (uint32_t j = 0; j < _input_set.size(); j++) {
for (uint32_t k = 0; k < vocab.size(); k++) { for (uint32_t k = 0; k < _vocab.size(); k++) {
if (inputSet[i][j] == vocab[k]) { if (_input_set[i][j] == _vocab[k]) {
for (int p = class_num - 1; p >= 0; p--) { for (int p = _class_num - 1; p >= 0; p--) {
score[p] += std::log(theta[i][vocab[k]]); score[p] += std::log(_theta[i][_vocab[k]]);
} }
} }
} }
} }
for (uint32_t ii = 0; ii < priors.size(); ii++) { for (uint32_t ii = 0; ii < _priors.size(); ii++) {
score[ii] += std::log(priors[ii]); score[ii] += std::log(_priors[ii]);
score[ii] = exp(score[ii]); score[ii] = exp(score[ii]);
} }
@ -115,6 +176,36 @@ void MLPPMultinomialNB::Evaluate() {
} }
// Assigning the traning example's y_hat to a class // Assigning the traning example's y_hat to a class
y_hat[i] = std::distance(score, std::max_element(score, score + sizeof(score) / sizeof(real_t))); _y_hat[i] = std::distance(score, std::max_element(score, score + sizeof(score) / sizeof(real_t)));
} }
} }
void MLPPMultinomialNB::_bind_methods() {
/*
ClassDB::bind_method(D_METHOD("get_input_set"), &MLPPMultinomialNB::get_input_set);
ClassDB::bind_method(D_METHOD("set_input_set", "val"), &MLPPMultinomialNB::set_input_set);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input_set", PROPERTY_HINT_RESOURCE_TYPE, "MLPPMatrix"), "set_input_set", "get_input_set");
ClassDB::bind_method(D_METHOD("get_output_set"), &MLPPMultinomialNB::get_output_set);
ClassDB::bind_method(D_METHOD("set_output_set", "val"), &MLPPMultinomialNB::set_output_set);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "output_set", PROPERTY_HINT_RESOURCE_TYPE, "MLPPVector"), "set_output_set", "get_output_set");
ClassDB::bind_method(D_METHOD("get_c"), &MLPPMultinomialNB::get_c);
ClassDB::bind_method(D_METHOD("set_c", "val"), &MLPPMultinomialNB::set_c);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "c"), "set_c", "get_c");
ClassDB::bind_method(D_METHOD("model_set_test", "X"), &MLPPMultinomialNB::model_set_test);
ClassDB::bind_method(D_METHOD("model_test", "x"), &MLPPMultinomialNB::model_test);
ClassDB::bind_method(D_METHOD("gradient_descent", "learning_rate", "max_epoch", "ui"), &MLPPMultinomialNB::gradient_descent, false);
ClassDB::bind_method(D_METHOD("sgd", "learning_rate", "max_epoch", "ui"), &MLPPMultinomialNB::sgd, false);
ClassDB::bind_method(D_METHOD("mbgd", "learning_rate", "max_epoch", "mini_batch_size", "ui"), &MLPPMultinomialNB::mbgd, false);
ClassDB::bind_method(D_METHOD("score"), &MLPPMultinomialNB::score);
ClassDB::bind_method(D_METHOD("save", "file_name"), &MLPPMultinomialNB::save);
ClassDB::bind_method(D_METHOD("is_initialized"), &MLPPMultinomialNB::is_initialized);
ClassDB::bind_method(D_METHOD("initialize"), &MLPPMultinomialNB::initialize);
*/
}

56
mlpp/multinomial_nb/multinomial_nb.h
View File

@ -10,31 +10,59 @@
#include "core/math/math_defs.h" #include "core/math/math_defs.h"
#include "core/object/reference.h"
#include "../lin_alg/mlpp_matrix.h"
#include "../lin_alg/mlpp_vector.h"
#include <map> #include <map>
#include <vector> #include <vector>
class MLPPMultinomialNB { class MLPPMultinomialNB : public Reference {
GDCLASS(MLPPMultinomialNB, Reference);
public: public:
MLPPMultinomialNB(std::vector<std::vector<real_t>> inputSet, std::vector<real_t> outputSet, int class_num); Ref<MLPPMatrix> get_input_set();
std::vector<real_t> modelSetTest(std::vector<std::vector<real_t>> X); void set_input_set(const Ref<MLPPMatrix> &val);
real_t modelTest(std::vector<real_t> x);
Ref<MLPPVector> get_output_set();
void set_output_set(const Ref<MLPPMatrix> &val);
real_t get_class_num();
void set_class_num(const real_t val);
std::vector<real_t> model_set_test(std::vector<std::vector<real_t>> X);
real_t model_test(std::vector<real_t> x);
real_t score(); real_t score();
private: bool is_initialized();
void computeTheta(); void initialize();
void Evaluate();
MLPPMultinomialNB(std::vector<std::vector<real_t>> _input_set, std::vector<real_t> _output_set, int class_num);
MLPPMultinomialNB();
~MLPPMultinomialNB();
protected:
void compute_theta();
void evaluate();
static void _bind_methods();
// Model Params // Model Params
std::vector<real_t> priors; std::vector<real_t> _priors;
std::vector<std::map<real_t, int>> theta; std::vector<std::map<real_t, int>> _theta;
std::vector<real_t> vocab; std::vector<real_t> _vocab;
int class_num; int _class_num;
// Datasets // Datasets
std::vector<std::vector<real_t>> inputSet; std::vector<std::vector<real_t>> _input_set;
std::vector<real_t> outputSet; std::vector<real_t> _output_set;
std::vector<real_t> y_hat; std::vector<real_t> _y_hat;
bool _initialized;
}; };
#endif /* MultinomialNB_hpp */ #endif /* MultinomialNB_hpp */

1
mlpp/output_layer/output_layer.h
View File

@ -20,6 +20,7 @@
#include "../lin_alg/mlpp_matrix.h" #include "../lin_alg/mlpp_matrix.h"
#include "../lin_alg/mlpp_vector.h" #include "../lin_alg/mlpp_vector.h"
class MLPPOutputLayer : public Reference { class MLPPOutputLayer : public Reference {
GDCLASS(MLPPOutputLayer, Reference); GDCLASS(MLPPOutputLayer, Reference);

30
test/mlpp_tests.cpp
View File

@ -47,20 +47,8 @@
#include "../mlpp/uni_lin_reg/uni_lin_reg.h" #include "../mlpp/uni_lin_reg/uni_lin_reg.h"
#include "../mlpp/wgan/wgan.h" #include "../mlpp/wgan/wgan.h"
#include "../mlpp/auto_encoder/auto_encoder_old.h"
#include "../mlpp/mlp/mlp_old.h"
#include "../mlpp/outlier_finder/outlier_finder_old.h"
#include "../mlpp/pca/pca_old.h"
#include "../mlpp/probit_reg/probit_reg_old.h"
#include "../mlpp/softmax_net/softmax_net_old.h"
#include "../mlpp/softmax_reg/softmax_reg_old.h"
#include "../mlpp/svc/svc_old.h"
#include "../mlpp/tanh_reg/tanh_reg_old.h"
#include "../mlpp/uni_lin_reg/uni_lin_reg_old.h"
#include "../mlpp/wgan/wgan_old.h"
/*
#include "../mlpp/ann/ann_old.h" #include "../mlpp/ann/ann_old.h"
#include "../mlpp/auto_encoder/auto_encoder_old.h"
#include "../mlpp/bernoulli_nb/bernoulli_nb_old.h" #include "../mlpp/bernoulli_nb/bernoulli_nb_old.h"
#include "../mlpp/c_log_log_reg/c_log_log_reg_old.h" #include "../mlpp/c_log_log_reg/c_log_log_reg_old.h"
#include "../mlpp/dual_svc/dual_svc_old.h" #include "../mlpp/dual_svc/dual_svc_old.h"
@ -71,10 +59,19 @@
#include "../mlpp/lin_reg/lin_reg_old.h" #include "../mlpp/lin_reg/lin_reg_old.h"
#include "../mlpp/log_reg/log_reg_old.h" #include "../mlpp/log_reg/log_reg_old.h"
#include "../mlpp/mann/mann_old.h" #include "../mlpp/mann/mann_old.h"
#include "../mlpp/mlp/mlp_old.h"
#include "../mlpp/multi_output_layer/multi_output_layer_old.h" #include "../mlpp/multi_output_layer/multi_output_layer_old.h"
#include "../mlpp/multinomial_nb/multinomial_nb_old.h" #include "../mlpp/multinomial_nb/multinomial_nb_old.h"
#include "../mlpp/outlier_finder/outlier_finder_old.h"
#include "../mlpp/output_layer/output_layer_old.h" #include "../mlpp/output_layer/output_layer_old.h"
*/ #include "../mlpp/pca/pca_old.h"
#include "../mlpp/probit_reg/probit_reg_old.h"
#include "../mlpp/softmax_net/softmax_net_old.h"
#include "../mlpp/softmax_reg/softmax_reg_old.h"
#include "../mlpp/svc/svc_old.h"
#include "../mlpp/tanh_reg/tanh_reg_old.h"
#include "../mlpp/uni_lin_reg/uni_lin_reg_old.h"
#include "../mlpp/wgan/wgan_old.h"
Vector<real_t> dstd_vec_to_vec(const std::vector<real_t> &in) { Vector<real_t> dstd_vec_to_vec(const std::vector<real_t> &in) {
Vector<real_t> r; Vector<real_t> r;
@ -680,8 +677,11 @@ void MLPPTests::test_naive_bayes() {
std::vector<std::vector<real_t>> inputSet = { { 1, 1, 1, 1, 1 }, { 0, 0, 1, 1, 1 }, { 0, 0, 1, 0, 1 } }; std::vector<std::vector<real_t>> inputSet = { { 1, 1, 1, 1, 1 }, { 0, 0, 1, 1, 1 }, { 0, 0, 1, 0, 1 } };
std::vector<real_t> outputSet = { 0, 1, 0, 1, 1 }; std::vector<real_t> outputSet = { 0, 1, 0, 1, 1 };
MLPPMultinomialNBOld MNB_old(alg.transpose(inputSet), outputSet, 2);
alg.printVector(MNB_old.modelSetTest(alg.transpose(inputSet)));
MLPPMultinomialNB MNB(alg.transpose(inputSet), outputSet, 2); MLPPMultinomialNB MNB(alg.transpose(inputSet), outputSet, 2);
alg.printVector(MNB.modelSetTest(alg.transpose(inputSet))); alg.printVector(MNB.model_set_test(alg.transpose(inputSet)));
MLPPBernoulliNB BNB(alg.transpose(inputSet), outputSet); MLPPBernoulliNB BNB(alg.transpose(inputSet), outputSet);
alg.printVector(BNB.modelSetTest(alg.transpose(inputSet))); alg.printVector(BNB.modelSetTest(alg.transpose(inputSet)));