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 #include <ctime>
00024
00025
00026
00027
00028 #include "../performance_functional/performance_functional.h"
00029
00030 #include "model_selection.h"
00031
00032 namespace OpenNN
00033 {
00034
00035
00036
00038
00039 ModelSelection::ModelSelection(void)
00040 : training_strategy_pointer(NULL)
00041 {
00042 set_default();
00043 }
00044
00045
00046
00047
00050
00051 ModelSelection::ModelSelection(TrainingStrategy* new_training_strategy_pointer)
00052 : training_strategy_pointer(new_training_strategy_pointer)
00053 {
00054 set_default();
00055 }
00056
00057
00058
00059
00062
00063 ModelSelection::ModelSelection(const std::string& filename)
00064 : training_strategy_pointer(NULL)
00065 {
00066 load(filename);
00067 }
00068
00069
00070
00071
00073
00074 ModelSelection::~ModelSelection(void)
00075 {
00076 }
00077
00078
00079
00080
00081
00082
00084
00085 TrainingStrategy* ModelSelection::get_training_strategy_pointer(void) const
00086 {
00087 return(training_strategy_pointer);
00088 }
00089
00090
00091
00092
00094
00095 const Vector<unsigned int>& ModelSelection::get_hidden_perceptrons_numbers(void) const
00096 {
00097 return(hidden_perceptrons_numbers);
00098 }
00099
00100
00101
00102
00104
00105 const unsigned int& ModelSelection::get_parameters_assays_number(void) const
00106 {
00107 return(parameters_assays_number);
00108 }
00109
00110
00111
00112
00114
00115 const bool& ModelSelection::get_reserve_parameters_data(void)
00116 {
00117 return(reserve_parameters_data);
00118 }
00119
00120
00121
00122
00124
00125 const bool& ModelSelection::get_reserve_evaluation_data(void)
00126 {
00127 return(reserve_evaluation_data);
00128 }
00129
00130
00131
00132
00134
00135 const bool& ModelSelection::get_reserve_generalization_evaluation_data(void)
00136 {
00137 return(reserve_generalization_evaluation_data);
00138 }
00139
00140
00141
00142
00144
00145 const bool& ModelSelection::get_reserve_minimal_parameters(void)
00146 {
00147 return(reserve_minimal_parameters);
00148 }
00149
00150
00151
00152
00154
00155 const bool& ModelSelection::get_reserve_evaluation_data_statistics(void)
00156 {
00157 return(reserve_evaluation_data_statistics);
00158 }
00159
00160
00161
00162
00164
00165 const bool& ModelSelection::get_reserve_generalization_evaluation_data_statistics(void)
00166 {
00167 return(reserve_generalization_evaluation_data_statistics);
00168 }
00169
00170
00171
00172
00174
00175 const bool& ModelSelection::get_reserve_model_order_selection_plot(void)
00176 {
00177 return(reserve_model_order_selection_plot);
00178 }
00179
00180
00181
00182
00185
00186 const bool& ModelSelection::get_display(void) const
00187 {
00188 return(display);
00189 }
00190
00191
00192
00193
00196
00197 void ModelSelection::set_training_strategy_pointer(TrainingStrategy* new_training_strategy_pointer)
00198 {
00199 training_strategy_pointer = new_training_strategy_pointer;
00200 }
00201
00202
00203
00204
00206
00207 void ModelSelection::set_default(void)
00208 {
00209
00210
00211 display = true;
00212 }
00213
00214
00215
00216
00219
00220 void ModelSelection::set_hidden_perceptrons_numbers(const Vector<unsigned int>& new_hidden_perceptrons_numbers)
00221 {
00222 hidden_perceptrons_numbers = new_hidden_perceptrons_numbers;
00223 }
00224
00225
00226
00227
00230
00231 void ModelSelection::set_parameters_assays_number(const unsigned int& new_parameters_assays_number)
00232 {
00233 parameters_assays_number = new_parameters_assays_number;
00234 }
00235
00236
00237
00238
00242
00243 void ModelSelection::set_assays_numbers(const unsigned int& new_complexity_assays_number, const unsigned int& new_parameters_assays_number)
00244 {
00245
00246
00247 #ifdef _DEBUG
00248
00249 if(!training_strategy_pointer)
00250 {
00251 std::ostringstream buffer;
00252
00253 buffer << "OpenNN Exception: ModelSelection class.\n"
00254 << "void set_assays_numbers(const unsigned int&, const unsigned int&) method.\n"
00255 << "Pointer to training strategy is NULL.\n";
00256
00257 throw std::logic_error(buffer.str().c_str());
00258 }
00259
00260 if(training_strategy_pointer->get_performance_functional_pointer() == NULL)
00261 {
00262 std::ostringstream buffer;
00263
00264 buffer << "OpenNN Exception: ModelSelection class.\n"
00265 << "void set_assays_numbers(const unsigned int&, const unsigned int&) method.\n"
00266 << "Pointer to performance functional is NULL.\n";
00267
00268 throw std::logic_error(buffer.str().c_str());
00269 }
00270
00271 if(training_strategy_pointer->get_performance_functional_pointer()->get_neural_network_pointer() == NULL)
00272 {
00273 std::ostringstream buffer;
00274
00275 buffer << "OpenNN Exception: ModelSelection class.\n"
00276 << "void set_assays_numbers(const unsigned int&, const unsigned int&) method.\n"
00277 << "Pointer to multilayer perceptron is NULL.\n";
00278
00279 throw std::logic_error(buffer.str().c_str());
00280 }
00281
00282 #endif
00283
00284 hidden_perceptrons_numbers.set(new_complexity_assays_number);
00285
00286
00287
00288
00289
00290
00291
00292
00293 unsigned int minimum_hidden_layer_size = 1;
00294 unsigned int maximum_hidden_layer_size = 12;
00295
00296 int hidden_layer_size_increment = (maximum_hidden_layer_size-minimum_hidden_layer_size)/new_complexity_assays_number;
00297
00298 if(hidden_layer_size_increment < 1)
00299 {
00300 hidden_layer_size_increment = 1;
00301 }
00302
00303 for(unsigned int i = 0; i < new_complexity_assays_number; i++)
00304 {
00305 hidden_perceptrons_numbers[i] = minimum_hidden_layer_size + hidden_layer_size_increment*i;
00306 }
00307
00308 parameters_assays_number = new_parameters_assays_number;
00309 }
00310
00311
00312
00313
00316
00317 void ModelSelection::set_reserve_parameters_data(const bool& new_reserve_parameters_data)
00318 {
00319 reserve_parameters_data = new_reserve_parameters_data;
00320 }
00321
00322
00323
00324
00327
00328 void ModelSelection::set_reserve_evaluation_data(const bool& new_reserve_evaluation_data)
00329 {
00330 reserve_evaluation_data = new_reserve_evaluation_data;
00331 }
00332
00333
00334
00335
00338
00339 void ModelSelection::set_reserve_generalization_evaluation_data(const bool& new_reserve_generalization_evaluation_data)
00340 {
00341 reserve_generalization_evaluation_data = new_reserve_generalization_evaluation_data;
00342 }
00343
00344
00345
00346
00349
00350 void ModelSelection::set_reserve_minimal_parameters(const bool& new_reserve_minimal_parameters)
00351 {
00352 reserve_minimal_parameters = new_reserve_minimal_parameters;
00353 }
00354
00355
00356
00357
00360
00361 void ModelSelection::set_reserve_evaluation_data_statistics(const bool& new_reserve_evaluation_data_statistics)
00362 {
00363 reserve_evaluation_data_statistics = new_reserve_evaluation_data_statistics;
00364 }
00365
00366
00367
00368
00371
00372 void ModelSelection::set_reserve_generalization_evaluation_data_statistics(const bool& new_reserve_generalization_evaluation_data_statistics)
00373 {
00374 reserve_generalization_evaluation_data_statistics = new_reserve_generalization_evaluation_data_statistics;
00375 }
00376
00377
00378
00379
00382
00383 void ModelSelection::set_reserve_model_order_selection_plot(const bool& new_reserve_model_order_selection_plot)
00384 {
00385 reserve_model_order_selection_plot = new_reserve_model_order_selection_plot;
00386 }
00387
00388
00389
00390
00395
00396 void ModelSelection::set_display(const bool& new_display)
00397 {
00398 display = new_display;
00399 }
00400
00401
00402
00403
00405
00406 void ModelSelection::check(void) const
00407 {
00408
00409
00410 std::ostringstream buffer;
00411
00412 if(!training_strategy_pointer)
00413 {
00414 buffer << "OpenNN Exception: ModelSelection class.\n"
00415 << "void check(void) const method.\n"
00416 << "Pointer to training strategy is NULL.\n";
00417
00418 throw std::logic_error(buffer.str().c_str());
00419 }
00420
00421
00422
00423 const PerformanceFunctional* performance_functional_pointer = training_strategy_pointer->get_performance_functional_pointer();
00424
00425 if(!performance_functional_pointer)
00426 {
00427 buffer << "OpenNN Exception: ModelSelection class.\n"
00428 << "void check(void) const method.\n"
00429 << "Pointer to performance functional is NULL.\n";
00430
00431 throw std::logic_error(buffer.str().c_str());
00432 }
00433
00434
00435
00436 const NeuralNetwork* neural_network_pointer = performance_functional_pointer->get_neural_network_pointer();
00437
00438 if(!neural_network_pointer)
00439 {
00440 buffer << "OpenNN Exception: ModelSelection class.\n"
00441 << "void check(void) const method.\n"
00442 << "Pointer to neural network is NULL.\n";
00443
00444 throw std::logic_error(buffer.str().c_str());
00445 }
00446
00447 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00448
00449 if(!multilayer_perceptron_pointer)
00450 {
00451 buffer << "OpenNN Exception: ModelSelection class.\n"
00452 << "void check(void) const method.\n"
00453 << "Pointer to multilayer perceptron is NULL.\n";
00454
00455 throw std::logic_error(buffer.str().c_str());
00456 }
00457
00458 }
00459
00460
00461
00462
00464
00465 ModelSelection::ModelSelectionResults ModelSelection::perform_model_inputs_selection(void) const
00466 {
00467 std::ostringstream buffer;
00468
00469 buffer << "OpenNN Exception: ModelSelection class.\n"
00470 << "ModelSelectionResults perform_model_inputs_selection(void) const method.\n"
00471 << "This method is under development.\n";
00472
00473 throw std::logic_error(buffer.str().c_str());
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580 }
00581
00582
00583
00584
00586
00587 ModelSelection::ModelSelectionResults ModelSelection::perform_model_order_selection(void) const
00588 {
00589 std::ostringstream buffer;
00590
00591 buffer << "OpenNN Exception: ModelSelection class.\n"
00592 << "ModelSelectionResults perform_model_order_selection(void) method.\n"
00593 << "This method is under development.\n";
00594
00595 throw std::logic_error(buffer.str().c_str());
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
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
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774 }
00775
00776
00777
00778
00780
00781 ModelSelection::ModelSelectionResults ModelSelection::perform_model_selection(void) const
00782 {
00783 std::ostringstream buffer;
00784
00785 buffer << "OpenNN Exception: ModelSelection class.\n"
00786 << "ModelSelectionResults perform_model_selection(void) method.\n"
00787 << "This method is under development.\n";
00788
00789 throw std::logic_error(buffer.str().c_str());
00790
00791
00792
00793
00794 }
00795
00796
00797
00798
00801
00802 TiXmlElement* ModelSelection::to_XML(void) const
00803 {
00804 std::ostringstream buffer;
00805
00806
00807
00808 TiXmlElement* model_order_selection_element = new TiXmlElement("ModelSelection");
00809 model_order_selection_element->SetAttribute("Version", 4);
00810
00811
00812
00813 TiXmlElement* hidden_perceptrons_numbers_element = new TiXmlElement("HiddenLayerSizes");
00814 model_order_selection_element->LinkEndChild(hidden_perceptrons_numbers_element);
00815
00816 buffer.str("");
00817 buffer << hidden_perceptrons_numbers;
00818
00819 TiXmlText* hidden_perceptrons_numbers_text = new TiXmlText(buffer.str().c_str());
00820 hidden_perceptrons_numbers_element->LinkEndChild(hidden_perceptrons_numbers_text);
00821
00822
00823
00824 TiXmlElement* parameters_assays_number_element = new TiXmlElement("ParametersAssaysNumber");
00825 model_order_selection_element->LinkEndChild(parameters_assays_number_element);
00826
00827 buffer.str("");
00828 buffer << parameters_assays_number;
00829
00830 TiXmlText* parameters_assays_number_text = new TiXmlText(buffer.str().c_str());
00831 parameters_assays_number_element->LinkEndChild(parameters_assays_number_text);
00832
00833 return(model_order_selection_element);
00834 }
00835
00836
00837
00838
00840
00841 void ModelSelection::from_XML(TiXmlElement*)
00842 {
00843 }
00844
00845
00846
00847
00849
00850 void ModelSelection::print(void) const
00851 {
00852 std::cout << to_XML();
00853 }
00854
00855
00856
00857
00860
00861 void ModelSelection::save(const std::string& filename) const
00862 {
00863 TiXmlDocument document;
00864
00865
00866
00867 TiXmlDeclaration* declaration = new TiXmlDeclaration("1.0", "", "");
00868 document.LinkEndChild(declaration);
00869
00870
00871
00872 TiXmlElement* model_selection_element = to_XML();
00873 document.LinkEndChild(model_selection_element);
00874
00875
00876
00877 document.SaveFile(filename.c_str());
00878 }
00879
00880
00881
00882
00885
00886 void ModelSelection::load(const std::string& filename)
00887 {
00888 std::ostringstream buffer;
00889
00890 TiXmlDocument document(filename.c_str());
00891
00892 if (!document.LoadFile())
00893 {
00894 buffer << "OpenNN Exception: ModelSelection class.\n"
00895 << "void load(const std::string&) method.\n"
00896 << "Cannot load XML file " << filename << ".\n";
00897
00898 throw std::logic_error(buffer.str());
00899 }
00900
00901
00902
00903 TiXmlElement* model_order_selection_element = document.FirstChildElement("ModelSelection");
00904
00905 if(!model_order_selection_element)
00906 {
00907 buffer << "OpenNN Exception: ModelSelection class.\n"
00908 << "void load(const std::string&) method.\n"
00909 << "Invalid model order selection XML root element.\n";
00910
00911 throw std::logic_error(buffer.str());
00912 }
00913
00914
00915
00916 TiXmlElement* hidden_perceptrons_numbers_element = model_order_selection_element->FirstChildElement("HiddenLayerSizes");
00917
00918 if(hidden_perceptrons_numbers_element)
00919 {
00920 Vector<unsigned int> new_hidden_perceptrons_numbers;
00921 new_hidden_perceptrons_numbers.parse(hidden_perceptrons_numbers_element->GetText());
00922
00923 try
00924 {
00925 set_hidden_perceptrons_numbers(new_hidden_perceptrons_numbers);
00926 }
00927 catch(std::exception& e)
00928 {
00929 std::cout << e.what() << std::endl;
00930 }
00931 }
00932
00933
00934
00935 TiXmlElement* parameters_assays_number_element = model_order_selection_element->FirstChildElement("ParametersAssaysNumber");
00936
00937 if(parameters_assays_number_element)
00938 {
00939 parameters_assays_number = atoi(parameters_assays_number_element->GetText());
00940 }
00941 }
00942
00943 }
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960