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 "pattern_recognition_testing.h"
00027
00028 namespace OpenNN
00029 {
00030
00031
00032
00035
00036 PatternRecognitionTesting::PatternRecognitionTesting(void)
00037 : neural_network_pointer(NULL),
00038 data_set_pointer(NULL)
00039 {
00040 }
00041
00042
00043
00044
00048
00049 PatternRecognitionTesting::PatternRecognitionTesting(NeuralNetwork* new_neural_network_pointer)
00050 : neural_network_pointer(new_neural_network_pointer),
00051 data_set_pointer(NULL)
00052 {
00053 }
00054
00055
00056
00057
00061
00062 PatternRecognitionTesting::PatternRecognitionTesting(DataSet* new_data_set_pointer)
00063 : neural_network_pointer(NULL),
00064 data_set_pointer(new_data_set_pointer)
00065 {
00066 }
00067
00068
00069
00070
00075
00076 PatternRecognitionTesting::PatternRecognitionTesting(NeuralNetwork* new_neural_network_pointer, DataSet* new_data_set_pointer)
00077 : neural_network_pointer(new_neural_network_pointer),
00078 data_set_pointer(new_data_set_pointer)
00079 {
00080 }
00081
00082
00083
00084
00089
00090 PatternRecognitionTesting::PatternRecognitionTesting(TiXmlElement* pattern_recognition_testing_element)
00091 : neural_network_pointer(NULL),
00092 data_set_pointer(NULL)
00093 {
00094 set_default();
00095
00096 from_XML(pattern_recognition_testing_element);
00097 }
00098
00099
00100
00101
00103
00104 PatternRecognitionTesting::~PatternRecognitionTesting(void)
00105 {
00106 }
00107
00108
00109
00110
00111
00112
00114
00115 NeuralNetwork* PatternRecognitionTesting::get_neural_network_pointer(void) const
00116 {
00117 return(neural_network_pointer);
00118 }
00119
00120
00121
00122
00124
00125 DataSet* PatternRecognitionTesting::get_data_set_pointer(void) const
00126 {
00127 return(data_set_pointer);
00128 }
00129
00130
00131
00132
00135
00136 const bool& PatternRecognitionTesting::get_display(void) const
00137 {
00138 return(display);
00139 }
00140
00141
00142
00143
00146
00147 void PatternRecognitionTesting::set_neural_network_pointer(NeuralNetwork* new_neural_network_pointer)
00148 {
00149 neural_network_pointer = new_neural_network_pointer;
00150 }
00151
00152
00153
00154
00157
00158 void PatternRecognitionTesting::set_data_set_pointer(DataSet* new_data_set_pointer)
00159 {
00160 data_set_pointer = new_data_set_pointer;
00161 }
00162
00163
00164
00165
00168
00169 void PatternRecognitionTesting::set_display(const bool& new_display)
00170 {
00171 display = new_display;
00172 }
00173
00174
00175
00176
00181
00182
00183 void PatternRecognitionTesting::set_default(void)
00184 {
00185 display = true;
00186 }
00187
00188
00189
00190
00193
00194 Matrix<bool> PatternRecognitionTesting::calculate_binary_target_data(void) const
00195 {
00196
00197
00198 #ifdef _DEBUG
00199
00200 if(!data_set_pointer)
00201 {
00202 std::ostringstream buffer;
00203
00204 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00205 << "Matrix<bool> get_binary_target_data(void) const method.\n"
00206 << "Data set is NULL.\n";
00207
00208 throw std::logic_error(buffer.str().c_str());
00209 }
00210
00211 #endif
00212
00213
00214
00215 const unsigned int instances_number = data_set_pointer->get_instances_number();
00216
00217 const VariablesInformation& variables_information = data_set_pointer->get_variables_information();
00218
00219 const unsigned int targets_number = variables_information.count_targets_number();
00220
00221 #ifdef _DEBUG
00222
00223 if(instances_number == 0)
00224 {
00225 std::ostringstream buffer;
00226
00227 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00228 << "Matrix<bool> get_binary_target_data(void) method."
00229 << "Number of instances must be greater than zero.";
00230
00231 throw std::logic_error(buffer.str().c_str());
00232 }
00233
00234 if(targets_number == 0)
00235 {
00236 std::ostringstream buffer;
00237
00238 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00239 << "Matrix<bool> get_binary_target_data(void) method.\n"
00240 << "Number of target variables must be greater than zero.\n";
00241
00242 throw std::logic_error(buffer.str().c_str());
00243 }
00244
00245 #endif
00246
00247
00248
00249
00250 Matrix<bool> target_data(instances_number, targets_number, false);
00251
00252 Vector<double> targets(targets_number);
00253
00254 if(targets_number == 1)
00255 {
00256 for(unsigned int i = 0; i < instances_number; i++)
00257 {
00258 targets = data_set_pointer->get_target_instance(i);
00259
00260 if(targets[0] > 0.5)
00261 {
00262 target_data[i][0] = true;
00263 }
00264 }
00265 }
00266 else if(targets_number > 1)
00267 {
00268 int winner_index;
00269
00270 for(unsigned int i = 0; i < instances_number; i++)
00271 {
00272 targets = data_set_pointer->get_target_instance(i);
00273
00274 winner_index = targets.calculate_maximal_index();
00275
00276 target_data[i][winner_index] = true;
00277 }
00278 }
00279
00280 return(target_data);
00281 }
00282
00283
00284
00285
00288
00289 Matrix<bool> PatternRecognitionTesting::calculate_binary_training_target_data(void) const
00290 {
00291
00292
00293 #ifdef _DEBUG
00294
00295 if(!data_set_pointer)
00296 {
00297 std::ostringstream buffer;
00298
00299 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00300 << "Matrix<bool> get_binary_training_target_data(void) const method.\n"
00301 << "Data set is NULL.\n";
00302
00303 throw std::logic_error(buffer.str().c_str());
00304 }
00305
00306 #endif
00307
00308
00309
00310 const VariablesInformation& variables_information = data_set_pointer->get_variables_information();
00311 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
00312
00313 const unsigned int training_instances_number = instances_information.count_training_instances_number();
00314
00315 const unsigned int targets_number = variables_information.count_targets_number();
00316
00317 #ifdef _DEBUG
00318
00319 if(training_instances_number == 0)
00320 {
00321 std::ostringstream buffer;
00322
00323 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00324 << "Matrix<bool> get_binary_training_target_data(void) method.\n"
00325 << "Number of training instances must be greater than zero.\n";
00326
00327 throw std::logic_error(buffer.str().c_str());
00328 }
00329
00330 if(targets_number == 0)
00331 {
00332 std::ostringstream buffer;
00333
00334 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00335 << "Matrix<bool> get_binary_training_target_data(void) method.\n"
00336 << "Number of target variables must be greater than zero.\n";
00337
00338 throw std::logic_error(buffer.str().c_str());
00339 }
00340
00341 #endif
00342
00343
00344
00345 Matrix<bool> training_target_data(training_instances_number, targets_number, false);
00346
00347 Vector<double> targets(targets_number);
00348
00349 if(targets_number == 1)
00350 {
00351 for(unsigned int i = 0; i < training_instances_number; i++)
00352 {
00353 targets = data_set_pointer->get_training_target_instance(i);
00354
00355 if(targets[0] > 0.5)
00356 {
00357 training_target_data[i][0] = true;
00358 }
00359 }
00360 }
00361 else if(targets_number > 1)
00362 {
00363 int winner_index;
00364
00365 for(unsigned int i = 0; i < training_instances_number; i++)
00366 {
00367 targets = data_set_pointer->get_training_target_instance(i);
00368
00369 winner_index = targets.calculate_maximal_index();
00370
00371 training_target_data[i][winner_index] = true;
00372 }
00373 }
00374
00375 return(training_target_data);
00376 }
00377
00378
00379
00380
00382
00383 Matrix<bool> PatternRecognitionTesting::calculate_binary_generalization_target_data(void) const
00384 {
00385
00386
00387 #ifdef _DEBUG
00388
00389 if(!data_set_pointer)
00390 {
00391 std::ostringstream buffer;
00392
00393 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00394 << "Matrix<bool> calculate_binary_generalization_target_data(void) const method.\n"
00395 << "Data set is NULL.\n";
00396
00397 throw std::logic_error(buffer.str().c_str());
00398 }
00399
00400 #endif
00401
00402
00403
00404 const VariablesInformation variables_information = data_set_pointer->get_variables_information();
00405 const InstancesInformation instances_information = data_set_pointer->get_instances_information();
00406
00407 const unsigned int generalization_instances_number = instances_information.count_generalization_instances_number();
00408
00409 const unsigned int targets_number = variables_information.count_targets_number();
00410
00411 #ifdef _DEBUG
00412
00413 if(generalization_instances_number == 0)
00414 {
00415 std::ostringstream buffer;
00416
00417 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00418 << "Matrix<bool> calculate_binary_generalization_target_data(void) const method.\n"
00419 << "Number of generalization instances must be greater than zero.\n";
00420
00421 throw std::logic_error(buffer.str().c_str());
00422 }
00423
00424 if(targets_number == 0)
00425 {
00426 std::ostringstream buffer;
00427
00428 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00429 << "Matrix<bool> calculate_binary_generalization_target_data(void) const method.\n"
00430 << "Number of target variables must be greater than zero.\n";
00431
00432 throw std::logic_error(buffer.str().c_str());
00433 }
00434
00435 #endif
00436
00437 Matrix<bool> generalization_target_data(generalization_instances_number, targets_number, false);
00438
00439 Vector<double> targets(targets_number);
00440
00441 if(targets_number == 1)
00442 {
00443 for(unsigned int i = 0; i < generalization_instances_number; i++)
00444 {
00445 targets = data_set_pointer->get_generalization_target_instance(i);
00446
00447 if(targets[0] > 0.5)
00448 {
00449 generalization_target_data[i][0] = true;
00450 }
00451 }
00452 }
00453 else if(targets_number > 1)
00454 {
00455 int winner_index;
00456
00457 for(unsigned int i = 0; i < generalization_instances_number; i++)
00458 {
00459 targets = data_set_pointer->get_generalization_target_instance(i);
00460
00461 winner_index = targets.calculate_maximal_index();
00462
00463 generalization_target_data[i][winner_index] = true;
00464 }
00465 }
00466
00467 return(generalization_target_data);
00468 }
00469
00470
00471
00472
00474
00475 Matrix<bool> PatternRecognitionTesting::calculate_binary_testing_target_data(void) const
00476 {
00477
00478
00479 #ifdef _DEBUG
00480
00481 std::ostringstream buffer;
00482
00483 if(!data_set_pointer)
00484 {
00485 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00486 << "Matrix<bool> calculate_binary_testing_target_data(void) const method.\n"
00487 << "Data set is NULL.\n";
00488
00489 throw std::logic_error(buffer.str().c_str());
00490 }
00491
00492 #endif
00493
00494
00495
00496 const VariablesInformation& variables_information = data_set_pointer->get_variables_information();
00497 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
00498
00499 const unsigned int testing_instances_number = instances_information.count_testing_instances_number();
00500
00501 const unsigned int targets_number = variables_information.count_targets_number();
00502
00503
00504
00505 #ifdef _DEBUG
00506
00507 if(testing_instances_number == 0)
00508 {
00509 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00510 << "Matrix<bool> calculate_binary_testing_target_data(void) const method.\n"
00511 << "Number of testing instances must be greater than zero.\n";
00512
00513 throw std::logic_error(buffer.str().c_str());
00514 }
00515
00516 if(targets_number == 0)
00517 {
00518 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00519 << "Matrix<bool> calculate_binary_testing_target_data(void) const method.\n"
00520 << "Number of target variables must be greater than zero.\n";
00521
00522 throw std::logic_error(buffer.str().c_str());
00523 }
00524
00525 #endif
00526
00527 Matrix<bool> testing_target_data(testing_instances_number, targets_number, false);
00528
00529 Vector<double> targets(targets_number);
00530
00531 if(targets_number == 1)
00532 {
00533 for(unsigned int i = 0; i < testing_instances_number; i++)
00534 {
00535 targets = data_set_pointer->get_testing_target_instance(i);
00536
00537 if(targets[0] > 0.5)
00538 {
00539 testing_target_data[i][0] = true;
00540 }
00541 }
00542 }
00543 else if(targets_number > 1)
00544 {
00545 int winner_index;
00546
00547 for(unsigned int i = 0; i < testing_instances_number; i++)
00548 {
00549 targets = data_set_pointer->get_testing_target_instance(i);
00550
00551 winner_index = targets.calculate_maximal_index();
00552
00553 testing_target_data[i][winner_index] = true;
00554 }
00555 }
00556
00557 return(testing_target_data);
00558 }
00559
00560
00561
00562
00564
00565 Matrix<bool> PatternRecognitionTesting::calculate_binary_output_data(void) const
00566 {
00567
00568
00569 #ifdef _DEBUG
00570
00571 std::ostringstream buffer;
00572
00573 if(!data_set_pointer)
00574 {
00575 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00576 << "Matrix<bool> calculate_binary_output_data(void) const method.\n"
00577 << "Data set is NULL.\n";
00578
00579 throw std::logic_error(buffer.str().c_str());
00580 }
00581
00582 #endif
00583
00584
00585
00586 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00587
00588 const unsigned int multilayer_perceptron_inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00589 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00590
00591 #ifdef _DEBUG
00592
00593 const VariablesInformation& variables_information = data_set_pointer->get_variables_information();
00594
00595 const unsigned int data_set_inputs_number = variables_information.count_inputs_number();
00596 const unsigned int targets_number = variables_information.count_targets_number();
00597
00598
00599
00600 if(multilayer_perceptron_inputs_number != data_set_inputs_number)
00601 {
00602 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00603 << "Matrix<bool> calculate_binary_output_data(void) const method.\n"
00604 << "Number of inputs in neural network is not equal to number of inputs in data set.\n";
00605
00606 throw std::logic_error(buffer.str().c_str());
00607 }
00608 else if(outputs_number != targets_number)
00609 {
00610 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00611 << "Matrix<bool> calculate_binary_output_data(void) const method.\n"
00612 << "Number of outputs in neural network is not equal to number of targets in data set.\n";
00613
00614 throw std::logic_error(buffer.str().c_str());
00615 }
00616
00617 #endif
00618
00619
00620
00621 const unsigned int instances_number = data_set_pointer->get_instances_number();
00622
00623 Matrix<bool> output_data(instances_number, outputs_number, false);
00624
00625 Vector<double> inputs(multilayer_perceptron_inputs_number);
00626 Vector<double> outputs(outputs_number);
00627
00628 if(outputs_number == 1)
00629 {
00630 for(unsigned int i = 0; i < instances_number; i++)
00631 {
00632 inputs = data_set_pointer->get_input_instance(i);
00633
00634 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00635
00636 if(outputs[0] > 0.5)
00637 {
00638 output_data[i][0] = true;
00639 }
00640 }
00641 }
00642 else
00643 {
00644 int winner_index;
00645
00646 for(unsigned int i = 0; i < instances_number; i++)
00647 {
00648 inputs = data_set_pointer->get_input_instance(i);
00649
00650 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00651
00652 winner_index = outputs.calculate_maximal_index();
00653
00654 output_data[i][winner_index] = true;
00655 }
00656 }
00657
00658 return(output_data);
00659 }
00660
00661
00662
00663
00665
00666 Matrix<bool> PatternRecognitionTesting::calculate_binary_training_output_data(void) const
00667 {
00668
00669
00670 #ifdef _DEBUG
00671
00672 if(!data_set_pointer)
00673 {
00674 std::ostringstream buffer;
00675
00676 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00677 << "Matrix<bool> calculate_binary_training_output_data(void) const method.\n"
00678 << "Data set is NULL.\n";
00679
00680 throw std::logic_error(buffer.str().c_str());
00681 }
00682
00683 #endif
00684
00685
00686
00687 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00688
00689 const unsigned int multilayer_perceptron_inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00690 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00691
00692
00693 #ifdef _DEBUG
00694
00695 const VariablesInformation& variables_information = data_set_pointer->get_variables_information();
00696
00697 const unsigned int data_set_inputs_number = variables_information.count_inputs_number();
00698 const unsigned int targets_number = variables_information.count_targets_number();
00699
00700
00701
00702 if(multilayer_perceptron_inputs_number != data_set_inputs_number)
00703 {
00704 std::ostringstream buffer;
00705
00706 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00707 << "Matrix<bool> calculate_binary_training_output_data(void) const method.\n"
00708 << "Number of inputs in neural network is not be equal to number of inputs in data set.\n";
00709
00710 throw std::logic_error(buffer.str().c_str());
00711 }
00712 else if(outputs_number != targets_number)
00713 {
00714 std::ostringstream buffer;
00715
00716 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00717 << "Matrix<bool> calculate_binary_output_data(void) const method.\n"
00718 << "Number of outputs in neural netwoek is not equal to number of targets in data set.\n";
00719
00720 throw std::logic_error(buffer.str().c_str());
00721 }
00722
00723 #endif
00724
00725 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
00726
00727 const unsigned int training_instances_number = instances_information.count_training_instances_number();
00728
00729
00730
00731 Matrix<bool> training_output_data(training_instances_number, outputs_number, false);
00732
00733 Vector<double> inputs(multilayer_perceptron_inputs_number);
00734 Vector<double> outputs(outputs_number);
00735
00736 if(outputs_number == 1)
00737 {
00738 for(unsigned int i = 0; i < training_instances_number; i++)
00739 {
00740 inputs = data_set_pointer->get_training_input_instance(i);
00741
00742 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00743
00744 if(outputs[0] > 0.5)
00745 {
00746 training_output_data[i][0] = true;
00747 }
00748 }
00749 }
00750 else
00751 {
00752 unsigned int winner_index;
00753
00754 for(unsigned int i = 0; i < training_instances_number; i++)
00755 {
00756 inputs = data_set_pointer->get_training_input_instance(i);
00757
00758 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00759
00760 winner_index = outputs.calculate_maximal_index();
00761
00762 training_output_data[i][winner_index] = true;
00763 }
00764 }
00765
00766 return(training_output_data);
00767 }
00768
00769
00770
00771
00772
00774
00775 Matrix<bool> PatternRecognitionTesting::calculate_binary_generalization_output_data(void) const
00776 {
00777
00778
00779 #ifdef _DEBUG
00780
00781 std::ostringstream buffer;
00782
00783 if(!data_set_pointer)
00784 {
00785 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00786 << "Matrix<bool> calculate_binary_generalization_output_data(void) const method.\n"
00787 << "Data set is NULL.\n";
00788
00789 throw std::logic_error(buffer.str().c_str());
00790 }
00791
00792 #endif
00793
00794 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00795
00796 const unsigned int multilayer_perceptron_inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00797 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00798
00799 #ifdef _DEBUG
00800
00801 const VariablesInformation& variables_information = data_set_pointer->get_variables_information();
00802
00803 const unsigned int data_set_inputs_number = variables_information.count_inputs_number();
00804 const unsigned int targets_number = variables_information.count_targets_number();
00805
00806
00807
00808 if(multilayer_perceptron_inputs_number != data_set_inputs_number)
00809 {
00810 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
00811 << "Matrix<bool> calculate_binary_generalization_output_data(void) const method." << std::endl
00812 << "Number of inputs in neural network is not equal to number of inputs in data set." << std::endl;
00813
00814 throw std::logic_error(buffer.str().c_str());
00815 }
00816 else if(outputs_number != targets_number)
00817 {
00818 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
00819 << "Matrix<bool> calculate_binary_generalization_output_data(void) const method." << std::endl
00820 << "Number of outputs in neural network is not equal to number of targets in data set." << std::endl;
00821
00822 throw std::logic_error(buffer.str().c_str());
00823 }
00824
00825 #endif
00826
00827
00828
00829 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
00830
00831 const unsigned int generalization_instances_number = instances_information.count_generalization_instances_number();
00832
00833 Matrix<bool> generalization_output_data(generalization_instances_number, outputs_number, false);
00834
00835 Vector<double> inputs(multilayer_perceptron_inputs_number);
00836 Vector<double> outputs(outputs_number);
00837
00838 if(outputs_number == 1)
00839 {
00840 for(unsigned int i = 0; i < generalization_instances_number; i++)
00841 {
00842 inputs = data_set_pointer->get_generalization_input_instance(i);
00843
00844 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00845
00846 if(outputs[0] > 0.5)
00847 {
00848 generalization_output_data[i][0] = true;
00849 }
00850 }
00851 }
00852 else
00853 {
00854 int winner_index;
00855
00856 for(unsigned int i = 0; i < generalization_instances_number; i++)
00857 {
00858 inputs = data_set_pointer->get_generalization_input_instance(i);
00859
00860 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00861
00862 winner_index = outputs.calculate_maximal_index();
00863
00864 generalization_output_data[i][winner_index] = true;
00865 }
00866 }
00867
00868 return(generalization_output_data);
00869 }
00870
00871
00872
00873
00876
00877 Matrix<bool> PatternRecognitionTesting::calculate_binary_testing_output_data(void) const
00878 {
00879
00880
00881 #ifdef _DEBUG
00882
00883 std::ostringstream buffer;
00884
00885 if(!data_set_pointer)
00886 {
00887 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
00888 << "Matrix<bool> calculate_binary_testing_output_data(void) const method." << std::endl
00889 << "Data set is NULL." << std::endl;
00890
00891 throw std::logic_error(buffer.str().c_str());
00892 }
00893
00894 #endif
00895
00896 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00897
00898 unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00899 unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00900
00901
00902 #ifdef _DEBUG
00903
00904 const VariablesInformation variables_information = data_set_pointer->get_variables_information();
00905
00906
00907
00908 if(inputs_number != variables_information.count_inputs_number())
00909 {
00910 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
00911 << "Matrix<bool> calculate_binary_testing_output_data(void) const method." << std::endl
00912 << "Number of inputs in neural network is not equal to number of inputs in testing data set." << std::endl;
00913
00914 throw std::logic_error(buffer.str().c_str());
00915 }
00916
00917 if(outputs_number != variables_information.count_targets_number())
00918 {
00919 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
00920 << "Matrix<bool> calculate_binary_testing_output_data(void) const method." << std::endl
00921 << "Number of outputs in neural network is not equal to number of targets in data set." << std::endl;
00922
00923 throw std::logic_error(buffer.str().c_str());
00924 }
00925
00926 #endif
00927
00928 const InstancesInformation instances_information = data_set_pointer->get_instances_information();
00929
00930 const unsigned int testing_instances_number = instances_information.count_testing_instances_number();
00931
00932
00933
00934 Matrix<bool> testing_output_data(testing_instances_number, outputs_number, false);
00935
00936 Vector<double> inputs(inputs_number);
00937 Vector<double> outputs(outputs_number);
00938
00939 if(outputs_number == 1)
00940 {
00941 for(unsigned int i = 0; i < testing_instances_number; i++)
00942 {
00943 inputs = data_set_pointer->get_testing_input_instance(i);
00944
00945 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00946
00947 if(outputs[0] > 0.5)
00948 {
00949 testing_output_data[i][0] = true;
00950 }
00951 }
00952 }
00953 else
00954 {
00955 int winner_index;
00956
00957 for(unsigned int i = 0; i < testing_instances_number; i++)
00958 {
00959 inputs = data_set_pointer->get_testing_input_instance(i);
00960
00961 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00962
00963 winner_index = outputs.calculate_maximal_index();
00964
00965 testing_output_data[i][winner_index] = true;
00966 }
00967 }
00968
00969 return(testing_output_data);
00970 }
00971
00972
00973
00974
00975
00977
00978 Matrix<unsigned int> PatternRecognitionTesting::calculate_confusion(void) const
00979 {
00980 #ifdef _DEBUG
00981
00982 std::ostringstream buffer;
00983
00984 if(!neural_network_pointer)
00985 {
00986 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
00987 << "Matrix<unsigned int> calculate_confusion(void) const method.\n"
00988 << "Pointer to neural network is NULL.\n";
00989
00990 throw std::logic_error(buffer.str().c_str());
00991 }
00992
00993 #endif
00994
00995 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00996
00997 #ifdef _DEBUG
00998
00999 if(!multilayer_perceptron_pointer)
01000 {
01001 buffer << "OpenNN Exception: PatternRecognitionTesting class.\n"
01002 << "Matrix<unsigned int> calculate_confusion(void) const method.\n"
01003 << "Pointer to multilayer perceptron in neural network is NULL.\n";
01004
01005 throw std::logic_error(buffer.str().c_str());
01006 }
01007
01008 #endif
01009
01010 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
01011
01012 #ifdef _DEBUG
01013
01014 if(!data_set_pointer)
01015 {
01016 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
01017 << "Matrix<unsigned int> calculate_confusion(void) const method." << std::endl
01018 << "Pointer to data set is NULL." << std::endl;
01019
01020 throw std::logic_error(buffer.str().c_str());
01021 }
01022
01023 #endif
01024
01025 #ifdef _DEBUG
01026
01027 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
01028
01029
01030
01031 const VariablesInformation& variables_information = data_set_pointer->get_variables_information();
01032
01033
01034 if(inputs_number != variables_information.count_inputs_number())
01035 {
01036 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
01037 << "Matrix<unsigned int> calculate_confusion(void) method." << std::endl
01038 << "Number of inputs in neural network must be equal to number of inputs in data set." << std::endl;
01039
01040 throw std::logic_error(buffer.str().c_str());
01041 }
01042
01043 if(outputs_number != variables_information.count_targets_number())
01044 {
01045 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
01046 << "Matrix<unsigned int> calculate_confusion(void) method." << std::endl
01047 << "Number of outputs in neural network must be equal to number of targets in data set." << std::endl;
01048
01049 throw std::logic_error(buffer.str().c_str());
01050 }
01051
01052 #endif
01053
01054 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
01055
01056 const unsigned int testing_instances_number = instances_information.count_testing_instances_number();
01057
01058 const Matrix<bool> binary_testing_target_data = calculate_binary_testing_target_data();
01059 const Matrix<bool> binary_testing_output_data = calculate_binary_testing_output_data();
01060
01061 if(outputs_number == 1)
01062 {
01063 Matrix<unsigned int> confusion(2, 2);
01064 unsigned int true_positive = 0;
01065 unsigned int false_positive = 0;
01066 unsigned int false_negative = 0;
01067 unsigned int true_negative = 0;
01068
01069 for(unsigned int i = 0; i < testing_instances_number; i++)
01070 {
01071 if(binary_testing_output_data[0][i] == true && binary_testing_target_data[0][i] == true)
01072 {
01073 true_positive++;
01074 }
01075 else if(binary_testing_output_data[0][i] == true && binary_testing_target_data[0][i] == false)
01076 {
01077 false_positive++;
01078 }
01079 else if(binary_testing_output_data[0][i] == false && binary_testing_target_data[0][i] == true)
01080 {
01081 false_negative++;
01082 }
01083 else if(binary_testing_output_data[0][i] == false && binary_testing_target_data[0][i] == false)
01084 {
01085 true_negative++;
01086 }
01087 else
01088 {
01089 std::ostringstream buffer;
01090
01091 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
01092 << "Matrix<unsigned int> calculate_confusion(void) method." << std::endl
01093 << "Unknown condition." << std::endl;
01094
01095 throw std::logic_error(buffer.str().c_str());
01096 }
01097
01098 confusion[0][0] = true_positive;
01099 confusion[0][1] = false_positive;
01100 confusion[1][0] = false_negative;
01101 confusion[1][1] = true_negative;
01102 }
01103
01104 return(confusion);
01105 }
01106 else
01107 {
01108 Matrix<unsigned int> confusion(outputs_number, outputs_number, 0);
01109
01110 unsigned int predicted_class = 0;
01111 unsigned int actual_class = 0;
01112
01113 for(unsigned int i = 0; i < testing_instances_number; i++)
01114 {
01115 for(unsigned int j = 0; j < outputs_number; j++)
01116 {
01117 if(binary_testing_output_data[i][j] == true)
01118 {
01119 predicted_class = j;
01120 }
01121 if(binary_testing_target_data[i][j] == true)
01122 {
01123 actual_class = j;
01124 }
01125 }
01126
01127 confusion[predicted_class][actual_class] += 1;
01128 }
01129
01130 return(confusion);
01131 }
01132 }
01133
01134
01135
01136
01148
01149 Vector<double> PatternRecognitionTesting::calculate_binary_classification_test(void) const
01150 {
01151
01152
01153 #ifdef _DEBUG
01154
01155 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
01156
01157 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
01158
01159 if(!data_set_pointer)
01160 {
01161 std::ostringstream buffer;
01162
01163 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
01164 << "Vector<double> calculate_binary_classification_test(void) const." << std::endl
01165 << "Data set is NULL." << std::endl;
01166
01167 throw std::logic_error(buffer.str().c_str());
01168 }
01169
01170 const VariablesInformation& variables_information = data_set_pointer->get_variables_information();
01171
01172 const unsigned int targets_number = variables_information.count_targets_number();
01173
01174 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
01175
01176
01177
01178 if(inputs_number != variables_information.count_inputs_number())
01179 {
01180 std::ostringstream buffer;
01181
01182 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
01183 << "Vector<double> calculate_binary_classification_test(void) const." << std::endl
01184 << "Number of inputs in neural network is not equal to number of inputs in data set." << std::endl;
01185
01186 throw std::logic_error(buffer.str().c_str());
01187 }
01188 else if(outputs_number != 1)
01189 {
01190 std::ostringstream buffer;
01191
01192 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
01193 << "Vector<double> calculate_binary_classification_test(void) const." << std::endl
01194 << "Number of outputs in neural network must be one." << std::endl;
01195
01196 throw std::logic_error(buffer.str().c_str());
01197 }
01198 else if(targets_number != 1)
01199 {
01200 std::ostringstream buffer;
01201
01202 buffer << "OpenNN Exception: PatternRecognitionTesting class." << std::endl
01203 << "Vector<double> calculate_binary_classification_test(void) const." << std::endl
01204 << "Number of targets in data set must be one." << std::endl;
01205
01206 throw std::logic_error(buffer.str().c_str());
01207 }
01208
01209 #endif
01210
01211
01212
01213 const Matrix<unsigned int> confusion = calculate_confusion();
01214
01215 const unsigned int true_positive = confusion[0][0];
01216 const unsigned int false_positive = confusion[0][1];
01217 const unsigned int false_negative = confusion[1][0];
01218 const unsigned int true_negative = confusion[1][1];
01219
01220
01221
01222 const double classification_accuracy = (double)(true_positive + true_negative)/double(true_positive + true_negative + false_positive + false_negative);
01223
01224
01225
01226 const double error_rate = (double)(false_positive + false_negative)/(double)(true_positive + true_negative + false_positive + false_negative);
01227
01228
01229
01230 const double sensitivity = (double)true_positive/(double)(true_positive + false_negative);
01231
01232
01233
01234 const double specifity = (double)true_negative/(double)(true_negative + false_positive);
01235
01236
01237
01238 const double positive_likelihood = sensitivity/(1.0 - specifity);
01239
01240
01241
01242 const double negative_likelihood = specifity/(1.0 - sensitivity);
01243
01244 Vector<double> binary_classification_test(6);
01245 binary_classification_test[0] = classification_accuracy;
01246 binary_classification_test[1] = error_rate;
01247 binary_classification_test[2] = sensitivity;
01248 binary_classification_test[3] = specifity;
01249 binary_classification_test[4] = positive_likelihood;
01250 binary_classification_test[5] = negative_likelihood;
01251
01252 return(binary_classification_test);
01253 }
01254
01255
01256
01257
01260
01261 void PatternRecognitionTesting::save_binary_classification_test(const std::string& filename) const
01262 {
01263 std::ofstream file(filename.c_str());
01264
01265 if(!file.is_open())
01266 {
01267 std::ostringstream buffer;
01268
01269 buffer << "OpenNN Exception: Matrix template." << std::endl
01270 << "void save_binary_classification_test(const std::string&) const method." << std::endl
01271 << "Cannot open binary classification test data file." << std::endl;
01272
01273 throw std::logic_error(buffer.str());
01274 }
01275
01276 const Vector<double> binary_classification_test = calculate_binary_classification_test();
01277
01278 file << "Binary classification test\n"
01279 << "Classification accuracy: " << binary_classification_test[0] << "\n"
01280 << "Error rate: " << binary_classification_test[1] << "\n"
01281 << "Sensitivity: " << binary_classification_test[2] << "\n"
01282 << "Specifity: " << binary_classification_test[3] << "\n"
01283 << "Positive likelihood: " << binary_classification_test[4] << "\n"
01284 << "Negative likelihood: " << binary_classification_test[5] << std::endl;
01285
01286 file.close();
01287 }
01288
01289
01290
01291
01294
01295 void PatternRecognitionTesting::save_confusion(const std::string& filename) const
01296 {
01297 std::ofstream file(filename.c_str());
01298
01299 if(!file.is_open())
01300 {
01301 std::ostringstream buffer;
01302
01303 buffer << "OpenNN Exception: Matrix template." << std::endl
01304 << "void save_confusion(const std::string&) const method." << std::endl
01305 << "Cannot open confusion data file." << std::endl;
01306
01307 throw std::logic_error(buffer.str());
01308 }
01309
01310 const Matrix<unsigned int> confusion = calculate_confusion();
01311
01312 file << "Confusion\n"
01313 << confusion;
01314
01315 file.close();
01316 }
01317
01318
01319
01321
01322 std::string PatternRecognitionTesting::to_string(void) const
01323 {
01324 std::ostringstream buffer;
01325
01326 buffer << "Pattern recognition testing\n"
01327 << "Display: " << display << "\n";
01328
01329 return(buffer.str());
01330 }
01331
01332
01333
01334
01338
01339 TiXmlElement* PatternRecognitionTesting::to_XML(void) const
01340 {
01341 return(NULL);
01342 }
01343
01344
01345
01346
01348
01349 void PatternRecognitionTesting::from_XML(TiXmlElement*)
01350 {
01351 }
01352
01353
01354 }
01355
01356
01357
01358
01359
01360
01361
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372
01373