const float CNeuroNetwok::Recognize(const _tstring& sPath)
{
if (!m_bIsNetworkTeached)
throw std::runtime_error("You should teach network first!");
// Восстанавливаем нейросеть из файла
m_pANN = fann_create_from_file(NETWORK_FILE_NAME);
if (!m_pANN)
{
std::string sError = "Failed to load data from: ";
sError += NETWORK_FILE_NAME;
throw std::runtime_error(sError);
}
// Подгружаем данные указанного файла
std::list< float > BmpData;
AnalizeBMP(sPath, BmpData);
// Преобразуем
TTrainData TestData;
TestData.push_back(std::pair< std::list< float >, bool > (BmpData, false));
boost::scoped_ptr< fann_train_data > pTestData(MakeTrainData(TestData));
#ifdef _DEBUG
// Для дебага
fann_save_train(pTestData.get(), "debug_data.dat");
#endif
// Получаем результат
fann_reset_MSE(m_pANN);
fann_type * pResult = fann_test(m_pANN, pTestData->input[0], pTestData->output[0]);
return *pResult;
}
bool Trainer::Test(const InputVector<float>& input_vector,
const OutputVector<float>& desired_output,
float* square_error, std::size_t* bit_fail) {
fann_reset_MSE(ann_);
tmp_input_vector_ = input_vector;
tmp_output_vector_ = desired_output;
fann_test(ann_, &tmp_input_vector_[0], &tmp_output_vector_[0]);
return GetMseAndBitFail(ann_, &square_error, &bit_fail);
}
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);
}
/*
* Test a set of training data and calculate the MSE
*/
FANN_EXTERNAL float FANN_API fann_test_data(struct fann *ann, struct fann_train_data *data)
{
unsigned int i;
fann_reset_MSE(ann);
for(i = 0; i != data->num_data; i++)
{
fann_test(ann, data->input[i], data->output[i]);
}
return fann_get_MSE(ann);
}
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;
}
float test_data_parallel(struct fann *ann, struct fann_train_data *data, const unsigned int threadnumb, vector< vector<fann_type> >& predicted_outputs)
{
if(fann_check_input_output_sizes(ann, data) == -1)
return 0;
predicted_outputs.resize(data->num_data,vector<fann_type> (data->num_output));
fann_reset_MSE(ann);
vector<struct fann *> ann_vect(threadnumb);
int i=0,j=0;
//generate copies of the ann
omp_set_dynamic(0);
omp_set_num_threads(threadnumb);
#pragma omp parallel private(j)
{
#pragma omp for schedule(static)
for(i=0; i<(int)threadnumb; i++)
{
ann_vect[i]=fann_copy(ann);
}
//parallel computing of the updates
#pragma omp for schedule(static)
for(i = 0; i < (int)data->num_data; ++i)
{
j=omp_get_thread_num();
fann_type* temp_predicted_output=fann_test(ann_vect[j], data->input[i],data->output[i]);
for(unsigned int k=0;k<data->num_output;++k)
{
predicted_outputs[i][k]=temp_predicted_output[k];
}
}
}
//merge of MSEs
for(i=0;i<(int)threadnumb;++i)
{
ann->MSE_value+= ann_vect[i]->MSE_value;
ann->num_MSE+=ann_vect[i]->num_MSE;
fann_destroy(ann_vect[i]);
}
return fann_get_MSE(ann);
}
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("scaling.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("scaling.data");
for(i = 0; i < fann_length_train_data(data); i++)
{
fann_reset_MSE(ann);
/* Just pass any param to perform scaling */
if( argc > 1 )
{
fann_scale_input( ann, data->input[i] );
calc_out = fann_run( ann, data->input[i] );
fann_descale_output( ann, calc_out );
}
else
{
calc_out = fann_test(ann, data->input[i], data->output[i]);
}
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;
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[]) {
int i, epoch, k, num_bits_failing, num_correct;
int max_epochs = 10000, exit_code = 0, batch_items = -1;
int flag_cups = 0, flag_last = 0, flag_mse = 0, flag_verbose = 0,
flag_bit_fail = 0, flag_ignore_limits = 0, flag_percent_correct = 0;
int mse_reporting_period = 1, bit_fail_reporting_period = 1,
percent_correct_reporting_period = 1;
float bit_fail_limit = 0.05, mse_fail_limit = -1.0;
double learning_rate = 0.7;
char id[100] = "0";
char * file_video_string = NULL;
FILE * file_video = NULL;
struct fann * ann = NULL;
struct fann_train_data * data = NULL;
fann_type * calc_out;
enum fann_train_enum type_training = FANN_TRAIN_BATCH;
char * file_nn = NULL, * file_train = NULL;
int c;
while (1) {
static struct option long_options[] = {
{"video-data", required_argument, 0, 'b'},
{"stat-cups", no_argument, 0, 'c'},
{"num-batch-items", required_argument, 0, 'd'},
{"max-epochs", required_argument, 0, 'e'},
{"bit-fail-limit", required_argument, 0, 'f'},
{"mse-fail-limit", required_argument, 0, 'g'},
{"help", no_argument, 0, 'h'},
{"id", required_argument, 0, 'i'},
{"stat-last", no_argument, 0, 'l'},
{"stat-mse", optional_argument, 0, 'm'},
{"nn-config", required_argument, 0, 'n'},
{"stat-bit-fail", optional_argument, 0, 'o'},
{"stat-percent-correct", optional_argument, 0, 'q'},
{"learning-rate", required_argument, 0, 'r'},
{"train-file", required_argument, 0, 't'},
{"verbose", no_argument, 0, 'v'},
{"incremental", optional_argument, 0, 'x'},
{"ignore-limits", no_argument, 0, 'z'}
};
int option_index = 0;
c = getopt_long (argc, argv, "b:cd:e:f:g:hi:lm::n:o::q::r:t:vx::z",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'b': file_video_string = optarg; break;
case 'c': flag_cups = 1; break;
case 'd': batch_items = atoi(optarg); break;
case 'e': max_epochs = atoi(optarg); break;
case 'f': bit_fail_limit = atof(optarg); break;
case 'g': mse_fail_limit = atof(optarg); break;
case 'h': usage(); exit_code = 0; goto bail;
case 'i': strcpy(id, optarg); break;
case 'l': flag_last = 1; break;
case 'm':
if (optarg)
mse_reporting_period = atoi(optarg);
flag_mse = 1;
break;
case 'n': file_nn = optarg; break;
case 'o':
if (optarg)
bit_fail_reporting_period = atoi(optarg);
flag_bit_fail = 1;
break;
case 'q':
if (optarg)
percent_correct_reporting_period = atoi(optarg);
flag_percent_correct = 1;
break;
case 'r': learning_rate = atof(optarg); break;
case 't': file_train = optarg; break;
case 'v': flag_verbose = 1; break;
case 'x': type_training=(optarg)?atoi(optarg):FANN_TRAIN_INCREMENTAL; break;
case 'z': flag_ignore_limits = 1; break;
}
};
// Make sure there aren't any arguments left over
if (optind != argc) {
fprintf(stderr, "[ERROR] Bad argument\n\n");
usage();
exit_code = -1;
goto bail;
}
// Make sure we have all required inputs
if (file_nn == NULL || file_train == NULL) {
fprintf(stderr, "[ERROR] Missing required input argument\n\n");
usage();
exit_code = -1;
goto bail;
}
// The training type needs to make sense
if (type_training > FANN_TRAIN_SARPROP) {
fprintf(stderr, "[ERROR] Training type %d outside of enumerated range (max: %d)\n",
type_training, FANN_TRAIN_SARPROP);
exit_code = -1;
goto bail;
}
ann = fann_create_from_file(file_nn);
data = fann_read_train_from_file(file_train);
if (batch_items != -1 && batch_items < data->num_data)
data->num_data = batch_items;
enum fann_activationfunc_enum af =
fann_get_activation_function(ann, ann->last_layer - ann->first_layer -1, 0);
ann->training_algorithm = type_training;
ann->learning_rate = learning_rate;
printf("[INFO] Using training type %d\n", type_training);
if (file_video_string != NULL)
file_video = fopen(file_video_string, "w");
double mse;
for (epoch = 0; epoch < max_epochs; epoch++) {
fann_train_epoch(ann, data);
num_bits_failing = 0;
num_correct = 0;
fann_reset_MSE(ann);
for (i = 0; i < fann_length_train_data(data); i++) {
calc_out = fann_test(ann, data->input[i], data->output[i]);
if (flag_verbose) {
printf("[INFO] ");
for (k = 0; k < data->num_input; k++) {
printf("%8.5f ", data->input[i][k]);
}
}
int correct = 1;
for (k = 0; k < data->num_output; k++) {
if (flag_verbose)
printf("%8.5f ", calc_out[k]);
num_bits_failing +=
fabs(calc_out[k] - data->output[i][k]) > bit_fail_limit;
if (fabs(calc_out[k] - data->output[i][k]) > bit_fail_limit)
correct = 0;
if (file_video)
fprintf(file_video, "%f ", calc_out[k]);
}
if (file_video)
fprintf(file_video, "\n");
num_correct += correct;
if (flag_verbose) {
if (i < fann_length_train_data(data) - 1)
printf("\n");
}
}
if (flag_verbose)
printf("%5d\n\n", epoch);
if (flag_mse && (epoch % mse_reporting_period == 0)) {
mse = fann_get_MSE(ann);
switch(af) {
case FANN_LINEAR_PIECE_SYMMETRIC:
case FANN_THRESHOLD_SYMMETRIC:
case FANN_SIGMOID_SYMMETRIC:
case FANN_SIGMOID_SYMMETRIC_STEPWISE:
case FANN_ELLIOT_SYMMETRIC:
case FANN_GAUSSIAN_SYMMETRIC:
case FANN_SIN_SYMMETRIC:
case FANN_COS_SYMMETRIC:
mse *= 4.0;
default:
break;
}
printf("[STAT] epoch %d id %s mse %8.8f\n", epoch, id, mse);
}
if (flag_bit_fail && (epoch % bit_fail_reporting_period == 0))
printf("[STAT] epoch %d id %s bfp %8.8f\n", epoch, id,
1 - (double) num_bits_failing / data->num_output /
fann_length_train_data(data));
if (flag_percent_correct && (epoch % percent_correct_reporting_period == 0))
printf("[STAT] epoch %d id %s perc %8.8f\n", epoch, id,
(double) num_correct / fann_length_train_data(data));
if (!flag_ignore_limits && (num_bits_failing == 0 || mse < mse_fail_limit))
goto finish;
// printf("%8.5f\n\n", fann_get_MSE(ann));
}
finish:
if (flag_last)
printf("[STAT] x 0 id %s epoch %d\n", id, epoch);
if (flag_cups)
printf("[STAT] x 0 id %s cups %d / ?\n", id,
epoch * fann_get_total_connections(ann));
bail:
if (ann != NULL)
fann_destroy(ann);
if (data != NULL)
fann_destroy_train(data);
if (file_video != NULL)
fclose(file_video);
return exit_code;
}
int main()
{
const unsigned int max_epochs = 1000;
const unsigned int epochs_between_reports = 10;
const unsigned int num_input = 48*48;
const unsigned int num_output = 30;
const unsigned int num_layers = 2;
const unsigned int num_neurons_hidden = 25;
const float desired_error = (const float) 0.0000;
fann_type *calc_out;
unsigned int i;
int incorrect,ret = 0;
int orig,pred; float max =0 ;
float learning_rate = 0.01;
struct fann *ann = fann_create_standard(num_layers, num_input, num_output);
fann_set_activation_function_hidden(ann, FANN_SIGMOID);
fann_set_activation_function_output(ann, FANN_LINEAR);
fann_set_learning_rate(ann, learning_rate);
fann_train_on_file(ann, "facial-train.txt", max_epochs,
epochs_between_reports, desired_error);
fann_reset_MSE(ann);
struct fann_train_data *data = fann_read_train_from_file("facial-test.txt");
printf("Testing network..\n");
for(i = 0; i < fann_length_train_data(data); i++) {
calc_out = fann_test(ann, data->input[i], data->output[i] );
printf ("%i ", i );
max = calc_out[0];
int maxo = data->output[i][0];
for (int n=0; n<30; n++) {
printf (" %.2f/%.2f(%.2f) ",calc_out[n]*(2*96), data->output[i][n]*(2*96), data->output[i][n]*(2*96) - calc_out[n]*(2*96) );
}
printf ("\n");
}
printf("Mean Square Error: %f\n", fann_get_MSE(ann));
//printf ("Incorrect %i\n", incorrect);
fann_save(ann, "facial.net");
fann_destroy_train(data);
fann_destroy(ann);
return 0;
}
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("./lib/fann/wc2fann/web_comp_fixed.net");
#else
ann = fann_create_from_file("./lib/fann/wc2fann/web_comp_config.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("./lib/fann/wc2fann/web_comp_fixed.data");
#else
data = fann_read_train_from_file("./lib/fann/wc2fann/data/selection.test");
#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("Web Comp 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("Web Comp 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]));
//Web_Comp
double answer = fann_abs(calc_out[0] - data->output[0][0]);
FILE *output;
output = fopen("./lib/fann/wc2fann/data/Web_Comp_Answer.txt","w");
fprintf(output, "%f", answer);
fclose(output);
#endif
}
printf("Cleaning up.\n");
fann_destroy_train(data);
fann_destroy(ann);
return ret;
}
int main()
{
fann_type *calc_out;
unsigned int i;
int ret = 0;
int max_expected_idx=0,max_predicted_idx=0,count=0;
struct fann *ann;
struct fann_train_data *data;
printf("Creating network.\n");
#ifdef FIXEDFANN
ann = fann_create_from_file("mnist_fixed1.net");
#else
ann = fann_create_from_file("mnist_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("mnist.data");
#else
data = fann_read_train_from_file("mnist.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("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)
{
printf("Test failed\n");
ret = -1;
}
#else
max_expected_idx = 0;
max_predicted_idx = 0;
for(int k=1;k<10;k++)
{
if(data->output[i][max_expected_idx] < data->output[i][k])
{
max_expected_idx = k;
}
if(calc_out[max_predicted_idx] < calc_out[k])
{
max_predicted_idx = k;
}
}
printf("MNIST test %d Expected %d , returned=%d\n",
i,max_expected_idx, max_predicted_idx);
if(max_expected_idx == max_predicted_idx)
count++;
#endif
}
printf("Cleaning up.\n");
fann_destroy_train(data);
fann_destroy(ann);
printf("Number correct=%d\n",count);
return ret;
}
