/*
Experimento usando 7 grupos para treino, 1 grupo para validacao e teste. Este ultimo eh dividido
em dois grupos, um com (n - 1) individuos para validacao e (1) individuo para teste.
*/
void train(){
string solver = dataPath + "solver.prototxt";
string resultsPath = dataPath + "results/";
for(int grupoTeste = 1; grupoTeste <= qtdeGrupos; grupoTeste++){
TrainData dadosTreino;
dadosTreino.testSet = grupoTeste;
//Garante que so vai separar em treino e teste, nao vai ter validacao
dadosTreino.validationSet = 99;
readTrainData(&dadosTreino);
for(int individuo = 1; individuo <= dadosTreino.IndividuosTeste.size(); individuo++){
double bstValidationAccuracy = 0, mediaNormal = 0, mediaBinario = 0;
vector<Mat> imagensValidacao, imagensTeste;
vector<int> labelsValidacao, labelsTeste;
separarIndividuo(dadosTreino.testSamples, dadosTreino.testLabels,
individuo - 1, imagensValidacao,
labelsValidacao, imagensTeste,
labelsTeste, dadosTreino.IndividuosTeste);
//Embaralha e trunca os dados de validacao
shuffleVectors(imagensValidacao, labelsValidacao);
while(imagensValidacao.size() % 55 != 0){
imagensValidacao.erase(imagensValidacao.begin());
labelsValidacao.erase(labelsValidacao.begin());
}
for(int iter = 1; iter <= qtdeIteracoes; iter++){
shuffleVectors(dadosTreino.trainSamples, dadosTreino.trainLabels);
trainNet(solver, dadosTreino.trainSamples, dadosTreino.trainLabels, imagensValidacao, labelsValidacao);
executarTeste(resultsPath, grupoTeste, grupoTeste, iter, imagensTeste, labelsTeste, individuo);
}
}
}
}
void Net::testNet(NetParam& param) {
shared_ptr<Blob> X_batch(new Blob(X_train_->subBlob(0, 1)));
shared_ptr<Blob> Y_batch(new Blob(Y_train_->subBlob(0, 1)));
trainNet(X_batch, Y_batch, param);
cout << "BEGIN TEST LAYERS" << endl;
for (int i = 0; i < (int)layers_.size(); ++i) {
testLayer(param, i);
printf("\n");
}
}
int main(int argc, char **argv)
{
double *netout = malloc(sizeof(double) * NUM_O); // what the network thinks
double *hidout = malloc(sizeof(double) * NUM_H); // results from hidden layer
sumsh = malloc(sizeof(double) * NUM_H); // weighted summations for hidden layer
sumso = malloc(sizeof(double) * NUM_O); // weighted summations for output layer
srand(time(NULL)*getpid());
/* initialize the weights; small, random values */
wih = initWeights(NUM_I, NUM_H); // weights between input and hidden layer
who = initWeights(NUM_H, NUM_O); // weights between hidden and output layer
/* train this thing. */
printf("%s\n", trainNet(netout, hidout) ? "Epoch limit exceeded!" : "Neural network trained and ready to go.");
free(sumsh); free(sumso); free(wih); free(who);
return 0;
}
void Net::train(NetParam& param) {
// to be delete
int N = X_train_->get_N();
int iter_per_epochs;
if (param.use_batch) {
iter_per_epochs = N / param.batch_size;
}
else {
iter_per_epochs = N;
}
int num_iters = iter_per_epochs * param.num_epochs;
int epoch = 0;
// iteration
for (int iter = 0; iter < num_iters; ++iter) {
// batch
shared_ptr<Blob> X_batch;
shared_ptr<Blob> Y_batch;
if (param.use_batch) {
// deep copy
X_batch.reset(new Blob(X_train_->subBlob((iter * param.batch_size) % N,
((iter+1) * param.batch_size) % N)));
Y_batch.reset(new Blob(Y_train_->subBlob((iter * param.batch_size) % N,
((iter+1) * param.batch_size) % N)));
}
else {
shared_ptr<Blob> X_batch = X_train_;
shared_ptr<Blob> Y_batch = Y_train_;
}
// train
trainNet(X_batch, Y_batch, param);
// update
for (int i = 0; i < (int)layers_.size(); ++i) {
std::string lname = layers_[i];
if (!data_[lname][1] || !data_[lname][2]) {
continue;
}
for (int j = 1; j <= 2; ++j) {
assert(param.update == "momentum" ||
param.update == "rmsprop" ||
param.update == "adagrad" ||
param.update == "sgd");
shared_ptr<Blob> dx(new Blob(data_[lname][j]->size()));
if (param.update == "sgd") {
*dx = -param.lr * (*grads_[lname][j]);
}
if (param.update == "momentum") {
if (!step_cache_[lname][j]) {
step_cache_[lname][j].reset(new Blob(data_[lname][j]->size(), TZEROS));
}
Blob ll = param.momentum * (*step_cache_[lname][j]);
Blob rr = param.lr * (*grads_[lname][j]);
*dx = ll - rr;
step_cache_[lname][j] = dx;
}
if (param.update == "rmsprop") {
// change it self
double decay_rate = 0.99;
if (!step_cache_[lname][j]) {
step_cache_[lname][j].reset(new Blob(data_[lname][j]->size(), TZEROS));
}
Blob r1 = decay_rate * (*step_cache_[lname][j]);
Blob r2 = (1 - decay_rate) * (*grads_[lname][j]);
Blob r3 = r2 * (*grads_[lname][j]);
*step_cache_[lname][j] = r1 + r3;
Blob d1 = (*step_cache_[lname][j]) + 1e-8;
Blob u1 = param.lr * (*grads_[lname][j]);
Blob d2 = mini_net::sqrt(d1);
Blob r4 = u1 / d2;
*dx = 0 - r4;
}
if (param.update == "adagrad") {
if (!step_cache_[lname][j]) {
step_cache_[lname][j].reset(new Blob(data_[lname][j]->size(), TZEROS));
}
*step_cache_[lname][j] = (*grads_[lname][j]) * (*grads_[lname][j]);
Blob d1 = (*step_cache_[lname][j]) + 1e-8;
Blob u1 = param.lr * (*grads_[lname][j]);
Blob d2 = mini_net::sqrt(d1);
Blob r4 = u1 / d2;
*dx = 0 - r4;
}
*data_[lname][j] = (*data_[lname][j]) + (*dx);
}
}
// evaluate
bool first_it = (iter == 0);
bool epoch_end = (iter + 1) % iter_per_epochs == 0;
bool acc_check = (param.acc_frequence && (iter+1) % param.acc_frequence == 0);
if (first_it || epoch_end || acc_check) {
// update learning rate[TODO]
if ((iter > 0 && epoch_end) || param.acc_update_lr) {
param.lr *= param.lr_decay;
if (epoch_end) {
epoch++;
}
}
// evaluate train set accuracy
shared_ptr<Blob> X_train_subset;
shared_ptr<Blob> Y_train_subset;
if (N > 1000) {
X_train_subset.reset(new Blob(X_train_->subBlob(0, 100)));
Y_train_subset.reset(new Blob(Y_train_->subBlob(0, 100)));
}
else {
X_train_subset = X_train_;
Y_train_subset = Y_train_;
}
trainNet(X_train_subset, Y_train_subset, param, "forward");
double train_acc = prob(*data_[layers_.back()][1], *data_[layers_.back()][0]);
train_acc_history_.push_back(train_acc);
// evaluate val set accuracy[TODO: change train to val]
trainNet(X_val_, Y_val_, param, "forward");
double val_acc = prob(*data_[layers_.back()][1], *data_[layers_.back()][0]);
val_acc_history_.push_back(val_acc);
// print
printf("iter: %d loss: %f train_acc: %0.2f%% val_acc: %0.2f%% lr: %0.6f\n",
iter, loss_, train_acc*100, val_acc*100, param.lr);
// save best model[TODO]
//if (val_acc_history_.size() > 1 && val_acc < val_acc_history_[val_acc_history_.size()-2]) {
// for (auto i : layers_) {
// if (!data_[i][1] || !data_[i][2]) {
// continue;
// }
// best_model_[i][1] = data_[i][1];
// best_model_[i][2] = data_[i][2];
// }
//}
}
}
return;
}
int main() {
double inputs[MAX_NO_OF_INPUTS];
double outputTargets[MAX_NO_OF_OUTPUTS];
/* determine layer paramaters */
int noOfLayers = 2; // input layer excluded
int noOfNeurons[] = {10,1};
int noOfInputs[] = {2,10};
char axonFamilies[] = {'g','l'};
double actFuncFlatnesses[] = {1,1,1};
createNet(noOfLayers, noOfNeurons, noOfInputs, axonFamilies, actFuncFlatnesses, 1);
/* train it using batch method */
int i;
double tempTotal1, tempTotal2;
int counter = 0;
for(i = 0; i < TRAINING_ITERATION; i++) {
inputs[0] = getRand();
inputs[1] = getRand();
inputs[2] = getRand();
inputs[3] = getRand();
tempTotal1 = inputs[0] + inputs[1];
tempTotal2 = inputs[2] - inputs[3];
// tempTotal = inputs[0] + inputs[1];
feedNetInputs(inputs);
updateNetOutput();
// outputTargets[0] = sin(tempTotal1)*2+0.5*exp(tempTotal2)-cos(inputs[1]+inputs[3])/2;
outputTargets[0] = sin(tempTotal1)*2+0.5*exp(tempTotal2);
// outputTargets[1] = (double)cos(tempTotal);
/* train using batch training ( don't update weights, just cumulate them ) */
//trainNet(0, 0, 1, outputTargets);
trainNet(0, 0, 1, outputTargets);
counter++;
/* apply batch changes after 100 loops use .8 learning rate and .8 momentum */
if(counter == 100) { applyBatchCumulations(.3,.3); counter = 0;} //!~~~swd: should be within (0,1)
}
/* test it */
double *outputs;
double target_out[50];
double actual_out[50];
printf("Sin Target \t Output \n");
printf("---------- \t -------- \t ---------- \t --------\n");
for(i = 0; i < 50; i++) {
inputs[0] = getRand();
inputs[1] = getRand();
inputs[2] = getRand();
inputs[3] = getRand();
tempTotal1 = inputs[0] + inputs[1];
tempTotal2 = inputs[2] - inputs[3];
target_out[i] = sin(tempTotal1)*2+0.5*exp(tempTotal2);
// target_out[i] = sin(tempTotal1)*2+0.5*exp(tempTotal2)-cos(inputs[1]+inputs[3])/2;
feedNetInputs(inputs);
updateNetOutput();
outputs = getOutputs();
actual_out[i] = outputs[0];
printf( "%f \t %f \n", target_out[i], actual_out[i]);
}
float Rsquared_ans=Rsquared(target_out, actual_out, 50);
printf("Result Summary: \n");
printf("The Rsquared Value is : %f \n", Rsquared_ans);
printf("finish!!!\n");
//getch();
return 0;
}
