00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include <iostream>
00019 #include <fstream>
00020 #include <string>
00021 #include <sstream>
00022 #include <cmath>
00023
00024
00025
00026 #include "function_regression_testing.h"
00027
00028 namespace OpenNN
00029 {
00030
00031
00032
00035
00036 FunctionRegressionTesting::FunctionRegressionTesting(void)
00037 : neural_network_pointer(NULL),
00038 data_set_pointer(NULL)
00039 {
00040 set_default();
00041 }
00042
00043
00044
00045
00049
00050 FunctionRegressionTesting::FunctionRegressionTesting(NeuralNetwork* new_neural_network_pointer)
00051 : neural_network_pointer(new_neural_network_pointer),
00052 data_set_pointer(NULL)
00053 {
00054 set_default();
00055 }
00056
00057
00058
00059
00063
00064 FunctionRegressionTesting::FunctionRegressionTesting(DataSet* new_data_set_pointer)
00065 : neural_network_pointer(NULL),
00066 data_set_pointer(new_data_set_pointer)
00067 {
00068 set_default();
00069 }
00070
00071
00072
00073
00078
00079 FunctionRegressionTesting::FunctionRegressionTesting(NeuralNetwork* new_neural_network_pointer, DataSet* new_data_set_pointer)
00080 : neural_network_pointer(new_neural_network_pointer),
00081 data_set_pointer(new_data_set_pointer)
00082 {
00083 set_default();
00084 }
00085
00086
00087
00088
00093
00094 FunctionRegressionTesting::FunctionRegressionTesting(TiXmlElement* function_regression_testing_element)
00095 : neural_network_pointer(NULL),
00096 data_set_pointer(NULL)
00097 {
00098 set_default();
00099
00100 from_XML(function_regression_testing_element);
00101 }
00102
00103
00104
00105
00108
00109 FunctionRegressionTesting::~FunctionRegressionTesting()
00110 {
00111 }
00112
00113
00114
00115
00117
00118 NeuralNetwork* FunctionRegressionTesting::get_neural_network_pointer(void) const
00119 {
00120 return(neural_network_pointer);
00121 }
00122
00123
00124
00125
00127
00128 DataSet* FunctionRegressionTesting::get_data_set_pointer(void) const
00129 {
00130 return(data_set_pointer);
00131 }
00132
00133
00134
00135
00138
00139 const bool& FunctionRegressionTesting::get_display(void) const
00140 {
00141 return(display);
00142 }
00143
00144
00145
00146
00149
00150 void FunctionRegressionTesting::set_neural_network_pointer(NeuralNetwork* new_neural_network_pointer)
00151 {
00152 neural_network_pointer = new_neural_network_pointer;
00153 }
00154
00155
00156
00157
00160
00161 void FunctionRegressionTesting::set_data_set_pointer(DataSet* new_data_set_pointer)
00162 {
00163 data_set_pointer = new_data_set_pointer;
00164 }
00165
00166
00167
00168
00171
00172 void FunctionRegressionTesting::set_display(const bool& new_display)
00173 {
00174 display = new_display;
00175 }
00176
00177
00178
00179
00184
00185 void FunctionRegressionTesting::set_default(void)
00186 {
00187 display = true;
00188 }
00189
00190
00191
00192
00195
00196 Vector< Matrix<double> > FunctionRegressionTesting::calculate_scaled_target_output_data(void) const
00197 {
00198
00199
00200 #ifdef _DEBUG
00201
00202 check();
00203
00204 #endif
00205
00206
00207
00208 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
00209
00210 const unsigned int testing_instances_number = instances_information.count_testing_instances_number();
00211
00212 const Matrix<double> testing_input_data = data_set_pointer->arrange_testing_input_data();
00213
00214 const Matrix<double> testing_target_data = data_set_pointer->arrange_testing_target_data();
00215
00216
00217
00218 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00219
00220 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00221
00222 bool scaling_layer_flag = neural_network_pointer->get_scaling_layer_flag();
00223 bool unscaling_layer_flag = neural_network_pointer->get_unscaling_layer_flag();
00224
00225 neural_network_pointer->set_scaling_layer_flag(false);
00226 neural_network_pointer->set_unscaling_layer_flag(false);
00227
00228 const Matrix<double> testing_output_data = neural_network_pointer->calculate_output_data(testing_input_data);
00229
00230 neural_network_pointer->set_scaling_layer_flag(scaling_layer_flag);
00231 neural_network_pointer->set_unscaling_layer_flag(unscaling_layer_flag);
00232
00233
00234
00235 Vector< Matrix<double> > scaled_target_output_data(outputs_number);
00236
00237 for(unsigned int i = 0; i < outputs_number; i++)
00238 {
00239 scaled_target_output_data[i].set(testing_instances_number, 2);
00240
00241 for(unsigned int j = 0; j < testing_instances_number; j++)
00242 {
00243 scaled_target_output_data[i][j][0] = testing_target_data[j][i];
00244 scaled_target_output_data[i][j][1] = testing_output_data[j][i];
00245 }
00246 }
00247
00248 return(scaled_target_output_data);
00249 }
00250
00251
00252
00253
00259
00260 void FunctionRegressionTesting::check(void) const
00261 {
00262 std::ostringstream buffer;
00263
00264 if(!neural_network_pointer)
00265 {
00266 buffer << "OpenNN Exception: FunctionRegressionTesting class.\n"
00267 << "void check(void) const method.\n"
00268 << "Neural network is NULL.\n";
00269
00270 throw std::logic_error(buffer.str().c_str());
00271 }
00272
00273 if(!data_set_pointer)
00274 {
00275 buffer << "OpenNN Exception: FunctionRegressionTesting class.\n"
00276 << "void check(void) const method.\n"
00277 << "Data set is NULL.\n";
00278
00279 throw std::logic_error(buffer.str().c_str());
00280 }
00281 }
00282
00283
00284
00285
00292
00293 Vector< Vector<double> > FunctionRegressionTesting::calculate_linear_regression_parameters(void) const
00294 {
00295
00296
00297 #ifdef _DEBUG
00298
00299 check();
00300
00301 #endif
00302
00303
00304
00305 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
00306
00307 const unsigned int testing_instances_number = instances_information.count_testing_instances_number();
00308
00309
00310
00311 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00312
00313 const unsigned int inputs_number = multilayer_perceptron_pointer->count_outputs_number();
00314 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00315
00316 #ifdef _DEBUG
00317
00318 std::ostringstream buffer;
00319
00320 if(testing_instances_number == 0)
00321 {
00322 buffer << "OpenNN Exception: FunctionRegressionTesting class.\n"
00323 << "Vector< Vector<double> > calculate_linear_regression_parameters(void) const method.\n"
00324 << "Number of testing instances is zero.\n";
00325
00326 throw std::logic_error(buffer.str().c_str());
00327 }
00328
00329 #endif
00330
00331
00332
00333 Vector<double> inputs(inputs_number);
00334 Vector<double> targets(outputs_number);
00335 Vector<double> outputs(outputs_number);
00336
00337 Vector<double> targets_sum(outputs_number, 0.0);
00338 Vector<double> squared_targets_sum(outputs_number, 0.0);
00339 Vector<double> outputs_sum(outputs_number, 0.0);
00340 Vector<double> targets_outputs_sum(outputs_number, 0.0);
00341
00342 for(unsigned int i = 0; i < testing_instances_number; i++)
00343 {
00344 targets = data_set_pointer->get_testing_target_instance(i);
00345
00346 inputs = data_set_pointer->get_testing_input_instance(i);
00347 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00348
00349 targets_sum += targets;
00350 squared_targets_sum += targets*targets;
00351 outputs_sum += outputs;
00352 targets_outputs_sum += targets*outputs;
00353 }
00354
00355 const Vector<double> intercept = (outputs_sum*squared_targets_sum-targets_sum*targets_outputs_sum)
00356 /(squared_targets_sum*testing_instances_number - targets_sum*targets_sum);
00357
00358 const Vector<double> slope = (targets_outputs_sum*testing_instances_number - outputs_sum*targets_sum)
00359 /(squared_targets_sum*testing_instances_number - targets_sum*targets_sum);
00360
00361 Vector< Vector<double> > linear_regression_parameters(outputs_number);
00362
00363 for(unsigned int i = 0; i < outputs_number; i++)
00364 {
00365 linear_regression_parameters[i].set(2);
00366
00367 linear_regression_parameters[i][0] = intercept[i];
00368 linear_regression_parameters[i][1] = slope[i];
00369 }
00370
00371 return(linear_regression_parameters);
00372 }
00373
00374
00375
00376
00383
00384 FunctionRegressionTesting::LinearRegressionAnalysisResults FunctionRegressionTesting::perform_linear_regression_analysis(void) const
00385 {
00386 LinearRegressionAnalysisResults linear_regression_analysis_results;
00387
00388 linear_regression_analysis_results.linear_regression_parameters = calculate_linear_regression_parameters();
00389 linear_regression_analysis_results.scaled_target_output_data = calculate_scaled_target_output_data();
00390
00391 return(linear_regression_analysis_results);
00392 }
00393
00394
00395
00396
00399
00400 void FunctionRegressionTesting::LinearRegressionAnalysisResults::save(const std::string& filename) const
00401 {
00402 std::ofstream file(filename.c_str());
00403
00404 file << "Linear regression parameters:\n"
00405 << linear_regression_parameters
00406 << "Scaled target-output data:\n"
00407 << scaled_target_output_data;
00408
00409 file.close();
00410 }
00411
00412
00413
00414
00424
00425 Vector< Matrix<double> > FunctionRegressionTesting::calculate_error_data(void) const
00426 {
00427
00428
00429 #ifdef _DEBUG
00430
00431 check();
00432
00433 #endif
00434
00435 const Matrix<double> testing_input_data = data_set_pointer->arrange_testing_input_data();
00436
00437 const Matrix<double> testing_target_data = data_set_pointer->arrange_testing_target_data();
00438
00439 const Matrix<double> testing_output_data = neural_network_pointer->calculate_output_data(testing_input_data);
00440
00441 const UnscalingLayer* unscaling_layer_pointer = neural_network_pointer->get_unscaling_layer_pointer();
00442
00443 #ifdef _DEBUG
00444
00445 std::ostringstream buffer;
00446
00447 if(!unscaling_layer_pointer)
00448 {
00449 buffer << "OpenNN Exception: FunctionRegressionTesting class.\n"
00450 << "Vector< Matrix<double> > calculate_error_data(void) const.\n"
00451 << "Unscaling layer is NULL.\n";
00452
00453 throw std::logic_error(buffer.str().c_str());
00454 }
00455
00456 #endif
00457
00458 const Vector<double>& outputs_minimum = unscaling_layer_pointer->get_minimums();
00459 const Vector<double>& outputs_maximum = unscaling_layer_pointer->get_maximums();
00460
00461
00462
00463 Vector< Matrix<double> > error_data(3);
00464
00465
00466
00467 error_data[0] = testing_target_data - testing_output_data;
00468
00469
00470
00471 error_data[1] = error_data[0]/(outputs_maximum-outputs_minimum);
00472
00473
00474
00475 error_data[2] = error_data[1]*100.0;
00476
00477 return(error_data);
00478 }
00479
00480
00481
00482
00490
00491 Vector< Vector< Vector<double> > > FunctionRegressionTesting::calculate_error_data_statistics(void) const
00492 {
00493 const Vector< Vector< Vector<double> > > statistics;
00494
00495 return(statistics);
00496 }
00497
00498
00499
00500
00504
00505 Vector< Vector< Vector<double> > > FunctionRegressionTesting::calculate_error_data_histogram(const unsigned int& bins_number) const
00506 {
00507 const Vector< Matrix<double> > error_data = calculate_error_data();
00508
00509 return(error_data[2].calculate_histogram(bins_number));
00510 }
00511
00512
00513
00514
00517
00518 Vector< Vector< Vector<double> > > FunctionRegressionTesting::calculate_error_data_histogram(void) const
00519 {
00520 Vector< Matrix<double> > error_data = calculate_error_data();
00521
00522 return(error_data[0].calculate_histogram());
00523 }
00524
00525
00526
00527
00529
00530 std::string FunctionRegressionTesting::to_string(void) const
00531 {
00532 std::ostringstream buffer;
00533
00534 buffer << "Function regression testing\n"
00535 << "Display: " << display << "\n";
00536
00537 return(buffer.str());
00538 }
00539
00540
00541
00542
00546
00547 TiXmlElement* FunctionRegressionTesting::to_XML(void) const
00548 {
00549 return(NULL);
00550 }
00551
00552
00553
00554
00556
00558
00559 void FunctionRegressionTesting::from_XML(TiXmlElement*)
00560 {
00561 }
00562
00563
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611
00613
00614
00615
00616
00617
00620
00623
00625
00627
00628
00629
00630
00631
00633
00634
00635
00636
00637
00638
00639 }
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658