int
main(int argc, char **argv)
{
const unsigned int num_input = 360;
const unsigned int num_output = 1;
const unsigned int num_layers = 4;
const unsigned int num_neurons_hidden = num_input / 2;
const float desired_error = (const float) 0.001;
const unsigned int max_epochs = 300;
const unsigned int epochs_between_reports = 10;
struct fann_train_data * data = NULL;
struct fann *ann = fann_create_standard(num_layers, num_input, num_neurons_hidden, num_neurons_hidden / 2, num_output);
unsigned int i, j;
if (argc != 2)
{
fprintf(stderr, "Use: %s arquivoTreino\n", argv[0]);
exit(1);
}
fann_set_activation_function_hidden(ann, FANN_ELLIOT);
fann_set_activation_function_output(ann, FANN_LINEAR);
fann_set_training_algorithm(ann, FANN_TRAIN_RPROP);
fann_set_learning_rate(ann, 0.1);
fann_set_learning_momentum(ann, 0.6);
data = fann_read_train_from_file(argv[1]);
fann_train_on_data(ann, data, max_epochs, epochs_between_reports, desired_error);
free(data);
fann_save(ann, ARQ_RNA);
fann_destroy(ann);
return 0;
}
int main()
{
const unsigned int num_layers = 3;
const unsigned int num_neurons_hidden = 96;
const float desired_error = (const float) 0.001;
struct fann *ann;
struct fann_train_data *train_data, *test_data;
float momentum;
train_data = fann_read_train_from_file("../benchmarks/datasets/robot.train");
test_data = fann_read_train_from_file("../benchmarks/datasets/robot.test");
for ( momentum = 0.0; momentum < 0.7; momentum += 0.1 )
{
printf("============= momentum = %f =============\n", momentum);
ann = fann_create_standard(num_layers,
train_data->num_input, num_neurons_hidden, train_data->num_output);
fann_set_training_algorithm(ann, FANN_TRAIN_INCREMENTAL);
fann_set_learning_momentum(ann, momentum);
fann_train_on_data(ann, train_data, 2000, 500, desired_error);
printf("MSE error on train data: %f\n", fann_test_data(ann, train_data));
printf("MSE error on test data : %f\n", fann_test_data(ann, test_data));
fann_destroy(ann);
}
fann_destroy_train(train_data);
fann_destroy_train(test_data);
return 0;
}
void Trainer::set_learning_momentum(float learning_momentum) {
std::cerr << "Set learning mementum to " << learning_momentum << std::endl;
return fann_set_learning_momentum(ann_, learning_momentum);
}
int main(int argc, char *argv[])
{
struct fann_train_data *dadosTreino, *dadosTeste;
struct fann *ANN;
fann_type *ANN_Answers;
int *layers, i, j, aux;
chromosome chromo;
float erro = 0.0;
checkArgs(argc, argv);
buildChromosome(argv, &chromo);
checkDatasetFiles();
dadosTreino = fann_read_train_from_file(nomeArqTreino);
layers = (int *) calloc(2+chromo.qntCamadasOcultas, sizeof(int));
layers[0] = qntNeuroniosEntrada;
layers[2+chromo.qntCamadasOcultas-1] = qntNeuroniosSaida;
aux = chromo.neurOcultos;
for (i=1; i < 2+chromo.qntCamadasOcultas-1 ; i++)
{
layers[i] = aux;
aux = aux/2;
}
// CRIANDO A RNA:
ANN = fann_create_standard_array(2+chromo.qntCamadasOcultas, layers);
// TREINO
fann_set_learning_rate(ANN, chromo.learnRate);
fann_set_learning_momentum(ANN, chromo.moment);
fann_set_activation_function_hidden( ANN, chromo.fcOculta );
fann_set_activation_function_output( ANN, chromo.fcSaida );
fann_set_training_algorithm(ANN, chromo.algAprend );
if (fann_get_training_algorithm(ANN) == FANN_TRAIN_QUICKPROP)
fann_set_quickprop_decay(ANN, chromo.decay);
// Em python, o treino ficava entre um try.
// Se desse erro, escrevia "Resultado: 999.0" e exit
fann_train_on_data(ANN, dadosTreino, chromo.epocasTreino, 50, desiredError);
fann_destroy_train(dadosTreino);
// TESTES:
dadosTeste = fann_read_train_from_file( nomeArqValidacao);
// Em python, o teste também ficava entre um try.
// Se desse erro, escrevia "Resultado: 999.0" e exit
for(i = 0; i < fann_length_train_data(dadosTeste); i++)
{
ANN_Answers = fann_run(ANN, dadosTeste->input[i]);
if (ANN_Answers == NULL)
{
printf("Resultado: 999.0\n");
exit(2);
}
for (j=0; j < qntNeuroniosSaida; j++)
erro += (float) powf(fann_abs(ANN_Answers[j] - dadosTeste->output[i][j]), 2);
}
printf("Resultado: %f\n", erro/(fann_length_train_data(dadosTeste)-1));
fann_destroy_train(dadosTeste);
saveANN(argc, argv, ANN);
fann_destroy(ANN);
}
void ViFann::setLearningMomentum(const qreal &momentum)
{
fann_set_learning_momentum(mNetwork, momentum);
}
