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;
}
/*! train:save(filename)
*# Saves training data to a specified file
*x train:save("train.data")
*-
*/
static int ann_save_train(lua_State *L)
{
struct fann_train_data **train;
const char *fname;
if(lua_gettop(L) < 2)
luaL_error(L, "insufficient parameters");
train = luaL_checkudata(L, 1, FANN_TRAIN_METATABLE);
luaL_argcheck(L, train != NULL, 1, "'training data' expected");
fname = lua_tostring(L, 2);
#ifdef FANN_VERBOSE
printf("Saving training data to %s\n", fname);
#endif
fann_save_train(*train, fname);
return 0;
}
int main(int argc, char *argv[])
{
struct fann_train_data *train, *test, *all;
unsigned int i, j;
unsigned int length, half_length;
if(argc == 2)
{
train = fann_read_train_from_file(argv[1]);
fann_shuffle_train_data(train);
fann_scale_train_data(train, 0, 1);
fann_save_train(train, argv[1]);
return 0;
}
else if(argc == 3)
{
train = fann_read_train_from_file(argv[1]);
test = fann_read_train_from_file(argv[2]);
all = fann_merge_train_data(train, test);
fann_shuffle_train_data(all);
for(i = 0; i < train->num_data; i++)
{
for(j = 0; j < train->num_input; j++)
{
train->input[i][j] = all->input[i][j];
}
for(j = 0; j < train->num_output; j++)
{
train->output[i][j] = all->output[i][j];
}
}
for(i = 0; i < test->num_data; i++)
{
for(j = 0; j < test->num_input; j++)
{
test->input[i][j] = all->input[i + train->num_data][j];
}
for(j = 0; j < test->num_output; j++)
{
test->output[i][j] = all->output[i + train->num_data][j];
}
}
fann_save_train(train, argv[1]);
fann_save_train(test, argv[2]);
}
else if(argc == 4)
{
all = fann_read_train_from_file(argv[1]);
fann_shuffle_train_data(all);
fann_scale_train_data(all, 0, 1);
length = fann_length_train_data(all);
half_length = length/2;
train = fann_subset_train_data(all, 0, half_length);
test = fann_subset_train_data(all, half_length, length-half_length);
fann_save_train(train, argv[2]);
fann_save_train(test, argv[3]);
}
else
{
printf("usage: %s train_file\n", argv[0]);
printf("will shuffle the data in the file.\n");
printf("usage: %s train_file test_file\n", argv[0]);
printf("will shuffle the data in the two files and save the new data back to them.\n");
printf("usage: %s input_file train_file test_file\n", argv[0]);
printf("will shuffle the data in the input_file, and split it in two files and save the new data back to them.\n\n");
return -1;
}
return 0;
}
int main(int argc, const char* argv[])
{
if (argc < 2) {
printf("Usage: ./dinneuro filename\n");
return -1;
}
//подготавливаем выборки
if (csv2fann2(argv[1], 59, 50, 100, true)) { printf("Converted\n"); }
//получим данные о количестве входных и выходных параметров
int *params;
const char * filename;
const char * normfilename;
filename = "data.data";
//filename = "scaling.data";
normfilename = "normalized.train";
params = getparams(filename);
unsigned int num_threads = omp_get_thread_num();
float error;
const unsigned int num_input = params[1];
const unsigned int num_output = params[2];
//printf("num_input=%d num_output=%d\n", num_input, num_output);
const unsigned int num_layers = 4;
//const unsigned int num_neurons_hidden = num_output;
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_LINEAR);
fann_set_activation_function_output(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_training_algorithm(ann, FANN_TRAIN_RPROP);
//printf("test\n");
data = fann_read_train_from_file(filename);
printf("Readed train from %s\n", filename);
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 );
printf("Scaled\n");
//сохраним нормализованную обучающу выборку в файл
fann_save_train(data, normfilename);
printf("Saved scaled file %s\n", normfilename);
unsigned int i;
printf("Start learning...\n");
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);
//если ошибка обучения меньше или равно заданной - выходим из цикла обучения
//if (error <= desired_error) { printf ("Desired error detected. Finishing teaching.\n"); break; }
//если текущий счетчик делится без остатка на epochs_between_reports - пишем лог
//if (i % epochs_between_reports == 0) { printf("Epochs %8d. Current error: %.10f\n", i, error); }
}
printf("End learning.\n");
printf("MSE = %f\n", fann_get_MSE(ann));
//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);
//проверка
printf("Testing...\n");
fann_type *calc_out;
//printf("fann_length_train_data=%d\n",fann_length_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(filename);
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 or %.2f%%\n",
calc_out[0], data->output[i][0],
(float) fann_abs(calc_out[0] - data->output[i][0]), (100*(float) fann_abs(calc_out[0] - data->output[i][0]))/(float)calc_out[0]);
}
fann_destroy_train( data );
fann_destroy(ann);
return 0;
}
const _tstring CNeuroNetwok::Teach(const std::vector< std::pair < _tstring, bool > >& InputData)
{
// На входе в Data карта путей к файлам и результатам, которые должны получится при распознавании
// Подгружаем данные для каждого файла
std::vector< std::pair < _tstring, bool > >::const_iterator it = InputData.begin();
const std::vector< std::pair < _tstring, bool > >::const_iterator itEnd = InputData.end();
for (; it != itEnd; ++it)
{
// Путь
const _tstring& sPath = it->first;
// Результат
const bool bResult = it->second;
// Данные
std::list< float > BmpData;
// Получаем данные для смещения 0 градусов
AnalizeBMP(sPath, BmpData);
// Добавляем данные
m_TrainData.push_back(std::pair< std::list< float >, bool > (BmpData, bResult));
/*
// Получаем данные для смещения 90 градусов
AnalizeBMP(sPath, BmpData, 90);
// Добавляем данные
m_TrainData.push_back(std::pair< std::list< float >, bool > (BmpData, bResult));
// Получаем данные для смещения 180 градусов
AnalizeBMP(sPath, BmpData, 180);
// Добавляем данные
m_TrainData.push_back(std::pair< std::list< float >, bool > (BmpData, bResult));
// Получаем данные для смещения 270 градусов
AnalizeBMP(sPath, BmpData, 270);
// Добавляем данные
m_TrainData.push_back(std::pair< std::list< float >, bool > (BmpData, bResult));*/
}
// Получили структуру данных, необходимую для тренировки нейросети
// преобразуем ее к виду, необходимую для библиотеки fann
boost::scoped_ptr< fann_train_data > pTrainData(MakeTrainData(m_TrainData));
if (!pTrainData)
throw std::runtime_error("Failed to make train data!");
#ifdef _DEBUG
// Для дебага
fann_save_train(pTrainData.get(), "debug_data.dat");
#endif
// Инициализируем веса связей нейронов
fann_init_weights(m_pANN, pTrainData.get());
const float fDesiredError = (const float) 0;
const unsigned int nEpochsBetweenReports = 10;
// Тренируем нейросеть
fann_train_on_data(m_pANN, pTrainData.get(), m_nEpochsCount, nEpochsBetweenReports, fDesiredError);
// Сохраняем нейросеть
fann_save(m_pANN, NETWORK_FILE_NAME);
// Тестируем сеть и возвращаем результат
m_bIsNetworkTeached = true;
return boost::lexical_cast< _tstring > (fann_test_data(m_pANN, pTrainData.get()));
}
