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 <random>
MLPPMultinomialNB::MLPPMultinomialNB(std::vector<std::vector<real_t>> pinputSet, std::vector<real_t> poutputSet, int pclass_num) {
inputSet = pinputSet;
outputSet = poutputSet;
class_num = pclass_num;
/*
Ref<MLPPMatrix> MLPPMultinomialNB::get_input_set() {
return _input_set;
}
void MLPPMultinomialNB::set_input_set(const Ref<MLPPMatrix> &val) {
_input_set = val;
y_hat.resize(outputSet.size());
Evaluate();
_initialized = false;
}
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;
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<real_t> x) {
real_t score[class_num];
computeTheta();
real_t MLPPMultinomialNB::model_test(std::vector<real_t> 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<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.
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);
*/
}

56
mlpp/multinomial_nb/multinomial_nb.h
View File

@ -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 <map>
#include <vector>
class MLPPMultinomialNB {
class MLPPMultinomialNB : public Reference {
GDCLASS(MLPPMultinomialNB, Reference);
public:
MLPPMultinomialNB(std::vector<std::vector<real_t>> inputSet, std::vector<real_t> outputSet, int class_num);
std::vector<real_t> modelSetTest(std::vector<std::vector<real_t>> X);
real_t modelTest(std::vector<real_t> x);
Ref<MLPPMatrix> get_input_set();
void set_input_set(const Ref<MLPPMatrix> &val);
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();
private:
void computeTheta();
void Evaluate();
bool is_initialized();
void initialize();
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
std::vector<real_t> priors;
std::vector<real_t> _priors;
std::vector<std::map<real_t, int>> theta;
std::vector<real_t> vocab;
int class_num;
std::vector<std::map<real_t, int>> _theta;
std::vector<real_t> _vocab;
int _class_num;
// Datasets
std::vector<std::vector<real_t>> inputSet;
std::vector<real_t> outputSet;
std::vector<real_t> y_hat;
std::vector<std::vector<real_t>> _input_set;
std::vector<real_t> _output_set;
std::vector<real_t> _y_hat;
bool _initialized;
};
#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_vector.h"
class MLPPOutputLayer : public 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/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<real_t> dstd_vec_to_vec(const std::vector<real_t> &in) {
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<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);
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)));