/*
* Creates an empty set of training data
*/
FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train(unsigned int num_data, unsigned int num_input, unsigned int num_output)
{
fann_type *data_input, *data_output;
unsigned int i;
struct fann_train_data *data =
(struct fann_train_data *) malloc(sizeof(struct fann_train_data));
if(data == NULL)
{
fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
return NULL;
}
fann_init_error_data((struct fann_error *) data);
data->num_data = num_data;
data->num_input = num_input;
data->num_output = num_output;
data->input = (fann_type **) calloc(num_data, sizeof(fann_type *));
if(data->input == NULL)
{
fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(data);
return NULL;
}
data->output = (fann_type **) calloc(num_data, sizeof(fann_type *));
if(data->output == NULL)
{
fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(data);
return NULL;
}
data_input = (fann_type *) calloc(num_input * num_data, sizeof(fann_type));
if(data_input == NULL)
{
fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(data);
return NULL;
}
data_output = (fann_type *) calloc(num_output * num_data, sizeof(fann_type));
if(data_output == NULL)
{
fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(data);
return NULL;
}
for(i = 0; i != num_data; i++)
{
data->input[i] = data_input;
data_input += num_input;
data->output[i] = data_output;
data_output += num_output;
}
return data;
}
int main(int argc, char *argv[])
{
/* parameters */
char output_file[256];
if(argc != 12)
{
printf("usage %s train_file test_file output_file width height topology neighborhood decay max_training_examples seconds_between_reports number_of_runs\n", argv[0]);
return -1;
}
unsigned int width = atoi(argv[4]);
unsigned int height = atoi(argv[5]);
unsigned int max_training_examples = atoi(argv[9]);
double seconds_between_reports = atof(argv[10]);
unsigned int number_of_runs = atoi(argv[11]);
fann_train_data *train_data = fann_read_train_from_file(argv[1]);
fann_train_data *test_data = fann_read_train_from_file(argv[2]);
char *train_out_file = argv[3];
FILE *train_out = 0;
fann_seed_rand();
for(unsigned int i = 0; i < number_of_runs; i++)
{
/* test_collector->newCollection();
train_collector->newCollection();
*/
if(strlen(train_out_file) == 1 && train_out_file[0] == '-')
train_out = stdout;
else
{
if(number_of_runs == 1)
train_out = fopen(train_out_file, "w");
else
{
sprintf(output_file, "%s_%d_run", train_out_file, i);
train_out = fopen(output_file, "w");
}
}
fprintf(stdout, "Quality test of %s\n", argv[1]);
quality_benchmark_fann_som(width, height, argv[6], argv[7], argv[8], train_data, test_data,
train_out, train_data->num_input, max_training_examples, seconds_between_reports);
fclose(train_out);
}
fann_destroy_train(train_data);
fann_destroy_train(test_data);
return 0;
}
int main()
{
const unsigned int num_layers = 3;
const unsigned int num_neurons_hidden = 32;
const float desired_error = (const float) 0.0001;
const unsigned int max_epochs = 300;
const unsigned int epochs_between_reports = 10;
struct fann *ann;
struct fann_train_data *train_data, *test_data;
unsigned int i = 0;
printf("Creating network.\n");
train_data = fann_read_train_from_file("../datasets/mushroom.train");
ann = fann_create_standard(num_layers,
train_data->num_input, num_neurons_hidden, train_data->num_output);
printf("Training network.\n");
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC_STEPWISE);
fann_set_activation_function_output(ann, FANN_SIGMOID_STEPWISE);
/*fann_set_training_algorithm(ann, FANN_TRAIN_INCREMENTAL); */
fann_train_on_data(ann, train_data, max_epochs, epochs_between_reports, desired_error);
printf("Testing network.\n");
test_data = fann_read_train_from_file("../datasets/mushroom.test");
fann_reset_MSE(ann);
for(i = 0; i < fann_length_train_data(test_data); i++)
{
fann_test(ann, test_data->input[i], test_data->output[i]);
}
printf("MSE error on test data: %f\n", fann_get_MSE(ann));
printf("Saving network.\n");
fann_save(ann, "mushroom_float.net");
printf("Cleaning up.\n");
fann_destroy_train(train_data);
fann_destroy_train(test_data);
fann_destroy(ann);
return 0;
}
int main( int argc, char** argv )
{
const unsigned int num_input = 3;
const unsigned int num_output = 1;
const unsigned int num_layers = 4;
const unsigned int num_neurons_hidden = 5;
const float desired_error = (const float) 0.0001;
const unsigned int max_epochs = 5000;
const unsigned int epochs_between_reports = 1000;
struct fann_train_data * data = NULL;
struct fann *ann = fann_create_standard(num_layers, num_input, num_neurons_hidden, num_neurons_hidden, num_output);
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_activation_function_output(ann, FANN_LINEAR);
fann_set_training_algorithm(ann, FANN_TRAIN_RPROP);
data = fann_read_train_from_file("../../datasets/scaling.data");
fann_set_scaling_params(
ann,
data,
-1, /* New input minimum */
1, /* New input maximum */
-1, /* New output minimum */
1); /* New output maximum */
fann_scale_train( ann, data );
fann_train_on_data(ann, data, max_epochs, epochs_between_reports, desired_error);
fann_destroy_train( data );
fann_save(ann, "scaling.net");
fann_destroy(ann);
return 0;
}
static void
lua_fann_thread_notify (gint fd, short what, gpointer ud)
{
struct lua_fann_train_cbdata *cbdata = ud;
struct lua_fann_train_reply rep;
if (read (cbdata->pair[0], &rep, sizeof (rep)) == -1) {
if (errno == EAGAIN || errno == EINTR) {
event_add (&cbdata->io, NULL);
return;
}
lua_fann_push_train_result (cbdata, errno, 0.0, strerror (errno));
}
else {
lua_fann_push_train_result (cbdata, rep.errcode, rep.mse, rep.errmsg);
}
g_assert (write (cbdata->pair[0], "", 1) == 1);
g_thread_join (cbdata->t);
close (cbdata->pair[0]);
close (cbdata->pair[1]);
fann_destroy_train (cbdata->train);
luaL_unref (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref);
g_free (cbdata);
}
int main( int argc, char** argv )
{
fann_type *calc_out;
unsigned int i;
int ret = 0;
struct fann *ann;
struct fann_train_data *data;
printf("Creating network.\n");
ann = fann_create_from_file("xor_float.net");
if(!ann)
{
printf("Error creating ann --- ABORTING.\n");
return 0;
}
fann_print_connections(ann);
fann_print_parameters(ann);
printf("Testing network.\n");
data = fann_read_train_from_file("5K.txt");
for(i = 0; i < fann_length_train_data(data); i++)
{
fann_reset_MSE(ann);
fann_scale_input( ann, data->input[i] );
calc_out = fann_run( ann, data->input[i] );
fann_descale_output( ann, calc_out );
printf("Result %f original %f error %f\n",
calc_out[0], data->output[i][0],
(float) fann_abs(calc_out[0] - data->output[i][0]));
}
printf("Cleaning up.\n");
fann_destroy_train(data);
fann_destroy(ann);
return ret;
}
int main()
{
fann_type *calc_out;
const unsigned int num_input = 2;
const unsigned int num_output = 1;
const unsigned int num_layers = 3;
const unsigned int num_neurons_hidden = 9;
const float desired_error = (const float) 0;
const unsigned int max_epochs = 500000;
const unsigned int epochs_between_reports = 1000;
struct fann *ann;
struct fann_train_data *data;
unsigned int i = 0;
unsigned int decimal_point;
printf("Creating network.\n");
ann = fann_create_standard(num_layers, num_input, num_neurons_hidden, num_output);
data = fann_read_train_from_file("osyslec_train.data");
fann_set_activation_steepness_hidden(ann, 1);
fann_set_activation_steepness_output(ann, 1);
fann_set_activation_function_hidden(ann, FANN_SIGMOID);
fann_set_activation_function_output(ann, FANN_SIGMOID);
fann_set_train_stop_function(ann, FANN_STOPFUNC_BIT);
fann_set_bit_fail_limit(ann, 0.01f);
fann_set_training_algorithm(ann, FANN_TRAIN_RPROP);
fann_init_weights(ann, data);
printf("Training network.\n");
fann_train_on_data(ann, data, max_epochs, epochs_between_reports, desired_error);
printf("Testing network. %f\n", fann_test_data(ann, data));
for(i = 0; i < fann_length_train_data(data); i++)
{
calc_out = fann_run(ann, data->input[i]);
printf("GG test (%f,%f) -> %f, should be %f, difference=%f\n",
data->input[i][0], data->input[i][1], calc_out[0], data->output[i][0],
fann_abs(calc_out[0] - data->output[i][0]));
}
printf("Saving network.\n");
fann_save(ann, "osyslec_train_float.net");
decimal_point = fann_save_to_fixed(ann, "osyslec_train_fixed.net");
fann_save_train_to_fixed(data, "osyslec_train_fixed.data", decimal_point);
printf("Cleaning up.\n");
fann_destroy_train(data);
fann_destroy(ann);
return 0;
}
int main() {
printf("Neural Network training\n");
const unsigned int num_input = 3;
const unsigned int num_output = 4;
const unsigned int num_layers = 4;
const unsigned int num_neurons_hidden = 30;
const float desired_error = (const float) 0.02;
const unsigned int max_epochs = 500000;
const unsigned int epochs_between_reports = 10;
struct fann *ann = fann_create_standard(
num_layers,
num_input,
num_neurons_hidden,
num_neurons_hidden,
// num_neurons_hidden,
num_output);
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC);
// fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_activation_function_output(ann, FANN_SIGMOID_SYMMETRIC);
struct fann_train_data *data = fann_read_train_from_file("../training.data");
fann_train_on_data(ann, data, max_epochs, epochs_between_reports, desired_error);
fann_destroy_train(data);
fann_save(ann, "../neural.net");
fann_destroy(ann);
return 0;
}
int main(int argc, const char* argv[])
{
const unsigned int max_epochs = 1000;
unsigned int num_threads = 1;
struct fann_train_data *data;
struct fann *ann;
long before;
float error;
unsigned int i;
if(argc == 2)
num_threads = atoi(argv[1]);
data = fann_read_train_from_file("../../datasets/mushroom.train");
ann = fann_create_standard(3, fann_num_input_train_data(data), 32, fann_num_output_train_data(data));
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_activation_function_output(ann, FANN_SIGMOID);
before = GetTickCount();
for(i = 1; i <= max_epochs; i++)
{
error = num_threads > 1 ? fann_train_epoch_irpropm_parallel(ann, data, num_threads) : fann_train_epoch(ann, data);
printf("Epochs %8d. Current error: %.10f\n", i, error);
}
printf("ticks %d", GetTickCount()-before);
fann_destroy(ann);
fann_destroy_train(data);
return 0;
}
int main()
{
struct fann *ann;
struct fann_train_data *train_data, *test_data;
const float desired_error = (const float) 0.001;
unsigned int max_neurons = 40;
unsigned int neurons_between_reports = 1;
printf("Reading data.\n");
train_data = fann_read_train_from_file("../benchmarks/datasets/two-spiral.train");
test_data = fann_read_train_from_file("../benchmarks/datasets/two-spiral.test");
fann_scale_train_data(train_data, 0, 1);
fann_scale_train_data(test_data, 0, 1);
printf("Creating network.\n");
ann = fann_create_shortcut(2, fann_num_input_train_data(train_data), fann_num_output_train_data(train_data));
fann_set_training_algorithm(ann, FANN_TRAIN_RPROP);
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_activation_function_output(ann, FANN_LINEAR_PIECE);
fann_set_train_error_function(ann, FANN_ERRORFUNC_LINEAR);
fann_print_parameters(ann);
printf("Training network.\n");
fann_cascadetrain_on_data(ann, train_data, max_neurons, neurons_between_reports, desired_error);
fann_print_connections(ann);
printf("\nTrain error: %f, Test error: %f\n\n", fann_test_data(ann, train_data),
fann_test_data(ann, test_data));
printf("Saving network.\n");
fann_save(ann, "two_spirali.net");
printf("Cleaning up.\n");
fann_destroy_train(train_data);
fann_destroy_train(test_data);
fann_destroy(ann);
return 0;
}
/*
* INTERNAL FUNCTION Reads training data from a file descriptor.
*/
struct fann_train_data *fann_read_train_from_fd(FILE * file, const char *filename)
{
unsigned int num_input, num_output, num_data, i, j;
unsigned int line = 1;
struct fann_train_data *data;
if(fscanf(file, "%u %u %u\n", &num_data, &num_input, &num_output) != 3)
{
fann_error(NULL, FANN_E_CANT_READ_TD, filename, line);
return NULL;
}
line++;
data = fann_create_train(num_data, num_input, num_output);
if(data == NULL)
{
return NULL;
}
for(i = 0; i != num_data; i++)
{
for(j = 0; j != num_input; j++)
{
if(!fann_scanvalue(file, FANNSCANF, &data->input[i][j]))
{
fann_error(NULL, FANN_E_CANT_READ_TD, filename, line);
fann_destroy_train(data);
return NULL;
}
}
line++;
for(j = 0; j != num_output; j++)
{
if(!fann_scanvalue(file, FANNSCANF, &data->output[i][j]))
{
fann_error(NULL, FANN_E_CANT_READ_TD, filename, line);
fann_destroy_train(data);
return NULL;
}
}
line++;
}
return data;
}
/*
Creer le meilleur fichier .net (apprentissage) possible
basé sur des tests effectués au cours de l'apprentissage
en fonction du nombre de neuronnes cachés choisis en entrée.
*/
void train(struct fann *ann, char* trainFile, char *testFile, char *netFile , unsigned int max_epochs, unsigned int epochs_between_reports, float desired_error, const unsigned int num_neurons_hidden) {
struct fann_train_data *trainData, *testData;
struct fann *annBest = fann_copy(ann);
float error;
unsigned int i;
char buffer[1024];
float testError = 1;
float testErrorBest = 1;
trainData = fann_read_train_from_file(trainFile);
testData = fann_read_train_from_file(testFile);
for(i = 1; i <= max_epochs; i++){
fann_shuffle_train_data(trainData); //melange les données
error = fann_train_epoch(ann, trainData); //fait une epoque, ann : le réseaux créer, erreur : l'erreur d'apprentissage
//Toute les 5 epoques
if(i % epochs_between_reports == 0 || error < desired_error){
fann_test_data(ann,testData);// teste le reseau sur les donnée de test
testError = fann_get_MSE(ann);
if (testError < testErrorBest) {
testErrorBest = testError;
annBest = fann_copy(ann);
printf("Epochs %8d; trainError : %f; testError : %f;\n", i, error,testError);
sprintf(buffer,"%s_%u_%d.net",netFile,num_neurons_hidden,i);
fann_save(annBest, buffer);
}
}
if(error < desired_error){
break;
}
}
sprintf(buffer,"%s_%u.net",netFile,num_neurons_hidden);
fann_save(annBest, buffer);
fann_destroy_train(trainData);
fann_destroy_train(testData);
}
void cunit_xor_test(void)
{
fann_type *calc_out = NULL;
unsigned int i;
int ret = 0;
struct fann *ann = NULL;
struct fann_train_data *data = NULL;
#ifdef FIXEDFANN
ann = fann_create_from_file("xor_fixed.net");
#else
ann = fann_create_from_file("xor_float.net");
#endif
CU_ASSERT_PTR_NOT_NULL_FATAL(ann);
#ifdef FIXEDFANN
data = fann_read_train_from_file("xor_fixed.data");
#else
data = fann_read_train_from_file("xor.data");
#endif
CU_ASSERT_PTR_NOT_NULL_FATAL(data);
for(i = 0; i < fann_length_train_data(data); i++)
{
fann_reset_MSE(ann);
calc_out = fann_test(ann, data->input[i], data->output[i]);
CU_ASSERT_PTR_NOT_NULL_FATAL(calc_out);
#ifdef FIXEDFANN
/*printf("XOR test (%d, %d) -> %d, should be %d, difference=%f\n",
data->input[i][0], data->input[i][1], calc_out[0], data->output[i][0],
(float) fann_abs(calc_out[0] - data->output[i][0]) / fann_get_multiplier(ann));*/
if((float) fann_abs(calc_out[0] - data->output[i][0]) / fann_get_multiplier(ann) > 0.2)
{
CU_FAIL("XOR test failed.");
ret = -1;
}
#else
/*printf("XOR test (%f, %f) -> %f, should be %f, difference=%f\n",
data->input[i][0], data->input[i][1], calc_out[0], data->output[i][0],
(float) fann_abs(calc_out[0] - data->output[i][0]));*/
#endif
}
fann_destroy_train(data);
fann_destroy(ann);
}
FANN_EXTERNAL void FANN_API fann_train_on_file(struct fann *ann, const char *filename,
unsigned int max_epochs,
unsigned int epochs_between_reports,
float desired_error)
{
struct fann_train_data *data = fann_read_train_from_file(filename);
if(data == NULL)
{
return;
}
fann_train_on_data(ann, data, max_epochs, epochs_between_reports, desired_error);
fann_destroy_train(data);
}
int
main(int argc, char **argv)
{
fann_type *calc_out;
unsigned int i, j;
struct fann *ann;
struct fann_train_data *data;
float error = 0.0;
if (argc < 3)
{
fprintf(stderr, "Use: %s FANN_network.net patternsFile\n", argv[0]);
exit(1);
}
printf("Openning ANN `%s'\n", argv[1]);
ann = fann_create_from_file(argv[1]);
if (!ann)
{
fprintf(stderr, "Error creating the ANN.\n");
return (1);
}
printf("Running ANN.\n");
data = fann_read_train_from_file(argv[2]);
for(i = 0; i < fann_length_train_data(data); i++)
{
calc_out = fann_run(ann, data->input[i]);
printf("ANN: %f ", calc_out[0]);
printf("Expected: %f ", data->output[i][0]);
printf("Error: %f ", (float) (data->output[i][0] -calc_out[0]));
printf("Throttle_Effort: %f Brake_Effort: %f Current_Velocity: %f\n",
// essa multiplicacao ocorre para desfazer o que o 'gerarEntrada.c' fez
data->input[i][360-3]*100.0, data->input[i][360-2]*100.0, data->input[i][360-1]*5.0);
error += (float) powf(fann_abs(calc_out[0] - data->output[i][0]),2);
}
printf("Test:: Squared Error: %f Mean Squared Error: %f\n", error, error/(fann_length_train_data(data)-1));
printf("Cleaning memory.\n");
fann_destroy_train(data);
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 NeuralNet::runNet(char* ptrDataFileName){
struct fann_train_data *ptrDataTest = fann_read_train_from_file(ptrDataFileName);
fann_reset_MSE(this->ptrNeuralNet);
fann_test_data(this->ptrNeuralNet, ptrDataTest);
printf("Mean Square Error: %f\n", fann_get_MSE(this->ptrNeuralNet));
fann_type *calc_out;
for(int i = 0; i < fann_length_train_data(ptrDataTest); i++){
calc_out = fann_run(this->ptrNeuralNet, ptrDataTest->input[i]);
cout << "Sample testing: "<< calc_out[0] << " " << ptrDataTest->output[i][0] << " " << fann_abs(calc_out[0] - ptrDataTest->output[i][0]) << endl;
}
fann_destroy_train(ptrDataTest);
}
int main()
{
const unsigned int num_input = 2;
const unsigned int num_output = 1;
const unsigned int num_layers = 3;
const unsigned int num_neurons_hidden = 3;
const float desired_error = (const float) 0.001;
const unsigned int max_epochs = 500000;
const unsigned int epochs_between_reports = 1000;
unsigned int i;
fann_type *calc_out;
struct fann_train_data *data;
struct fann *ann = fann_create_standard(num_layers,
num_input, num_neurons_hidden, num_output);
data = fann_read_train_from_file("xor.data");
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_activation_function_output(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_training_algorithm(ann, FANN_TRAIN_QUICKPROP);
train_on_steepness_file(ann, "xor.data", max_epochs,
epochs_between_reports, desired_error, (float) 1.0, (float) 0.1,
(float) 20.0);
fann_set_activation_function_hidden(ann, FANN_THRESHOLD_SYMMETRIC);
fann_set_activation_function_output(ann, FANN_THRESHOLD_SYMMETRIC);
for(i = 0; i != fann_length_train_data(data); i++)
{
calc_out = fann_run(ann, data->input[i]);
printf("XOR test (%f, %f) -> %f, should be %f, difference=%f\n",
data->input[i][0], data->input[i][1], calc_out[0], data->output[i][0],
(float) fann_abs(calc_out[0] - data->output[i][0]));
}
fann_save(ann, "xor_float.net");
fann_destroy(ann);
fann_destroy_train(data);
return 0;
}
int
main(int argc, char **argv)
{
fann_type *calc_out;
unsigned int i, j;
struct fann *ann;
struct fann_train_data *data;
if (argc < 2)
{
fprintf(stderr, "Use: %s arquivoTeste\n", argv[0]);
exit(1);
}
printf("Abrindo a Rede `%s'\n", ARQ_RNA);
ann = fann_create_from_file(ARQ_RNA);
if (!ann)
{
fprintf(stderr, "Erro criando a RNA.\n");
return (1);
}
//fann_print_connections(ann);
//fann_print_parameters(ann);
printf("Testando a RNA.\n");
data = fann_read_train_from_file(argv[1]);
for(i = 0; i < fann_length_train_data(data); i++)
{
fann_reset_MSE(ann);
calc_out = fann_run(ann, data->input[i]);
printf("Resultado: %f ", calc_out[0]);
printf("Original: %f " , data->output[i][0]);
printf("Erro: %f\n" , (float) fann_abs(calc_out[0] - data->output[i][0]));
}
printf("Limpando memoria.\n");
fann_destroy_train(data);
fann_destroy(ann);
return (0);
}
void train_on_steepness_file(struct fann *ann, char *filename,
unsigned int max_epochs, unsigned int epochs_between_reports,
float desired_error, float steepness_start,
float steepness_step, float steepness_end)
{
float error;
unsigned int i;
struct fann_train_data *data = fann_read_train_from_file(filename);
if(epochs_between_reports)
{
printf("Max epochs %8d. Desired error: %.10f\n", max_epochs, desired_error);
}
fann_set_activation_steepness_hidden(ann, steepness_start);
fann_set_activation_steepness_output(ann, steepness_start);
for(i = 1; i <= max_epochs; i++)
{
/* train */
error = fann_train_epoch(ann, data);
/* print current output */
if(epochs_between_reports &&
(i % epochs_between_reports == 0 || i == max_epochs || i == 1 || error < desired_error))
{
printf("Epochs %8d. Current error: %.10f\n", i, error);
}
if(error < desired_error)
{
steepness_start += steepness_step;
if(steepness_start <= steepness_end)
{
printf("Steepness: %f\n", steepness_start);
fann_set_activation_steepness_hidden(ann, steepness_start);
fann_set_activation_steepness_output(ann, steepness_start);
}
else
{
break;
}
}
}
fann_destroy_train(data);
}
/*! train:__gc()
*# Garbage collects training data.
*-
*/
static int ann_train_close(lua_State *L)
{
struct fann_train_data **train;
train = luaL_checkudata(L, 1, FANN_TRAIN_METATABLE);
luaL_argcheck(L, train != NULL, 1, "'training data' expected");
#ifdef FANN_VERBOSE
printf("Closing training data\n");
#endif
if(*train)
{
fann_destroy_train(*train);
*train = NULL;
}
return 0;
}
int main()
{
const float desired_error = (const float) 0.0001;
const unsigned int max_epochs = 350;
const unsigned int epochs_between_reports = 25;
struct fann *ann;
struct fann_train_data *train_data;
unsigned int i = 0;
printf("Creating network.\n");
train_data = fann_read_train_from_file("ann_training_data");
// Using incremental training -> shuffle training data
fann_shuffle_train_data(train_data);
// ann = fann_create_standard(num_layers,
// train_data->num_input, num_neurons_hidden, train_data->num_output);
//ann = fann_create_standard(500, 2, 50, 50, 21);
unsigned int layers[4] = {150, 70, 30, 22};
ann = fann_create_standard_array(4, layers);
printf("Training network.\n");
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC_STEPWISE);
fann_set_activation_function_output(ann, FANN_LINEAR_PIECE); //FANN_SIGMOID_STEPWISE);
fann_set_training_algorithm(ann, FANN_TRAIN_INCREMENTAL);
fann_train_on_data(ann, train_data, max_epochs, epochs_between_reports, desired_error);
printf("Saving network.\n");
fann_save(ann, "mymoves_gestures.net");
printf("Cleaning up.\n");
fann_destroy_train(train_data);
fann_destroy(ann);
return 0;
}
bool ViFann::setWeights(const Weights &initialization, const qreal &minimum, const qreal &maximum)
{
if(mNetwork == NULL) return false;
mWeights = initialization;
if(initialization == Random)
{
fann_randomize_weights(mNetwork, minimum, maximum);
mWeightsMinimum = minimum;
mWeightsMaximum = maximum;
}
else if(initialization == WidrowNguyen)
{
// Create fake training set so that FANN can determine the min and max values
fann_train_data *data = fann_create_train(1, 2, 1);
data->input[0][0] = 1;
data->input[0][1] = -1;
fann_init_weights(mNetwork, data);
fann_destroy_train(data);
}
return true;
}
FANN_EXTERNAL struct fann_train_data *FANN_API fann_subset_train_data(struct fann_train_data
*data, unsigned int pos,
unsigned int length)
{
unsigned int i;
fann_type *data_input, *data_output;
struct fann_train_data *dest =
(struct fann_train_data *) malloc(sizeof(struct fann_train_data));
if(dest == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
return NULL;
}
if(pos > data->num_data || pos+length > data->num_data)
{
fann_error((struct fann_error*)data, FANN_E_TRAIN_DATA_SUBSET, pos, length, data->num_data);
return NULL;
}
fann_init_error_data((struct fann_error *) dest);
dest->error_log = data->error_log;
dest->num_data = length;
dest->num_input = data->num_input;
dest->num_output = data->num_output;
dest->input = (fann_type **) calloc(dest->num_data, sizeof(fann_type *));
if(dest->input == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
dest->output = (fann_type **) calloc(dest->num_data, sizeof(fann_type *));
if(dest->output == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
data_input = (fann_type *) calloc(dest->num_input * dest->num_data, sizeof(fann_type));
if(data_input == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
memcpy(data_input, data->input[pos], dest->num_input * dest->num_data * sizeof(fann_type));
data_output = (fann_type *) calloc(dest->num_output * dest->num_data, sizeof(fann_type));
if(data_output == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
memcpy(data_output, data->output[pos], dest->num_output * dest->num_data * sizeof(fann_type));
for(i = 0; i != dest->num_data; i++)
{
dest->input[i] = data_input;
data_input += dest->num_input;
dest->output[i] = data_output;
data_output += dest->num_output;
}
return dest;
}
/*
* return a copy of a fann_train_data struct
*/
FANN_EXTERNAL struct fann_train_data *FANN_API fann_duplicate_train_data(struct fann_train_data
*data)
{
unsigned int i;
fann_type *data_input, *data_output;
struct fann_train_data *dest =
(struct fann_train_data *) malloc(sizeof(struct fann_train_data));
if(dest == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
return NULL;
}
fann_init_error_data((struct fann_error *) dest);
dest->error_log = data->error_log;
dest->num_data = data->num_data;
dest->num_input = data->num_input;
dest->num_output = data->num_output;
dest->input = (fann_type **) calloc(dest->num_data, sizeof(fann_type *));
if(dest->input == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
dest->output = (fann_type **) calloc(dest->num_data, sizeof(fann_type *));
if(dest->output == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
data_input = (fann_type *) calloc(dest->num_input * dest->num_data, sizeof(fann_type));
if(data_input == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
memcpy(data_input, data->input[0], dest->num_input * dest->num_data * sizeof(fann_type));
data_output = (fann_type *) calloc(dest->num_output * dest->num_data, sizeof(fann_type));
if(data_output == NULL)
{
fann_error((struct fann_error*)data, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
memcpy(data_output, data->output[0], dest->num_output * dest->num_data * sizeof(fann_type));
for(i = 0; i != dest->num_data; i++)
{
dest->input[i] = data_input;
data_input += dest->num_input;
dest->output[i] = data_output;
data_output += dest->num_output;
}
return dest;
}
/*
* merges training data into a single struct.
*/
FANN_EXTERNAL struct fann_train_data *FANN_API fann_merge_train_data(struct fann_train_data *data1,
struct fann_train_data *data2)
{
unsigned int i;
fann_type *data_input, *data_output;
struct fann_train_data *dest =
(struct fann_train_data *) malloc(sizeof(struct fann_train_data));
if(dest == NULL)
{
fann_error((struct fann_error*)data1, FANN_E_CANT_ALLOCATE_MEM);
return NULL;
}
if((data1->num_input != data2->num_input) || (data1->num_output != data2->num_output))
{
fann_error((struct fann_error*)data1, FANN_E_TRAIN_DATA_MISMATCH);
return NULL;
}
fann_init_error_data((struct fann_error *) dest);
dest->error_log = data1->error_log;
dest->num_data = data1->num_data+data2->num_data;
dest->num_input = data1->num_input;
dest->num_output = data1->num_output;
dest->input = (fann_type **) calloc(dest->num_data, sizeof(fann_type *));
if(dest->input == NULL)
{
fann_error((struct fann_error*)data1, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
dest->output = (fann_type **) calloc(dest->num_data, sizeof(fann_type *));
if(dest->output == NULL)
{
fann_error((struct fann_error*)data1, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
data_input = (fann_type *) calloc(dest->num_input * dest->num_data, sizeof(fann_type));
if(data_input == NULL)
{
fann_error((struct fann_error*)data1, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
memcpy(data_input, data1->input[0], dest->num_input * data1->num_data * sizeof(fann_type));
memcpy(data_input + (dest->num_input*data1->num_data),
data2->input[0], dest->num_input * data2->num_data * sizeof(fann_type));
data_output = (fann_type *) calloc(dest->num_output * dest->num_data, sizeof(fann_type));
if(data_output == NULL)
{
fann_error((struct fann_error*)data1, FANN_E_CANT_ALLOCATE_MEM);
fann_destroy_train(dest);
return NULL;
}
memcpy(data_output, data1->output[0], dest->num_output * data1->num_data * sizeof(fann_type));
memcpy(data_output + (dest->num_output*data1->num_data),
data2->output[0], dest->num_output * data2->num_data * sizeof(fann_type));
for(i = 0; i != dest->num_data; i++)
{
dest->input[i] = data_input;
data_input += dest->num_input;
dest->output[i] = data_output;
data_output += dest->num_output;
}
return dest;
}
void book_destroy(book_t *book)
{
fann_destroy_train((struct fann_train_data *) book);
}
int main()
{
fann_type *calc_out;
unsigned int i;
int ret = 0;
struct fann *ann;
struct fann_train_data *data;
printf("Creating network.\n");
#ifdef FIXEDFANN
ann = fann_create_from_file("digitde_validation_fixed.net");
#else
ann = fann_create_from_file("digitde_validation_float.net");
#endif
if(!ann)
{
printf("Error creating ann --- ABORTING.\n");
return -1;
}
fann_print_connections(ann);
fann_print_parameters(ann);
printf("Testing network.\n");
#ifdef FIXEDFANN
data = fann_read_train_from_file("digitde_validation_fixed.data");
#else
data = fann_read_train_from_file("digitde_validation.data");
#endif
for(i = 0; i < fann_length_train_data(data); i++)
{
fann_reset_MSE(ann);
calc_out = fann_test(ann, data->input[i], data->output[i]);
#ifdef FIXEDFANN
printf("GG test (%d, %d) -> %d, should be %d, difference=%f\n",
data->input[i][0], data->input[i][1], calc_out[0], data->output[i][0],
(float) fann_abs(calc_out[0] - data->output[i][0]) / fann_get_multiplier(ann));
if((float) fann_abs(calc_out[0] - data->output[i][0]) / fann_get_multiplier(ann) > 0.2)
{
printf("Test failed\n");
ret = -1;
}
#else
printf("GG test (%f, %f) -> %f, should be %f, difference=%f\n",
data->input[i][0], data->input[i][1], calc_out[0], data->output[i][0],
(float) fann_abs(calc_out[0] - data->output[i][0]));
#endif
}
printf("Cleaning up.\n");
fann_destroy_train(data);
fann_destroy(ann);
return ret;
}
int main ( int argc, char **argv )
{
srand(time(NULL));
if ( argc<=1 )
{
// printf ( "neuro num\r\n" );
// exit ( 0 );
}
if (argc>2)
{
//desired_error=atof(argv[2]);
numn=atoi(argv[1]);
l1n=atoi(argv[2]);
if (argc>3)
l2n=atoi(argv[3]);
if (argc>4)
l3n=atoi(argv[4]);
if (argc>5)
l4n=atoi(argv[5]);
if (argc>6)
l5n=atoi(argv[6]);
if (argc>7)
l6n=atoi(argv[7]);
}
signal ( 2, sig_term );
srand ( time ( NULL ) );
printf("loading training data...");
train_data = fann_read_train_from_file ( "train.dat" );
test_data = fann_read_train_from_file ( "test.dat" );
weight_data=fann_merge_train_data(train_data,test_data);
cln_weight_data=fann_duplicate_train_data(weight_data);
cln_test_data=fann_duplicate_train_data(test_data);
cln_train_data=fann_duplicate_train_data(train_data);
//num_neurons_hidden = atoi ( argv[1] );
srand(time(NULL));
y=atoi(argv[2]);
lay=atoi(argv[1]);
ln=lay+2;
if (lay==1)
y2=train_data->num_output;
best_perc=1;
printf("\r\ndoing %ux%u [layers=%u,out=%u]",lay,y,ln, train_data->num_output);
while (true)
{
neur1=1+(rand()%y);
neur2=1+(rand()%y);
conn_rate=0.5f+((rand()%50)*0.01f);
printf("\r\n%2dx%-4d: ",neur1,neur2);
// printf("create network: layers=%d l1n=%d l2n=%d l3n=%d l4n=%d\ l5n=%d l6n=%dr\n",numn,l1n,l2n,l3n,l4n,l5n,l6n);
ann = fann_create_standard (//conn_rate,
ln,
train_data->num_input,
neur1,
neur2,
train_data->num_output );
//fann_init_weights ( ann, train_data );
printf(" [%p] ",ann);
if ( ( int ) ann==NULL )
{
printf ( "error" );
exit ( 0 );
}
fann_set_activation_function_hidden(ann,FANN_SIGMOID);
fann_set_activation_function_output(ann,FANN_SIGMOID);
rebuild_functions(neur1);
fann_set_training_algorithm ( ann, FANN_TRAIN_RPROP );
fann_set_sarprop_temperature(ann,15000.0f);
//fann_randomize_weights ( ann, -((rand()%10)*0.1f), ((rand()%10)*0.1f) );
fann_init_weights(ann,train_data);
got_inc=0;
prev_epoch_mse=1;
//
epochs=0;
unsigned last_best_perc_epoch=0;
unsigned last_sync_epoch=0;
unsigned last_ftest_secs=0;
last_sync_epoch=0;
last_best_perc_epoch=0;
if (good_ann)
fann_destroy(good_ann);
good_ann=fann_copy(ann);
unlink(histfile);
for (u=0;u<1000;u++)
{
fflush(NULL);
train_mse=fann_train_epoch(ann, train_data);
if (jitter_train)
apply_jjit(train_data,cln_train_data);
if (time(NULL)-last_ftest_secs>=1)
{
//printf("\r\n%5u %9.6f %5.2f ",epochs,train_mse,test_perc);
//printf(" %4.2f",test_perc);
printf(".");
last_ftest_secs=time(NULL);
}
ftest_data();
plot(epochs,train_mse,test_mse);
/* if (epochs>10&&((int)test_perc==43||(int)test_perc==57))
{
printf(" [excluded %.2f] ",test_perc);
break;
} else {
} */
//printf("excluded %f ",test_perc);
double prev_test_perc;
// if (prev_epoch_mse==best_perc)
// printf("o");
if ((int)test_perc>(int)train_perc&&epochs-last_stat_epoch>10)
{
fann_destroy(good_ann);
good_ann=fann_copy(ann);
if (test_perc!=prev_test_perc)
printf("%.2f [%f]",test_perc,train_mse);
//printf(" sync[%4.2f]",test_perc);
last_stat_epoch=epochs;
}
else if (epochs-last_sync_epoch>111500)
{
last_sync_epoch=epochs;
}
if (epochs>210&&test_perc>best_perc)
{
// u--;
// fann_destroy(good_ann);
// good_ann=fann_copy(ann);
printf(" [saved best %.0f] ",test_perc);
last_stat_epoch=epochs;
// printf("%f",test_perc);
// fann_destroy(ann);
// ann=fann_copy(good_ann);
fann_save(ann,"mutate-best.net");
best_perc=test_perc;
printf(" %6.2f [%f]",test_perc,train_mse);
last_best_perc_epoch=epochs;
}
else if (epochs>11100&&((int)test_perc<=63||(int)test_perc==(int)prev_test_perc))
{
//best_perc=test_perc;
// printf("x");
// printf(".");
//printf("\r%6.8f",train_mse);
// printf("done\r\n");
break;
}
static unsigned last_restore_epoch=0;
if (epochs>100&&test_mse-train_mse>=0.25f&&epochs-last_restore_epoch>=120)
{
/* fann_set_learning_rate ( ann,0.31f+(rand()%90)*0.01f);
fann_set_learning_momentum(ann,(rand()%90)*0.01f);
printf(" [restored @ %u lr %.2f mm %.2f]",epochs,fann_get_learning_rate(ann),
fann_get_learning_momentum(ann));
fann_destroy(ann);
ann=fann_copy(good_ann);
last_stat_epoch=epochs;
last_restore_epoch=epochs; */
double rdec,rinc;
rdec=0.0101f+((rand()%100)*0.00001f);
if (!rdec)
rdec=0.01f;
rinc=1.0001f+((rand()%90)*0.00001f);
if (!rinc)
rinc=1.1f;
static double prev_test_epoch_mse;
// rinc+=diff_mse*0.000001f;
// fann_set_rprop_increase_factor(ann,rinc );
// fann_set_rprop_decrease_factor(ann, rdec);
}
else if (test_mse-train_mse<=0.1f)
{
fann_destroy(good_ann);
good_ann=fann_copy(ann);
// printf("s");
}
else
{
fann_set_sarprop_temperature(ann,fann_get_sarprop_temperature(ann)-0.0001f);
}
static unsigned last_train_change_epoch=0;
if (test_mse>=train_mse&&epochs-last_train_change_epoch>=100)
{
last_train_change_epoch=epochs;
//fann_set_training_algorithm(ann,FANN_TRAIN_SARPROP);
jitter_train=0;
}
else
{
//fann_set_training_algorithm(ann,FANN_TRAIN_RPROP);
jitter_train=0;
}
got_inc=test_perc-prev_epoch_mse;
prev_epoch_mse=test_perc;
prev_test_perc=test_perc;
epochs++;
if (epochs-last_best_perc_epoch>511500)
{
printf(" failed");
break;
}
if (epochs>2200&&(int)train_perc<40)
{
printf("skip 1\r\n");
break;
}
if ((int)test_perc>=80)
{
printf("\r\ngot it %f\r\n",test_perc);
fann_save(ann,"good.net");
exit(0);
}
// printf("\n%6u ",epochs);
}
printf(" %6.2f inc: %.2f",test_perc,got_inc);
// printf("%6.2f %6.2f",train_perc,test_perc);
fann_destroy ( ann );
}
fann_destroy_train ( train_data );
fann_destroy_train ( test_data );
fann_destroy ( ann );
return 0;
}
int main()
{
struct fann *ann;
struct fann_train_data *train_data, *test_data;
const float desired_error = (const float)0.0;
unsigned int max_neurons = 30;
unsigned int neurons_between_reports = 1;
unsigned int bit_fail_train, bit_fail_test;
float mse_train, mse_test;
unsigned int i = 0;
fann_type *output;
fann_type steepness;
int multi = 0;
enum fann_activationfunc_enum activation;
enum fann_train_enum training_algorithm = FANN_TRAIN_RPROP;
printf("Reading data.\n");
train_data = fann_read_train_from_file("../benchmarks/datasets/parity8.train");
test_data = fann_read_train_from_file("../benchmarks/datasets/parity8.test");
fann_scale_train_data(train_data, -1, 1);
fann_scale_train_data(test_data, -1, 1);
printf("Creating network.\n");
ann = fann_create_shortcut(2, fann_num_input_train_data(train_data), fann_num_output_train_data(train_data));
fann_set_training_algorithm(ann, training_algorithm);
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_activation_function_output(ann, FANN_LINEAR);
fann_set_train_error_function(ann, FANN_ERRORFUNC_LINEAR);
if(!multi)
{
/*steepness = 0.5;*/
steepness = 1;
fann_set_cascade_activation_steepnesses(ann, &steepness, 1);
/*activation = FANN_SIN_SYMMETRIC;*/
activation = FANN_SIGMOID_SYMMETRIC;
fann_set_cascade_activation_functions(ann, &activation, 1);
fann_set_cascade_num_candidate_groups(ann, 8);
}
if(training_algorithm == FANN_TRAIN_QUICKPROP)
{
fann_set_learning_rate(ann, 0.35);
fann_randomize_weights(ann, -2.0,2.0);
}
fann_set_bit_fail_limit(ann, 0.9);
fann_set_train_stop_function(ann, FANN_STOPFUNC_BIT);
fann_print_parameters(ann);
fann_save(ann, "cascade_train2.net");
printf("Training network.\n");
fann_cascadetrain_on_data(ann, train_data, max_neurons, neurons_between_reports, desired_error);
fann_print_connections(ann);
mse_train = fann_test_data(ann, train_data);
bit_fail_train = fann_get_bit_fail(ann);
mse_test = fann_test_data(ann, test_data);
bit_fail_test = fann_get_bit_fail(ann);
printf("\nTrain error: %f, Train bit-fail: %d, Test error: %f, Test bit-fail: %d\n\n",
mse_train, bit_fail_train, mse_test, bit_fail_test);
for(i = 0; i < train_data->num_data; i++)
{
output = fann_run(ann, train_data->input[i]);
if((train_data->output[i][0] >= 0 && output[0] <= 0) ||
(train_data->output[i][0] <= 0 && output[0] >= 0))
{
printf("ERROR: %f does not match %f\n", train_data->output[i][0], output[0]);
}
}
printf("Saving network.\n");
fann_save(ann, "cascade_train.net");
printf("Cleaning up.\n");
fann_destroy_train(train_data);
fann_destroy_train(test_data);
fann_destroy(ann);
return 0;
}