Relintai/pmlpp
1
0
Fork 0
mirror of https://github.com/Relintai/pmlpp.git synced 2025-03-12 22:38:51 +01:00
Code Issues Packages Projects Releases Wiki Activity

Initial cleanup pass on AutoEncoder.

Browse Source
This commit is contained in:
Relintai 2023-02-10 20:48:55 +01:00
parent e6e50025ad
commit 4e30b31833
4 changed files with 235 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

268
mlpp/auto_encoder/auto_encoder.cpp
View File

@ -5,67 +5,95 @@
// //
#include "auto_encoder.h" #include "auto_encoder.h"
#include "../activation/activation.h" #include "../activation/activation.h"
#include "../cost/cost.h" #include "../cost/cost.h"
#include "../lin_alg/lin_alg.h" #include "../lin_alg/lin_alg.h"
#include "../utilities/utilities.h" #include "../utilities/utilities.h"
#include <iostream>
#include <random> #include <random>
std::vector<std::vector<real_t>> MLPPAutoEncoder::modelSetTest(std::vector<std::vector<real_t>> X) { //UDPATE
return Evaluate(X); Ref<MLPPMatrix> MLPPAutoEncoder::get_input_set() {
return Ref<MLPPMatrix>();
//return _input_set;
}
void MLPPAutoEncoder::set_input_set(const Ref<MLPPMatrix> &val) {
//_input_set = val;
_initialized = false;
} }
std::vector<real_t> MLPPAutoEncoder::modelTest(std::vector<real_t> x) { int MLPPAutoEncoder::get_n_hidden() {
return Evaluate(x); return _n_hidden;
}
void MLPPAutoEncoder::set_n_hidden(const int val) {
_n_hidden = val;
_initialized = false;
} }
void MLPPAutoEncoder::gradientDescent(real_t learning_rate, int max_epoch, bool UI) { std::vector<std::vector<real_t>> MLPPAutoEncoder::model_set_test(std::vector<std::vector<real_t>> X) {
ERR_FAIL_COND_V(!_initialized, std::vector<std::vector<real_t>>());
return evaluatem(X);
}
std::vector<real_t> MLPPAutoEncoder::model_test(std::vector<real_t> x) {
ERR_FAIL_COND_V(!_initialized, std::vector<real_t>());
return evaluatev(x);
}
void MLPPAutoEncoder::gradient_descent(real_t learning_rate, int max_epoch, bool ui) {
ERR_FAIL_COND(!_initialized);
MLPPActivation avn; MLPPActivation avn;
MLPPLinAlg alg; MLPPLinAlg alg;
real_t cost_prev = 0; real_t cost_prev = 0;
int epoch = 1; int epoch = 1;
forwardPass();
forward_pass();
while (true) { while (true) {
cost_prev = Cost(y_hat, inputSet); cost_prev = cost(_y_hat, _input_set);
// Calculating the errors // Calculating the errors
std::vector<std::vector<real_t>> error = alg.subtraction(y_hat, inputSet); std::vector<std::vector<real_t>> error = alg.subtraction(_y_hat, _input_set);
// Calculating the weight/bias gradients for layer 2 // Calculating the weight/bias gradients for layer 2
std::vector<std::vector<real_t>> D2_1 = alg.matmult(alg.transpose(a2), error); std::vector<std::vector<real_t>> D2_1 = alg.matmult(alg.transpose(_a2), error);
// weights and bias updation for layer 2 // weights and bias updation for layer 2
weights2 = alg.subtraction(weights2, alg.scalarMultiply(learning_rate / n, D2_1)); _weights2 = alg.subtraction(_weights2, alg.scalarMultiply(learning_rate / _n, D2_1));
// Calculating the bias gradients for layer 2 // Calculating the bias gradients for layer 2
bias2 = alg.subtractMatrixRows(bias2, alg.scalarMultiply(learning_rate, error)); _bias2 = alg.subtractMatrixRows(_bias2, alg.scalarMultiply(learning_rate, error));
//Calculating the weight/bias for layer 1 //Calculating the weight/bias for layer 1
std::vector<std::vector<real_t>> D1_1 = alg.matmult(error, alg.transpose(weights2)); std::vector<std::vector<real_t>> D1_1 = alg.matmult(error, alg.transpose(_weights2));
std::vector<std::vector<real_t>> D1_2 = alg.hadamard_product(D1_1, avn.sigmoid(z2, 1)); std::vector<std::vector<real_t>> D1_2 = alg.hadamard_product(D1_1, avn.sigmoid(_z2, 1));
std::vector<std::vector<real_t>> D1_3 = alg.matmult(alg.transpose(inputSet), D1_2); std::vector<std::vector<real_t>> D1_3 = alg.matmult(alg.transpose(_input_set), D1_2);
// weight an bias updation for layer 1 // weight an bias updation for layer 1
weights1 = alg.subtraction(weights1, alg.scalarMultiply(learning_rate / n, D1_3)); _weights1 = alg.subtraction(_weights1, alg.scalarMultiply(learning_rate / _n, D1_3));
bias1 = alg.subtractMatrixRows(bias1, alg.scalarMultiply(learning_rate / n, D1_2)); _bias1 = alg.subtractMatrixRows(_bias1, alg.scalarMultiply(learning_rate / _n, D1_2));
forwardPass(); forward_pass();
// UI PORTION // UI PORTION
if (UI) { if (ui) {
MLPPUtilities::CostInfo(epoch, cost_prev, Cost(y_hat, inputSet)); MLPPUtilities::CostInfo(epoch, cost_prev, cost(_y_hat, _input_set));
std::cout << "Layer 1:" << std::endl; std::cout << "Layer 1:" << std::endl;
MLPPUtilities::UI(weights1, bias1); MLPPUtilities::UI(_weights1, _bias1);
std::cout << "Layer 2:" << std::endl; std::cout << "Layer 2:" << std::endl;
MLPPUtilities::UI(weights2, bias2); MLPPUtilities::UI(_weights2, _bias2);
} }
epoch++; epoch++;
if (epoch > max_epoch) { if (epoch > max_epoch) {
@ -74,7 +102,9 @@ void MLPPAutoEncoder::gradientDescent(real_t learning_rate, int max_epoch, bool
} }
} }
void MLPPAutoEncoder::SGD(real_t learning_rate, int max_epoch, bool UI) { void MLPPAutoEncoder::sgd(real_t learning_rate, int max_epoch, bool ui) {
ERR_FAIL_COND(!_initialized);
MLPPActivation avn; MLPPActivation avn;
MLPPLinAlg alg; MLPPLinAlg alg;
real_t cost_prev = 0; real_t cost_prev = 0;
@ -83,70 +113,75 @@ void MLPPAutoEncoder::SGD(real_t learning_rate, int max_epoch, bool UI) {
while (true) { while (true) {
std::random_device rd; std::random_device rd;
std::default_random_engine generator(rd()); std::default_random_engine generator(rd());
std::uniform_int_distribution<int> distribution(0, int(n - 1)); std::uniform_int_distribution<int> distribution(0, int(_n - 1));
int outputIndex = distribution(generator); int outputIndex = distribution(generator);
std::vector<real_t> y_hat = Evaluate(inputSet[outputIndex]); std::vector<real_t> y_hat = evaluatev(_input_set[outputIndex]);
auto prop_res = propagate(inputSet[outputIndex]); auto prop_res = propagatev(_input_set[outputIndex]);
auto z2 = std::get<0>(prop_res); auto z2 = std::get<0>(prop_res);
auto a2 = std::get<1>(prop_res); auto a2 = std::get<1>(prop_res);
cost_prev = Cost({ y_hat }, { inputSet[outputIndex] }); cost_prev = cost({ y_hat }, { _input_set[outputIndex] });
std::vector<real_t> error = alg.subtraction(y_hat, inputSet[outputIndex]); std::vector<real_t> error = alg.subtraction(y_hat, _input_set[outputIndex]);
// Weight updation for layer 2 // Weight updation for layer 2
std::vector<std::vector<real_t>> D2_1 = alg.outerProduct(error, a2); std::vector<std::vector<real_t>> D2_1 = alg.outerProduct(error, a2);
weights2 = alg.subtraction(weights2, alg.scalarMultiply(learning_rate, alg.transpose(D2_1))); _weights2 = alg.subtraction(_weights2, alg.scalarMultiply(learning_rate, alg.transpose(D2_1)));
// Bias updation for layer 2 // Bias updation for layer 2
bias2 = alg.subtraction(bias2, alg.scalarMultiply(learning_rate, error)); _bias2 = alg.subtraction(_bias2, alg.scalarMultiply(learning_rate, error));
// Weight updation for layer 1 // Weight updation for layer 1
std::vector<real_t> D1_1 = alg.mat_vec_mult(weights2, error); std::vector<real_t> D1_1 = alg.mat_vec_mult(_weights2, error);
std::vector<real_t> D1_2 = alg.hadamard_product(D1_1, avn.sigmoid(z2, 1)); std::vector<real_t> D1_2 = alg.hadamard_product(D1_1, avn.sigmoid(z2, 1));
std::vector<std::vector<real_t>> D1_3 = alg.outerProduct(inputSet[outputIndex], D1_2); std::vector<std::vector<real_t>> D1_3 = alg.outerProduct(_input_set[outputIndex], D1_2);
weights1 = alg.subtraction(weights1, alg.scalarMultiply(learning_rate, D1_3)); _weights1 = alg.subtraction(_weights1, alg.scalarMultiply(learning_rate, D1_3));
// Bias updation for layer 1 // Bias updation for layer 1
bias1 = alg.subtraction(bias1, alg.scalarMultiply(learning_rate, D1_2)); _bias1 = alg.subtraction(_bias1, alg.scalarMultiply(learning_rate, D1_2));
y_hat = Evaluate(inputSet[outputIndex]); y_hat = evaluatev(_input_set[outputIndex]);
if (UI) {
MLPPUtilities::CostInfo(epoch, cost_prev, Cost({ y_hat }, { inputSet[outputIndex] })); if (ui) {
MLPPUtilities::CostInfo(epoch, cost_prev, cost({ y_hat }, { _input_set[outputIndex] }));
std::cout << "Layer 1:" << std::endl; std::cout << "Layer 1:" << std::endl;
MLPPUtilities::UI(weights1, bias1); MLPPUtilities::UI(_weights1, _bias1);
std::cout << "Layer 2:" << std::endl; std::cout << "Layer 2:" << std::endl;
MLPPUtilities::UI(weights2, bias2); MLPPUtilities::UI(_weights2, _bias2);
} }
epoch++; epoch++;
if (epoch > max_epoch) { if (epoch > max_epoch) {
break; break;
} }
} }
forwardPass();
forward_pass();
} }
void MLPPAutoEncoder::MBGD(real_t learning_rate, int max_epoch, int mini_batch_size, bool UI) { void MLPPAutoEncoder::mbgd(real_t learning_rate, int max_epoch, int mini_batch_size, bool ui) {
ERR_FAIL_COND(!_initialized);
MLPPActivation avn; MLPPActivation avn;
MLPPLinAlg alg; MLPPLinAlg alg;
real_t cost_prev = 0; real_t cost_prev = 0;
int epoch = 1; int epoch = 1;
// Creating the mini-batches // Creating the mini-batches
int n_mini_batch = n / mini_batch_size; int n_mini_batch = _n / mini_batch_size;
std::vector<std::vector<std::vector<real_t>>> inputMiniBatches = MLPPUtilities::createMiniBatches(inputSet, n_mini_batch); std::vector<std::vector<std::vector<real_t>>> inputMiniBatches = MLPPUtilities::createMiniBatches(_input_set, n_mini_batch);
while (true) { while (true) {
for (int i = 0; i < n_mini_batch; i++) { for (int i = 0; i < n_mini_batch; i++) {
std::vector<std::vector<real_t>> y_hat = Evaluate(inputMiniBatches[i]); std::vector<std::vector<real_t>> y_hat = evaluatem(inputMiniBatches[i]);
auto prop_res = propagate(inputMiniBatches[i]); auto prop_res = propagatem(inputMiniBatches[i]);
auto z2 = std::get<0>(prop_res); auto z2 = std::get<0>(prop_res);
auto a2 = std::get<1>(prop_res); auto a2 = std::get<1>(prop_res);
cost_prev = Cost(y_hat, inputMiniBatches[i]); cost_prev = cost(y_hat, inputMiniBatches[i]);
// Calculating the errors // Calculating the errors
std::vector<std::vector<real_t>> error = alg.subtraction(y_hat, inputMiniBatches[i]); std::vector<std::vector<real_t>> error = alg.subtraction(y_hat, inputMiniBatches[i]);
@ -156,109 +191,160 @@ void MLPPAutoEncoder::MBGD(real_t learning_rate, int max_epoch, int mini_batch_s
std::vector<std::vector<real_t>> D2_1 = alg.matmult(alg.transpose(a2), error); std::vector<std::vector<real_t>> D2_1 = alg.matmult(alg.transpose(a2), error);
// weights and bias updation for layer 2 // weights and bias updation for layer 2
weights2 = alg.subtraction(weights2, alg.scalarMultiply(learning_rate / inputMiniBatches[i].size(), D2_1)); _weights2 = alg.subtraction(_weights2, alg.scalarMultiply(learning_rate / inputMiniBatches[i].size(), D2_1));
// Bias Updation for layer 2 // Bias Updation for layer 2
bias2 = alg.subtractMatrixRows(bias2, alg.scalarMultiply(learning_rate, error)); _bias2 = alg.subtractMatrixRows(_bias2, alg.scalarMultiply(learning_rate, error));
//Calculating the weight/bias for layer 1 //Calculating the weight/bias for layer 1
std::vector<std::vector<real_t>> D1_1 = alg.matmult(error, alg.transpose(weights2)); std::vector<std::vector<real_t>> D1_1 = alg.matmult(error, alg.transpose(_weights2));
std::vector<std::vector<real_t>> D1_2 = alg.hadamard_product(D1_1, avn.sigmoid(z2, 1)); std::vector<std::vector<real_t>> D1_2 = alg.hadamard_product(D1_1, avn.sigmoid(z2, true));
std::vector<std::vector<real_t>> D1_3 = alg.matmult(alg.transpose(inputMiniBatches[i]), D1_2); std::vector<std::vector<real_t>> D1_3 = alg.matmult(alg.transpose(inputMiniBatches[i]), D1_2);
// weight an bias updation for layer 1 // weight an bias updation for layer 1
weights1 = alg.subtraction(weights1, alg.scalarMultiply(learning_rate / inputMiniBatches[i].size(), D1_3)); _weights1 = alg.subtraction(_weights1, alg.scalarMultiply(learning_rate / inputMiniBatches[i].size(), D1_3));
bias1 = alg.subtractMatrixRows(bias1, alg.scalarMultiply(learning_rate / inputMiniBatches[i].size(), D1_2)); _bias1 = alg.subtractMatrixRows(_bias1, alg.scalarMultiply(learning_rate / inputMiniBatches[i].size(), D1_2));
y_hat = Evaluate(inputMiniBatches[i]); y_hat = evaluatem(inputMiniBatches[i]);
if (UI) { if (ui) {
MLPPUtilities::CostInfo(epoch, cost_prev, Cost(y_hat, inputMiniBatches[i])); MLPPUtilities::CostInfo(epoch, cost_prev, cost(y_hat, inputMiniBatches[i]));
std::cout << "Layer 1:" << std::endl; std::cout << "Layer 1:" << std::endl;
MLPPUtilities::UI(weights1, bias1); MLPPUtilities::UI(_weights1, _bias1);
std::cout << "Layer 2:" << std::endl; std::cout << "Layer 2:" << std::endl;
MLPPUtilities::UI(weights2, bias2); MLPPUtilities::UI(_weights2, _bias2);
} }
} }
epoch++; epoch++;
if (epoch > max_epoch) { if (epoch > max_epoch) {
break; break;
} }
} }
forwardPass();
forward_pass();
} }
real_t MLPPAutoEncoder::score() { real_t MLPPAutoEncoder::score() {
ERR_FAIL_COND_V(!_initialized, 0);
MLPPUtilities util; MLPPUtilities util;
return util.performance(y_hat, inputSet); return util.performance(_y_hat, _input_set);
} }
void MLPPAutoEncoder::save(std::string fileName) { void MLPPAutoEncoder::save(std::string fileName) {
ERR_FAIL_COND(!_initialized);
MLPPUtilities util; MLPPUtilities util;
util.saveParameters(fileName, weights1, bias1, 0, 1); util.saveParameters(fileName, _weights1, _bias1, false, 1);
util.saveParameters(fileName, weights2, bias2, 1, 2); util.saveParameters(fileName, _weights2, _bias2, true, 2);
} }
MLPPAutoEncoder::MLPPAutoEncoder(std::vector<std::vector<real_t>> pinputSet, int pn_hidden) { MLPPAutoEncoder::MLPPAutoEncoder(std::vector<std::vector<real_t>> p_input_set, int pn_hidden) {
inputSet = pinputSet; _input_set = p_input_set;
n_hidden = pn_hidden; _n_hidden = pn_hidden;
n = inputSet.size(); _n = _input_set.size();
k = inputSet[0].size(); _k = _input_set[0].size();
MLPPActivation avn; MLPPActivation avn;
y_hat.resize(inputSet.size()); _y_hat.resize(_input_set.size());
weights1 = MLPPUtilities::weightInitialization(k, n_hidden); _weights1 = MLPPUtilities::weightInitialization(_k, _n_hidden);
weights2 = MLPPUtilities::weightInitialization(n_hidden, k); _weights2 = MLPPUtilities::weightInitialization(_n_hidden, _k);
bias1 = MLPPUtilities::biasInitialization(n_hidden); _bias1 = MLPPUtilities::biasInitialization(_n_hidden);
bias2 = MLPPUtilities::biasInitialization(k); _bias2 = MLPPUtilities::biasInitialization(_k);
_initialized = true;
} }
real_t MLPPAutoEncoder::Cost(std::vector<std::vector<real_t>> y_hat, std::vector<std::vector<real_t>> y) { MLPPAutoEncoder::MLPPAutoEncoder() {
_initialized = false;
}
MLPPAutoEncoder::~MLPPAutoEncoder() {
}
real_t MLPPAutoEncoder::cost(std::vector<std::vector<real_t>> y_hat, std::vector<std::vector<real_t>> y) {
class MLPPCost cost; class MLPPCost cost;
return cost.MSE(y_hat, inputSet);
return cost.MSE(y_hat, _input_set);
} }
std::vector<std::vector<real_t>> MLPPAutoEncoder::Evaluate(std::vector<std::vector<real_t>> X) { std::vector<real_t> MLPPAutoEncoder::evaluatev(std::vector<real_t> x) {
MLPPLinAlg alg; MLPPLinAlg alg;
MLPPActivation avn; MLPPActivation avn;
std::vector<std::vector<real_t>> z2 = alg.mat_vec_add(alg.matmult(X, weights1), bias1);
std::vector<std::vector<real_t>> a2 = avn.sigmoid(z2); std::vector<real_t> z2 = alg.addition(alg.mat_vec_mult(alg.transpose(_weights1), x), _bias1);
return alg.mat_vec_add(alg.matmult(a2, weights2), bias2); std::vector<real_t> a2 = avn.sigmoid(z2);
return alg.addition(alg.mat_vec_mult(alg.transpose(_weights2), a2), _bias2);
} }
std::tuple<std::vector<std::vector<real_t>>, std::vector<std::vector<real_t>>> MLPPAutoEncoder::propagate(std::vector<std::vector<real_t>> X) { std::tuple<std::vector<real_t>, std::vector<real_t>> MLPPAutoEncoder::propagatev(std::vector<real_t> x) {
MLPPLinAlg alg; MLPPLinAlg alg;
MLPPActivation avn; MLPPActivation avn;
std::vector<std::vector<real_t>> z2 = alg.mat_vec_add(alg.matmult(X, weights1), bias1);
std::vector<std::vector<real_t>> a2 = avn.sigmoid(z2); std::vector<real_t> z2 = alg.addition(alg.mat_vec_mult(alg.transpose(_weights1), x), _bias1);
std::vector<real_t> a2 = avn.sigmoid(z2);
return { z2, a2 }; return { z2, a2 };
} }
std::vector<real_t> MLPPAutoEncoder::Evaluate(std::vector<real_t> x) { std::vector<std::vector<real_t>> MLPPAutoEncoder::evaluatem(std::vector<std::vector<real_t>> X) {
MLPPLinAlg alg; MLPPLinAlg alg;
MLPPActivation avn; MLPPActivation avn;
std::vector<real_t> z2 = alg.addition(alg.mat_vec_mult(alg.transpose(weights1), x), bias1);
std::vector<real_t> a2 = avn.sigmoid(z2); std::vector<std::vector<real_t>> z2 = alg.mat_vec_add(alg.matmult(X, _weights1), _bias1);
return alg.addition(alg.mat_vec_mult(alg.transpose(weights2), a2), bias2); std::vector<std::vector<real_t>> a2 = avn.sigmoid(z2);
return alg.mat_vec_add(alg.matmult(a2, _weights2), _bias2);
} }
std::tuple<std::vector<real_t>, std::vector<real_t>> MLPPAutoEncoder::propagate(std::vector<real_t> x) { std::tuple<std::vector<std::vector<real_t>>, std::vector<std::vector<real_t>>> MLPPAutoEncoder::propagatem(std::vector<std::vector<real_t>> X) {
MLPPLinAlg alg; MLPPLinAlg alg;
MLPPActivation avn; MLPPActivation avn;
std::vector<real_t> z2 = alg.addition(alg.mat_vec_mult(alg.transpose(weights1), x), bias1);
std::vector<real_t> a2 = avn.sigmoid(z2); std::vector<std::vector<real_t>> z2 = alg.mat_vec_add(alg.matmult(X, _weights1), _bias1);
std::vector<std::vector<real_t>> a2 = avn.sigmoid(z2);
return { z2, a2 }; return { z2, a2 };
} }
void MLPPAutoEncoder::forwardPass() { void MLPPAutoEncoder::forward_pass() {
MLPPLinAlg alg; MLPPLinAlg alg;
MLPPActivation avn; MLPPActivation avn;
z2 = alg.mat_vec_add(alg.matmult(inputSet, weights1), bias1);
a2 = avn.sigmoid(z2); _z2 = alg.mat_vec_add(alg.matmult(_input_set, _weights1), _bias1);
y_hat = alg.mat_vec_add(alg.matmult(a2, weights2), bias2); _a2 = avn.sigmoid(_z2);
_y_hat = alg.mat_vec_add(alg.matmult(_a2, _weights2), _bias2);
}
void MLPPAutoEncoder::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_input_set"), &MLPPAutoEncoder::get_input_set);
ClassDB::bind_method(D_METHOD("set_input_set", "val"), &MLPPAutoEncoder::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_n_hidden"), &MLPPAutoEncoder::get_n_hidden);
ClassDB::bind_method(D_METHOD("set_n_hidden", "val"), &MLPPAutoEncoder::set_n_hidden);
ADD_PROPERTY(PropertyInfo(Variant::INT, "n_hidden"), "set_n_hidden", "get_n_hidden");
/*
ClassDB::bind_method(D_METHOD("model_set_test", "X"), &MLPPAutoEncoder::model_set_test);
ClassDB::bind_method(D_METHOD("model_test", "x"), &MLPPAutoEncoder::model_test);
ClassDB::bind_method(D_METHOD("gradient_descent", "learning_rate", "max_epoch", "ui"), &MLPPAutoEncoder::gradient_descent, false);
ClassDB::bind_method(D_METHOD("sgd", "learning_rate", "max_epoch", "ui"), &MLPPAutoEncoder::sgd, false);
ClassDB::bind_method(D_METHOD("mbgd", "learning_rate", "max_epoch", "mini_batch_size", "ui"), &MLPPAutoEncoder::mbgd, false);
ClassDB::bind_method(D_METHOD("score"), &MLPPAutoEncoder::score);
ClassDB::bind_method(D_METHOD("save", "file_name"), &MLPPAutoEncoder::save);
ClassDB::bind_method(D_METHOD("is_initialized"), &MLPPAutoEncoder::is_initialized);
ClassDB::bind_method(D_METHOD("initialize"), &MLPPAutoEncoder::initialize);
*/
} }

77
mlpp/auto_encoder/auto_encoder.h
View File

@ -10,18 +10,34 @@
#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 "../regularization/reg.h"
//REMOVE
#include <iostream>
#include <string> #include <string>
#include <tuple>
#include <vector> #include <vector>
class MLPPAutoEncoder { class MLPPAutoEncoder : public Reference {
public: GDCLASS(MLPPAutoEncoder, Reference);
std::vector<std::vector<real_t>> modelSetTest(std::vector<std::vector<real_t>> X);
std::vector<real_t> modelTest(std::vector<real_t> x);
void gradientDescent(real_t learning_rate, int max_epoch, bool UI = false); public:
void SGD(real_t learning_rate, int max_epoch, bool UI = false); Ref<MLPPMatrix> get_input_set();
void MBGD(real_t learning_rate, int max_epoch, int mini_batch_size, bool UI = false); void set_input_set(const Ref<MLPPMatrix> &val);
int get_n_hidden();
void set_n_hidden(const int val);
std::vector<std::vector<real_t>> model_set_test(std::vector<std::vector<real_t>> X);
std::vector<real_t> model_test(std::vector<real_t> x);
void gradient_descent(real_t learning_rate, int max_epoch, bool ui = false);
void sgd(real_t learning_rate, int max_epoch, bool ui = false);
void mbgd(real_t learning_rate, int max_epoch, int mini_batch_size, bool ui = false);
real_t score(); real_t score();
@ -29,30 +45,39 @@ public:
MLPPAutoEncoder(std::vector<std::vector<real_t>> inputSet, int n_hidden); MLPPAutoEncoder(std::vector<std::vector<real_t>> inputSet, int n_hidden);
private: MLPPAutoEncoder();
real_t Cost(std::vector<std::vector<real_t>> y_hat, std::vector<std::vector<real_t>> y); ~MLPPAutoEncoder();
std::vector<std::vector<real_t>> Evaluate(std::vector<std::vector<real_t>> X); protected:
std::tuple<std::vector<std::vector<real_t>>, std::vector<std::vector<real_t>>> propagate(std::vector<std::vector<real_t>> X); real_t cost(std::vector<std::vector<real_t>> y_hat, std::vector<std::vector<real_t>> y);
std::vector<real_t> Evaluate(std::vector<real_t> x);
std::tuple<std::vector<real_t>, std::vector<real_t>> propagate(std::vector<real_t> x);
void forwardPass();
std::vector<std::vector<real_t>> inputSet; std::vector<real_t> evaluatev(std::vector<real_t> x);
std::vector<std::vector<real_t>> y_hat; std::tuple<std::vector<real_t>, std::vector<real_t>> propagatev(std::vector<real_t> x);
std::vector<std::vector<real_t>> weights1; std::vector<std::vector<real_t>> evaluatem(std::vector<std::vector<real_t>> X);
std::vector<std::vector<real_t>> weights2; std::tuple<std::vector<std::vector<real_t>>, std::vector<std::vector<real_t>>> propagatem(std::vector<std::vector<real_t>> X);
std::vector<real_t> bias1; void forward_pass();
std::vector<real_t> bias2;
std::vector<std::vector<real_t>> z2; static void _bind_methods();
std::vector<std::vector<real_t>> a2;
int n; std::vector<std::vector<real_t>> _input_set;
int k; std::vector<std::vector<real_t>> _y_hat;
int n_hidden;
std::vector<std::vector<real_t>> _weights1;
std::vector<std::vector<real_t>> _weights2;
std::vector<real_t> _bias1;
std::vector<real_t> _bias2;
std::vector<std::vector<real_t>> _z2;
std::vector<std::vector<real_t>> _a2;
int _n;
int _k;
int _n_hidden;
bool _initialized;
}; };
#endif /* AutoEncoder_hpp */ #endif /* AutoEncoder_hpp */

2
register_types.cpp
View File

@ -45,6 +45,7 @@ SOFTWARE.
#include "mlpp/probit_reg/probit_reg.h" #include "mlpp/probit_reg/probit_reg.h"
#include "mlpp/svc/svc.h" #include "mlpp/svc/svc.h"
#include "mlpp/softmax_reg/softmax_reg.h" #include "mlpp/softmax_reg/softmax_reg.h"
#include "mlpp/auto_encoder/auto_encoder.h"
#include "mlpp/mlp/mlp.h" #include "mlpp/mlp/mlp.h"
@ -75,6 +76,7 @@ void register_pmlpp_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<MLPPProbitReg>(); ClassDB::register_class<MLPPProbitReg>();
ClassDB::register_class<MLPPSVC>(); ClassDB::register_class<MLPPSVC>();
ClassDB::register_class<MLPPSoftmaxReg>(); ClassDB::register_class<MLPPSoftmaxReg>();
ClassDB::register_class<MLPPAutoEncoder>();
ClassDB::register_class<MLPPDataESimple>(); ClassDB::register_class<MLPPDataESimple>();
ClassDB::register_class<MLPPDataSimple>(); ClassDB::register_class<MLPPDataSimple>();

5
test/mlpp_tests.cpp
View File

@ -503,6 +503,11 @@ void MLPPTests::test_autoencoder(bool ui) {
model_old.SGD(0.001, 300000, ui); model_old.SGD(0.001, 300000, ui);
alg.printMatrix(model_old.modelSetTest(alg.transpose(inputSet))); alg.printMatrix(model_old.modelSetTest(alg.transpose(inputSet)));
std::cout << "ACCURACY (Old): " << 100 * model_old.score() << "%" << std::endl; std::cout << "ACCURACY (Old): " << 100 * model_old.score() << "%" << std::endl;
MLPPAutoEncoder model(alg.transpose(inputSet), 5);
model.sgd(0.001, 300000, ui);
alg.printMatrix(model.model_set_test(alg.transpose(inputSet)));
std::cout << "ACCURACY: " << 100 * model.score() << "%" << std::endl;
} }
void MLPPTests::test_dynamically_sized_ann(bool ui) { void MLPPTests::test_dynamically_sized_ann(bool ui) {
MLPPLinAlg alg; MLPPLinAlg alg;