#include
#include
#include "utils.h"
#include "HiddenLayer.h"
#include "dA.h"
#include "LogisticRegression.h"
#include "SdA.h"
using namespace std;
using namespace utils;
// SdA
SdA::SdA(int size, int n_i, int *hls, int n_o, int n_l) {
int input_size;
N = size;
n_ins = n_i;
hidden_layer_sizes = hls;
n_outs = n_o;
n_layers = n_l;
sigmoid_layers = new HiddenLayer*[n_layers];
dA_layers = new dA*[n_layers];
// construct multi-layer
for(int i=0; iW, sigmoid_layers[i]->b, NULL);
}
// layer for output using LogisticRegression
log_layer = new LogisticRegression(N, hidden_layer_sizes[n_layers-1], n_outs);
}
SdA::~SdA() {
delete log_layer;
for(int i=0; isample_h_given_v(prev_layer_input, layer_input);
delete[] prev_layer_input;
}
}
dA_layers[i]->train(layer_input, lr, corruption_level);
}
}
}
delete[] train_X;
delete[] layer_input;
}
void SdA::finetune(int *input, int *label, double lr, int epochs) {
int *layer_input;
int prev_layer_input_size;
int *prev_layer_input;
int *train_X = new int[n_ins];
int *train_Y = new int[n_outs];
for(int epoch=0; epochsample_h_given_v(prev_layer_input, layer_input);
delete[] prev_layer_input;
}
log_layer->train(layer_input, train_Y, lr);
}
// lr *= 0.95;
}
delete[] layer_input;
delete[] train_X;
delete[] train_Y;
}
void SdA::predict(int *x, double *y) {
double *layer_input;
int prev_layer_input_size;
double *prev_layer_input;
double linear_output;
prev_layer_input = new double[n_ins];
for(int j=0; jn_out];
for(int k=0; kn_out; k++) {
linear_output = 0.0;
for(int j=0; jn_in; j++) {
linear_output += sigmoid_layers[i]->W[k][j] * prev_layer_input[j];
}
linear_output += sigmoid_layers[i]->b[k];
layer_input[k] = sigmoid(linear_output);
}
delete[] prev_layer_input;
if(i < n_layers-1) {
prev_layer_input = new double[sigmoid_layers[i]->n_out];
for(int j=0; jn_out; j++) prev_layer_input[j] = layer_input[j];
delete[] layer_input;
}
}
for(int i=0; in_out; i++) {
y[i] = 0;
for(int j=0; jn_in; j++) {
y[i] += log_layer->W[i][j] * layer_input[j];
}
y[i] += log_layer->b[i];
}
log_layer->softmax(y);
delete[] layer_input;
}
// HiddenLayer
HiddenLayer::HiddenLayer(int size, int in, int out, double **w, double *bp) {
N = size;
n_in = in;
n_out = out;
if(w == NULL) {
W = new double*[n_out];
for(int i=0; i