diff --git a/mlpp/multinomial_nb/multinomial_nb.cpp b/mlpp/multinomial_nb/multinomial_nb.cpp index 9fb9c31..48d41e0 100644 --- a/mlpp/multinomial_nb/multinomial_nb.cpp +++ b/mlpp/multinomial_nb/multinomial_nb.cpp @@ -12,101 +12,162 @@ #include #include -MLPPMultinomialNB::MLPPMultinomialNB(std::vector> pinputSet, std::vector poutputSet, int pclass_num) { - inputSet = pinputSet; - outputSet = poutputSet; - class_num = pclass_num; +/* +Ref MLPPMultinomialNB::get_input_set() { + return _input_set; +} +void MLPPMultinomialNB::set_input_set(const Ref &val) { + _input_set = val; - y_hat.resize(outputSet.size()); - Evaluate(); + _initialized = false; } -std::vector MLPPMultinomialNB::modelSetTest(std::vector> X) { +Ref MLPPMultinomialNB::get_output_set() { + return _output_set; +} +void MLPPMultinomialNB::set_output_set(const Ref &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 MLPPMultinomialNB::model_set_test(std::vector> X) { + ERR_FAIL_COND_V(!_initialized, std::vector()); + std::vector y_hat; 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; } -real_t MLPPMultinomialNB::modelTest(std::vector x) { - real_t score[class_num]; - computeTheta(); +real_t MLPPMultinomialNB::model_test(std::vector x) { + ERR_FAIL_COND_V(!_initialized, 0); + + real_t score[_class_num]; + + compute_theta(); for (uint32_t j = 0; j < x.size(); j++) { - for (uint32_t k = 0; k < vocab.size(); k++) { - if (x[j] == vocab[k]) { - for (int p = class_num - 1; p >= 0; p--) { - score[p] += std::log(theta[p][vocab[k]]); + for (uint32_t k = 0; k < _vocab.size(); k++) { + if (x[j] == _vocab[k]) { + for (int p = _class_num - 1; p >= 0; p--) { + score[p] += std::log(_theta[p][_vocab[k]]); } } } } - for (uint32_t i = 0; i < priors.size(); i++) { - score[i] += std::log(priors[i]); + for (uint32_t i = 0; i < _priors.size(); i++) { + score[i] += std::log(_priors[i]); } return std::distance(score, std::max_element(score, score + sizeof(score) / sizeof(real_t))); } real_t MLPPMultinomialNB::score() { + ERR_FAIL_COND_V(!_initialized, 0); + 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> p_input_set, std::vector 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. - theta.resize(class_num); + _theta.resize(_class_num); // Setting all values in the hasmap by default to 0. - for (int i = class_num - 1; i >= 0; i--) { - for (uint32_t j = 0; j < vocab.size(); j++) { - theta[i][vocab[j]] = 0; + for (int i = _class_num - 1; i >= 0; i--) { + for (uint32_t j = 0; j < _vocab.size(); j++) { + _theta[i][_vocab[j]] = 0; } } - for (uint32_t i = 0; i < inputSet.size(); i++) { - for (uint32_t j = 0; j < inputSet[0].size(); j++) { - theta[outputSet[i]][inputSet[i][j]]++; + for (uint32_t i = 0; i < _input_set.size(); i++) { + for (uint32_t j = 0; j < _input_set[0].size(); j++) { + _theta[_output_set[i]][_input_set[i][j]]++; } } - for (uint32_t i = 0; i < theta.size(); i++) { - for (uint32_t j = 0; j < theta[i].size(); j++) { - theta[i][j] /= priors[i] * y_hat.size(); + for (uint32_t i = 0; i < _theta.size(); i++) { + for (uint32_t j = 0; j < _theta[i].size(); j++) { + _theta[i][j] /= _priors[i] * _y_hat.size(); } } } -void MLPPMultinomialNB::Evaluate() { +void MLPPMultinomialNB::evaluate() { 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) - real_t score[class_num]; + real_t score[_class_num]; // Easy computation of priors, i.e. Pr(C_k) - priors.resize(class_num); - for (uint32_t ii = 0; ii < outputSet.size(); ii++) { - priors[int(outputSet[ii])]++; + _priors.resize(_class_num); + for (uint32_t ii = 0; ii < _output_set.size(); 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... - computeTheta(); + compute_theta(); - for (uint32_t j = 0; j < inputSet.size(); j++) { - for (uint32_t k = 0; k < vocab.size(); k++) { - if (inputSet[i][j] == vocab[k]) { - for (int p = class_num - 1; p >= 0; p--) { - score[p] += std::log(theta[i][vocab[k]]); + for (uint32_t j = 0; j < _input_set.size(); j++) { + for (uint32_t k = 0; k < _vocab.size(); k++) { + if (_input_set[i][j] == _vocab[k]) { + for (int p = _class_num - 1; p >= 0; p--) { + score[p] += std::log(_theta[i][_vocab[k]]); } } } } - for (uint32_t ii = 0; ii < priors.size(); ii++) { - score[ii] += std::log(priors[ii]); + for (uint32_t ii = 0; ii < _priors.size(); ii++) { + score[ii] += std::log(_priors[ii]); score[ii] = exp(score[ii]); } @@ -115,6 +176,36 @@ void MLPPMultinomialNB::Evaluate() { } // 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); + */ +} diff --git a/mlpp/multinomial_nb/multinomial_nb.h b/mlpp/multinomial_nb/multinomial_nb.h index 6ab3223..8b968cd 100644 --- a/mlpp/multinomial_nb/multinomial_nb.h +++ b/mlpp/multinomial_nb/multinomial_nb.h @@ -10,31 +10,59 @@ #include "core/math/math_defs.h" +#include "core/object/reference.h" + +#include "../lin_alg/mlpp_matrix.h" +#include "../lin_alg/mlpp_vector.h" + #include #include -class MLPPMultinomialNB { +class MLPPMultinomialNB : public Reference { + GDCLASS(MLPPMultinomialNB, Reference); + public: - MLPPMultinomialNB(std::vector> inputSet, std::vector outputSet, int class_num); - std::vector modelSetTest(std::vector> X); - real_t modelTest(std::vector x); + Ref get_input_set(); + void set_input_set(const Ref &val); + + Ref get_output_set(); + void set_output_set(const Ref &val); + + real_t get_class_num(); + void set_class_num(const real_t val); + + std::vector model_set_test(std::vector> X); + real_t model_test(std::vector x); + real_t score(); -private: - void computeTheta(); - void Evaluate(); + bool is_initialized(); + void initialize(); + + MLPPMultinomialNB(std::vector> _input_set, std::vector _output_set, int class_num); + + MLPPMultinomialNB(); + ~MLPPMultinomialNB(); + +protected: + void compute_theta(); + void evaluate(); + + static void _bind_methods(); // Model Params - std::vector priors; + std::vector _priors; - std::vector> theta; - std::vector vocab; - int class_num; + std::vector> _theta; + std::vector _vocab; + int _class_num; // Datasets - std::vector> inputSet; - std::vector outputSet; - std::vector y_hat; + std::vector> _input_set; + std::vector _output_set; + std::vector _y_hat; + + bool _initialized; }; #endif /* MultinomialNB_hpp */ diff --git a/mlpp/output_layer/output_layer.h b/mlpp/output_layer/output_layer.h index b4ba219..637699c 100644 --- a/mlpp/output_layer/output_layer.h +++ b/mlpp/output_layer/output_layer.h @@ -20,6 +20,7 @@ #include "../lin_alg/mlpp_matrix.h" #include "../lin_alg/mlpp_vector.h" + class MLPPOutputLayer : public Reference { GDCLASS(MLPPOutputLayer, Reference); diff --git a/test/mlpp_tests.cpp b/test/mlpp_tests.cpp index 4079a61..cadf406 100644 --- a/test/mlpp_tests.cpp +++ b/test/mlpp_tests.cpp @@ -47,20 +47,8 @@ #include "../mlpp/uni_lin_reg/uni_lin_reg.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/auto_encoder/auto_encoder_old.h" #include "../mlpp/bernoulli_nb/bernoulli_nb_old.h" #include "../mlpp/c_log_log_reg/c_log_log_reg_old.h" #include "../mlpp/dual_svc/dual_svc_old.h" @@ -71,10 +59,19 @@ #include "../mlpp/lin_reg/lin_reg_old.h" #include "../mlpp/log_reg/log_reg_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/multinomial_nb/multinomial_nb_old.h" +#include "../mlpp/outlier_finder/outlier_finder_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 dstd_vec_to_vec(const std::vector &in) { Vector r; @@ -680,8 +677,11 @@ void MLPPTests::test_naive_bayes() { std::vector> inputSet = { { 1, 1, 1, 1, 1 }, { 0, 0, 1, 1, 1 }, { 0, 0, 1, 0, 1 } }; std::vector 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); - alg.printVector(MNB.modelSetTest(alg.transpose(inputSet))); + alg.printVector(MNB.model_set_test(alg.transpose(inputSet))); MLPPBernoulliNB BNB(alg.transpose(inputSet), outputSet); alg.printVector(BNB.modelSetTest(alg.transpose(inputSet)));