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;
}
/*
* Scale input and output data based on previously calculated parameters.
*/
FANN_EXTERNAL void FANN_API fann_descale_train( struct fann *ann, struct fann_train_data *data )
{
unsigned cur_sample;
if(ann->scale_mean_in == NULL)
{
fann_error( (struct fann_error *) ann, FANN_E_SCALE_NOT_PRESENT );
return;
}
/* Check that we have good training data. */
if(fann_check_input_output_sizes(ann, data) == -1)
return;
for( cur_sample = 0; cur_sample < data->num_data; cur_sample++ )
{
fann_descale_input( ann, data->input[ cur_sample ] );
fann_descale_output( ann, data->output[ cur_sample ] );
}
}
/*
* Scale input and output data based on previously calculated parameters.
*/
FANN_EXTERNAL void FANN_API fann_descale_train( struct fann *ann, struct fann_train_data *data )
{
unsigned cur_sample;
if(ann->scale_mean_in == NULL)
{
fann_error( (struct fann_error *) ann, FANN_E_SCALE_NOT_PRESENT );
return;
}
/* Check that we have good training data. */
/* No need for if( !params || !ann ) */
if( data->num_input != ann->num_input
|| data->num_output != ann->num_output
)
{
fann_error( (struct fann_error *) ann, FANN_E_TRAIN_DATA_MISMATCH );
return;
}
for( cur_sample = 0; cur_sample < data->num_data; cur_sample++ )
{
fann_descale_input( ann, data->input[ cur_sample ] );
fann_descale_output( ann, data->output[ cur_sample ] );
}
}
bool TwoAnn::sellShort(CandleStick * stick)
{
int numSticks = CandleStickManager::instance()->numSticks(stock_->symbol());
if(!isTradingTime(stock_->time()) || numSticks < 12)
{
return false;
}
if(0 != stick)
{
double closePrice = stick->closePrice();
double openPrice = stick->openPrice();
fann_type *annData = new fann_type[8];
fann_type * ann1Data = data_->getCandleData();
fann_scale_input( ann1_, ann1Data );
fann_type * ann1Out = fann_run( ann1_, ann1Data );
annData[0] = ann1Out[0];
delete [] ann1Data;
fann_type * ann2Data = data_->getCandleData();
fann_scale_input( ann2_, ann2Data );
fann_type * ann2Out = fann_run( ann2_, ann2Data );
annData[1] = ann2Out[0];
delete [] ann2Data;
fann_type * ann3Data = data_->getGMMAData();
fann_scale_input( ann3_, ann3Data );
fann_type * ann3Out = fann_run( ann3_, ann3Data );
annData[2] = ann3Out[0];
delete [] ann3Data;
fann_type * ann4Data = data_->getGMMAData();
fann_scale_input( ann4_, ann4Data );
fann_type * ann4Out = fann_run( ann4_, ann4Data );
annData[3] = ann4Out[0];
delete [] ann4Data;
fann_type * ann5Data = data_->getHilbertData();
fann_scale_input( ann5_, ann5Data );
fann_type * ann5Out = fann_run( ann5_, ann5Data );
annData[4] = ann5Out[0];
delete [] ann5Data;
fann_type * ann6Data = data_->getHilbertData();
fann_scale_input( ann6_, ann6Data );
fann_type * ann6Out = fann_run( ann6_, ann6Data );
annData[5] = ann6Out[0];
delete [] ann6Data;
fann_type * ann7Data = data_->getMishMashData();
fann_scale_input( ann7_, ann7Data );
fann_type * ann7Out = fann_run( ann7_, ann7Data );
annData[6] = ann7Out[0];
delete [] ann7Data;
fann_type * ann8Data = data_->getMishMashData();
fann_scale_input( ann8_, ann8Data );
fann_type * ann8Out = fann_run( ann8_, ann8Data );
annData[7] = ann8Out[0];
delete [] ann8Data;
fann_scale_input( annChairman_, annData );
fann_type * annChairmanOut = fann_run( annChairman_, annData );
fann_descale_output(annChairman_, annChairmanOut);
double result = annChairmanOut[0];
delete [] annData;
debugLog_ << stock_->symbol() << ","
<< TimeZone::instance()->formatDateTZ(stick->date(), stick->endTime()) << " " << TimeZone::instance()->formatTZ(stick->endTime()) << ","
<< openPrice << ","
<< stick->highPrice() << ","
<< stick->lowPrice() << ","
<< closePrice << ","
<< result << std::endl;
double vote = 0.0;
if(result > ann2Lower_)
{
std::strstream strstr;
strstr << "\n\tTwo Ann Entry (Short)\nClose Price: " << closePrice
<< "\nChairman Data: " << result << std::ends;
std::string msg = strstr.str();
strstr.clear();
strstr.rdbuf()->freeze(0);
DataLogger::instance()->recordDebug(msg, stock_->symbol());
return true;
}
}
return false;
}
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;
}
