00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include <cmath>
00019 #include <cstdlib>
00020 #include <fstream>
00021 #include <iostream>
00022 #include <string>
00023 #include <sstream>
00024
00025
00026
00027 #include "neural_network.h"
00028
00029
00030
00031 #include "../../parsers/tinyxml/tinyxml.h"
00032
00033 namespace OpenNN
00034 {
00035
00036
00037
00042
00043 NeuralNetwork::NeuralNetwork(void)
00044 : multilayer_perceptron_pointer(NULL)
00045 , scaling_layer_pointer(NULL)
00046 , unscaling_layer_pointer(NULL)
00047 , bounding_layer_pointer(NULL)
00048 , probabilistic_layer_pointer(NULL)
00049 , conditions_layer_pointer(NULL)
00050 , inputs_outputs_information_pointer(NULL)
00051 , independent_parameters_pointer(NULL)
00052 {
00053 set_default();
00054 }
00055
00056
00057
00058
00063
00064 NeuralNetwork::NeuralNetwork(const MultilayerPerceptron& new_multilayer_perceptron)
00065 : multilayer_perceptron_pointer(NULL)
00066 , scaling_layer_pointer(NULL)
00067 , unscaling_layer_pointer(NULL)
00068 , bounding_layer_pointer(NULL)
00069 , probabilistic_layer_pointer(NULL)
00070 , conditions_layer_pointer(NULL)
00071 , inputs_outputs_information_pointer(NULL)
00072 , independent_parameters_pointer(NULL)
00073 {
00074 multilayer_perceptron_pointer = new MultilayerPerceptron(new_multilayer_perceptron);
00075
00076 set_default();
00077 }
00078
00079
00080
00081
00088
00089 NeuralNetwork::NeuralNetwork(const Vector<unsigned int>& new_multilayer_perceptron_architecture)
00090 : multilayer_perceptron_pointer(NULL)
00091 , scaling_layer_pointer(NULL)
00092 , unscaling_layer_pointer(NULL)
00093 , bounding_layer_pointer(NULL)
00094 , probabilistic_layer_pointer(NULL)
00095 , conditions_layer_pointer(NULL)
00096 , inputs_outputs_information_pointer(NULL)
00097 , independent_parameters_pointer(NULL)
00098 {
00099 multilayer_perceptron_pointer = new MultilayerPerceptron(new_multilayer_perceptron_architecture);
00100
00101 set(new_multilayer_perceptron_architecture);
00102 }
00103
00104
00105
00106
00113
00114 NeuralNetwork::NeuralNetwork(const unsigned int& new_inputs_number, const unsigned int& new_perceptrons_number)
00115 : multilayer_perceptron_pointer(NULL)
00116 , scaling_layer_pointer(NULL)
00117 , unscaling_layer_pointer(NULL)
00118 , bounding_layer_pointer(NULL)
00119 , probabilistic_layer_pointer(NULL)
00120 , conditions_layer_pointer(NULL)
00121 , inputs_outputs_information_pointer(NULL)
00122 , independent_parameters_pointer(NULL)
00123 {
00124 multilayer_perceptron_pointer = new MultilayerPerceptron(new_inputs_number, new_perceptrons_number);
00125
00126 set_default();
00127 }
00128
00129
00130
00131
00139
00140 NeuralNetwork::NeuralNetwork(const unsigned int& new_inputs_number, const unsigned int& new_hidden_perceptrons_number, const unsigned int& new_output_perceptrons_number)
00141 : multilayer_perceptron_pointer(NULL)
00142 , scaling_layer_pointer(NULL)
00143 , unscaling_layer_pointer(NULL)
00144 , bounding_layer_pointer(NULL)
00145 , probabilistic_layer_pointer(NULL)
00146 , conditions_layer_pointer(NULL)
00147 , inputs_outputs_information_pointer(NULL)
00148 , independent_parameters_pointer(NULL)
00149 {
00150 multilayer_perceptron_pointer = new MultilayerPerceptron(new_inputs_number, new_hidden_perceptrons_number, new_output_perceptrons_number);
00151
00152 set_default();
00153 }
00154
00155
00156
00157
00162
00163 NeuralNetwork::NeuralNetwork(const unsigned int& new_independent_parameters_number)
00164 : multilayer_perceptron_pointer(NULL)
00165 , scaling_layer_pointer(NULL)
00166 , unscaling_layer_pointer(NULL)
00167 , bounding_layer_pointer(NULL)
00168 , probabilistic_layer_pointer(NULL)
00169 , conditions_layer_pointer(NULL)
00170 , inputs_outputs_information_pointer(NULL)
00171 , independent_parameters_pointer(NULL)
00172 {
00173 independent_parameters_pointer = new IndependentParameters(new_independent_parameters_number);
00174
00175 set_default();
00176 }
00177
00178
00179
00180
00185
00186 NeuralNetwork::NeuralNetwork(const std::string& filename)
00187 : multilayer_perceptron_pointer(NULL)
00188 , scaling_layer_pointer(NULL)
00189 , unscaling_layer_pointer(NULL)
00190 , bounding_layer_pointer(NULL)
00191 , probabilistic_layer_pointer(NULL)
00192 , conditions_layer_pointer(NULL)
00193 , inputs_outputs_information_pointer(NULL)
00194 , independent_parameters_pointer(NULL)
00195 {
00196 load(filename);
00197 }
00198
00199
00200
00201
00205
00206 NeuralNetwork::NeuralNetwork(const NeuralNetwork& other_neural_network)
00207 : multilayer_perceptron_pointer(NULL)
00208 , scaling_layer_pointer(NULL)
00209 , unscaling_layer_pointer(NULL)
00210 , bounding_layer_pointer(NULL)
00211 , probabilistic_layer_pointer(NULL)
00212 , conditions_layer_pointer(NULL)
00213 , inputs_outputs_information_pointer(NULL)
00214 , independent_parameters_pointer(NULL)
00215 {
00216 set(other_neural_network);
00217 }
00218
00219
00220
00221
00223
00224 NeuralNetwork::~NeuralNetwork(void)
00225 {
00226 delete multilayer_perceptron_pointer;
00227 delete scaling_layer_pointer;
00228 delete unscaling_layer_pointer;
00229 delete bounding_layer_pointer;
00230 delete probabilistic_layer_pointer;
00231 delete conditions_layer_pointer;
00232 delete inputs_outputs_information_pointer;
00233 delete independent_parameters_pointer;
00234 }
00235
00236
00237
00238
00242
00243 NeuralNetwork& NeuralNetwork::operator = (const NeuralNetwork& other_neural_network)
00244 {
00245 if(this != &other_neural_network)
00246 {
00247 delete_pointers();
00248
00249 multilayer_perceptron_pointer = new MultilayerPerceptron(*other_neural_network.multilayer_perceptron_pointer);
00250
00251 scaling_layer_pointer = new ScalingLayer(*other_neural_network.scaling_layer_pointer);
00252
00253 unscaling_layer_pointer = new UnscalingLayer(*other_neural_network.unscaling_layer_pointer);
00254
00255 bounding_layer_pointer = new BoundingLayer(*other_neural_network.bounding_layer_pointer);
00256
00257 probabilistic_layer_pointer = new ProbabilisticLayer(*other_neural_network.probabilistic_layer_pointer);
00258
00259 conditions_layer_pointer = new ConditionsLayer(*other_neural_network.conditions_layer_pointer);
00260
00261 independent_parameters_pointer = new IndependentParameters(*other_neural_network.independent_parameters_pointer);
00262
00263 multilayer_perceptron_flag = other_neural_network.multilayer_perceptron_flag;
00264
00265 scaling_layer_flag = other_neural_network.scaling_layer_flag;
00266
00267 unscaling_layer_flag = other_neural_network.unscaling_layer_flag;
00268
00269 bounding_layer_flag = other_neural_network.bounding_layer_flag;
00270
00271 probabilistic_layer_flag = other_neural_network.probabilistic_layer_flag;
00272
00273 conditions_layer_flag = other_neural_network.conditions_layer_flag;
00274
00275 display = other_neural_network.display;
00276 }
00277
00278 return(*this);
00279 }
00280
00281
00282
00283
00286
00287 bool NeuralNetwork::operator == (const NeuralNetwork& other_neural_network) const
00288 {
00289 if(*multilayer_perceptron_pointer == *other_neural_network.multilayer_perceptron_pointer
00290 && *scaling_layer_pointer == *other_neural_network.scaling_layer_pointer
00291 && *unscaling_layer_pointer == *other_neural_network.unscaling_layer_pointer
00292 && *bounding_layer_pointer == *other_neural_network.bounding_layer_pointer
00293 && *probabilistic_layer_pointer == *other_neural_network.probabilistic_layer_pointer
00294 && *conditions_layer_pointer == *other_neural_network.conditions_layer_pointer
00295 && *independent_parameters_pointer == *other_neural_network.independent_parameters_pointer
00296 && multilayer_perceptron_flag == other_neural_network.multilayer_perceptron_flag
00297 && scaling_layer_flag == other_neural_network.scaling_layer_flag
00298 && unscaling_layer_flag == other_neural_network.unscaling_layer_flag
00299 && bounding_layer_flag == other_neural_network.bounding_layer_flag
00300 && probabilistic_layer_flag == other_neural_network.probabilistic_layer_flag
00301 && conditions_layer_flag == other_neural_network.conditions_layer_flag
00302 && display == other_neural_network.display)
00303 {
00304 return(true);
00305 }
00306 else
00307 {
00308 return(false);
00309 }
00310 }
00311
00312
00313
00314
00315
00316
00318
00319 MultilayerPerceptron* NeuralNetwork::get_multilayer_perceptron_pointer(void) const
00320 {
00321 return(multilayer_perceptron_pointer);
00322 }
00323
00324
00325
00326
00328
00329 ScalingLayer* NeuralNetwork::get_scaling_layer_pointer(void) const
00330 {
00331 return(scaling_layer_pointer);
00332 }
00333
00334
00335
00336
00338
00339 UnscalingLayer* NeuralNetwork::get_unscaling_layer_pointer(void) const
00340 {
00341 return(unscaling_layer_pointer);
00342 }
00343
00344
00345
00346
00348
00349 BoundingLayer* NeuralNetwork::get_bounding_layer_pointer(void) const
00350 {
00351 return(bounding_layer_pointer);
00352 }
00353
00354
00355
00356
00358
00359 ProbabilisticLayer* NeuralNetwork::get_probabilistic_layer_pointer(void) const
00360 {
00361 return(probabilistic_layer_pointer);
00362 }
00363
00364
00365
00366
00368
00369 ConditionsLayer* NeuralNetwork::get_conditions_layer_pointer(void) const
00370 {
00371 return(conditions_layer_pointer);
00372 }
00373
00374
00375
00376
00378
00379 InputsOutputsInformation* NeuralNetwork::get_inputs_outputs_information_pointer(void) const
00380 {
00381 return(inputs_outputs_information_pointer);
00382 }
00383
00384
00385
00386
00388
00389 IndependentParameters* NeuralNetwork::get_independent_parameters_pointer(void) const
00390 {
00391 return(independent_parameters_pointer);
00392 }
00393
00394
00395
00396
00398
00399 const bool& NeuralNetwork::get_multilayer_perceptron_flag(void) const
00400 {
00401 return(multilayer_perceptron_flag);
00402 }
00403
00404
00405
00406
00408
00409 const bool& NeuralNetwork::get_scaling_layer_flag(void) const
00410 {
00411 return(scaling_layer_flag);
00412 }
00413
00414
00415
00416
00418
00419 const bool& NeuralNetwork::get_unscaling_layer_flag(void) const
00420 {
00421 return(unscaling_layer_flag);
00422 }
00423
00424
00425
00426
00428
00429 const bool& NeuralNetwork::get_bounding_layer_flag(void) const
00430 {
00431 return(bounding_layer_flag);
00432 }
00433
00434
00435
00436
00438
00439 const bool& NeuralNetwork::get_probabilistic_layer_flag(void) const
00440 {
00441 return(probabilistic_layer_flag);
00442 }
00443
00444
00445
00446
00448
00449 const bool& NeuralNetwork::get_conditions_layer_flag(void) const
00450 {
00451 return(conditions_layer_flag);
00452 }
00453
00454
00455
00456
00459
00460 const bool& NeuralNetwork::get_display(void) const
00461 {
00462 return(display);
00463 }
00464
00465
00466
00467
00470
00471 void NeuralNetwork::set(void)
00472 {
00473 delete_pointers();
00474
00475 set_default();
00476 }
00477
00478
00479
00480
00484
00485 void NeuralNetwork::set(const MultilayerPerceptron& new_multilayer_perceptron)
00486 {
00487 delete_pointers();
00488
00489 multilayer_perceptron_pointer = new MultilayerPerceptron(new_multilayer_perceptron);
00490
00491 set_default();
00492 }
00493
00494
00495
00496
00500
00501 void NeuralNetwork::set(const Vector<unsigned int>& new_multilayer_perceptron_architecture)
00502 {
00503 delete_pointers();
00504
00505 multilayer_perceptron_pointer = new MultilayerPerceptron(new_multilayer_perceptron_architecture);
00506
00507 set_default();
00508 }
00509
00510
00511
00512
00517
00518 void NeuralNetwork::set(const unsigned int& new_inputs_number, const unsigned int& new_outputs_number)
00519 {
00520 delete_pointers();
00521
00522 multilayer_perceptron_pointer = new MultilayerPerceptron(new_inputs_number, new_outputs_number);
00523
00524 set_default();
00525 }
00526
00527
00528
00529
00535
00536 void NeuralNetwork::set(const unsigned int& new_inputs_number, const unsigned int& new_hidden_neurons_number, const unsigned int& new_outputs_number)
00537 {
00538 delete_pointers();
00539
00540 multilayer_perceptron_pointer = new MultilayerPerceptron(new_inputs_number, new_hidden_neurons_number, new_outputs_number);
00541
00542 set_default();
00543 }
00544
00545
00546
00547
00551
00552 void NeuralNetwork::set(const unsigned int& new_independent_parameters_number)
00553 {
00554 delete_pointers();
00555
00556 independent_parameters_pointer = new IndependentParameters(new_independent_parameters_number);
00557
00558 set_default();
00559 }
00560
00561
00562
00563
00566
00567 void NeuralNetwork::set(const std::string& filename)
00568 {
00569 delete_pointers();
00570
00571 load(filename);
00572 }
00573
00574
00575
00576
00579
00580 void NeuralNetwork::set(const NeuralNetwork& other_neural_network)
00581 {
00582
00583
00584 delete_pointers();
00585
00586 if(other_neural_network.multilayer_perceptron_pointer)
00587 {
00588 multilayer_perceptron_pointer = new MultilayerPerceptron(*other_neural_network.multilayer_perceptron_pointer);
00589 }
00590
00591 if(other_neural_network.scaling_layer_pointer)
00592 {
00593 scaling_layer_pointer = new ScalingLayer(*other_neural_network.scaling_layer_pointer);
00594 }
00595
00596 if(other_neural_network.unscaling_layer_pointer)
00597 {
00598 unscaling_layer_pointer = new UnscalingLayer(*other_neural_network.unscaling_layer_pointer);
00599 }
00600
00601 if(other_neural_network.bounding_layer_pointer)
00602 {
00603 bounding_layer_pointer = new BoundingLayer(*other_neural_network.bounding_layer_pointer);
00604 }
00605
00606 if(other_neural_network.probabilistic_layer_pointer)
00607 {
00608 probabilistic_layer_pointer = new ProbabilisticLayer(*other_neural_network.probabilistic_layer_pointer);
00609 }
00610
00611 if(other_neural_network.conditions_layer_pointer)
00612 {
00613 conditions_layer_pointer = new ConditionsLayer(*other_neural_network.conditions_layer_pointer);
00614 }
00615
00616 if(other_neural_network.inputs_outputs_information_pointer)
00617 {
00618 inputs_outputs_information_pointer = new InputsOutputsInformation(*other_neural_network.inputs_outputs_information_pointer);
00619 }
00620
00621 if(other_neural_network.independent_parameters_pointer)
00622 {
00623 independent_parameters_pointer = new IndependentParameters(*other_neural_network.independent_parameters_pointer);
00624 }
00625
00626
00627
00628 multilayer_perceptron_flag = other_neural_network.multilayer_perceptron_flag;
00629
00630 scaling_layer_flag = other_neural_network.scaling_layer_flag;
00631
00632 unscaling_layer_flag = other_neural_network.unscaling_layer_flag;
00633
00634 bounding_layer_flag = other_neural_network.bounding_layer_flag;
00635
00636 probabilistic_layer_flag = other_neural_network.probabilistic_layer_flag;
00637
00638 conditions_layer_flag = other_neural_network.conditions_layer_flag;
00639
00640
00641
00642 display = other_neural_network.display;
00643 }
00644
00645
00646
00647
00649
00650 void NeuralNetwork::set_default(void)
00651 {
00652 multilayer_perceptron_flag = true;
00653 scaling_layer_flag = false;
00654 unscaling_layer_flag = false;
00655 bounding_layer_flag = false;
00656 probabilistic_layer_flag = false;
00657 conditions_layer_flag = false;
00658
00659 display = true;
00660 }
00661
00662
00663
00664
00668
00669 void NeuralNetwork::set_multilayer_perceptron_pointer(MultilayerPerceptron* new_multilayer_perceptron_pointer)
00670 {
00671 if(new_multilayer_perceptron_pointer != multilayer_perceptron_pointer)
00672 {
00673 delete multilayer_perceptron_pointer;
00674
00675 multilayer_perceptron_pointer = new_multilayer_perceptron_pointer;
00676 }
00677 }
00678
00679
00680
00681
00685
00686 void NeuralNetwork::set_scaling_layer_pointer(ScalingLayer* new_scaling_layer_pointer)
00687 {
00688 if(new_scaling_layer_pointer != scaling_layer_pointer)
00689 {
00690 delete scaling_layer_pointer;
00691
00692 scaling_layer_pointer = new_scaling_layer_pointer;
00693 }
00694 }
00695
00696
00697
00698
00702
00703 void NeuralNetwork::set_unscaling_layer_pointer(UnscalingLayer* new_unscaling_layer_pointer)
00704 {
00705 if(new_unscaling_layer_pointer != unscaling_layer_pointer)
00706 {
00707 delete unscaling_layer_pointer;
00708
00709 unscaling_layer_pointer = new_unscaling_layer_pointer;
00710 }
00711 }
00712
00713
00714
00715
00719
00720 void NeuralNetwork::set_bounding_layer_pointer(BoundingLayer* new_bounding_layer_pointer)
00721 {
00722 if(new_bounding_layer_pointer != bounding_layer_pointer)
00723 {
00724 delete bounding_layer_pointer;
00725
00726 bounding_layer_pointer = new_bounding_layer_pointer;
00727 }
00728 }
00729
00730
00731
00732
00736
00737 void NeuralNetwork::set_probabilistic_layer_pointer(ProbabilisticLayer* new_probabilistic_layer_pointer)
00738 {
00739 if(new_probabilistic_layer_pointer != probabilistic_layer_pointer)
00740 {
00741 delete probabilistic_layer_pointer;
00742
00743 probabilistic_layer_pointer = new_probabilistic_layer_pointer;
00744 }
00745 }
00746
00747
00748
00749
00753
00754 void NeuralNetwork::set_conditions_layer_pointer(ConditionsLayer* new_conditions_layer_pointer)
00755 {
00756 if(new_conditions_layer_pointer != conditions_layer_pointer)
00757 {
00758 delete conditions_layer_pointer;
00759
00760 conditions_layer_pointer = new_conditions_layer_pointer;
00761 }
00762 }
00763
00764
00765
00766
00770
00771 void NeuralNetwork::set_inputs_outputs_information_pointer(InputsOutputsInformation* new_inputs_outputs_information_pointer)
00772 {
00773 if(new_inputs_outputs_information_pointer != inputs_outputs_information_pointer)
00774 {
00775 delete inputs_outputs_information_pointer;
00776
00777 inputs_outputs_information_pointer = new_inputs_outputs_information_pointer;
00778 }
00779 }
00780
00781
00782
00783
00787
00788 void NeuralNetwork::set_independent_parameters_pointer(IndependentParameters* new_independent_parameters_pointer)
00789 {
00790 if(new_independent_parameters_pointer != independent_parameters_pointer)
00791 {
00792 delete independent_parameters_pointer;
00793
00794 independent_parameters_pointer = new_independent_parameters_pointer;
00795 }
00796 }
00797
00798
00799
00800
00803
00804 void NeuralNetwork::set_multilayer_perceptron_flag(const bool& new_multilayer_perceptron_flag)
00805 {
00806 multilayer_perceptron_flag = new_multilayer_perceptron_flag;
00807 }
00808
00809
00810
00811
00814
00815 void NeuralNetwork::set_scaling_layer_flag(const bool& new_scaling_layer_flag)
00816 {
00817 unsigned int inputs_number = 0;
00818
00819 if(multilayer_perceptron_pointer)
00820 {
00821 inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00822 }
00823
00824 if(!scaling_layer_pointer)
00825 {
00826 scaling_layer_pointer = new ScalingLayer(inputs_number);
00827 }
00828
00829 scaling_layer_flag = new_scaling_layer_flag;
00830 }
00831
00832
00833
00834
00837
00838 void NeuralNetwork::set_unscaling_layer_flag(const bool& new_unscaling_layer_flag)
00839 {
00840 unsigned int outputs_number = 0;
00841
00842 if(multilayer_perceptron_pointer)
00843 {
00844 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00845 }
00846
00847 if(!unscaling_layer_flag)
00848 {
00849 unscaling_layer_pointer = new UnscalingLayer(outputs_number);
00850 }
00851
00852 unscaling_layer_flag = new_unscaling_layer_flag;
00853 }
00854
00855
00856
00857
00860
00861 void NeuralNetwork::set_scaling_unscaling_layers_flag(const bool& new_scaling_unscaling_layers_flag)
00862 {
00863 set_scaling_layer_flag(new_scaling_unscaling_layers_flag);
00864 set_unscaling_layer_flag(new_scaling_unscaling_layers_flag);
00865 }
00866
00867
00868
00869
00872
00873 void NeuralNetwork::set_bounding_layer_flag(const bool& new_bounding_layer_flag)
00874 {
00875 unsigned int outputs_number = 0;
00876
00877 if(multilayer_perceptron_pointer)
00878 {
00879 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00880 }
00881
00882 if(!bounding_layer_pointer)
00883 {
00884 bounding_layer_pointer = new BoundingLayer(outputs_number);
00885 }
00886
00887 bounding_layer_flag = new_bounding_layer_flag;
00888 }
00889
00890
00891
00892
00896
00897 void NeuralNetwork::set_probabilistic_layer_flag(const bool& new_probabilistic_layer_flag)
00898 {
00899 unsigned int outputs_number = 0;
00900
00901 if(multilayer_perceptron_pointer)
00902 {
00903 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00904 }
00905
00906 if(!probabilistic_layer_pointer)
00907 {
00908 probabilistic_layer_pointer = new ProbabilisticLayer(outputs_number);
00909 }
00910
00911 probabilistic_layer_flag = new_probabilistic_layer_flag;
00912 }
00913
00914
00915
00916
00919
00920 void NeuralNetwork::set_conditions_layer_flag(const bool& new_conditions_layer_flag)
00921 {
00922 if(!conditions_layer_pointer)
00923 {
00924 unsigned int inputs_number = 0;
00925 unsigned int outputs_number = 0;
00926
00927 if(multilayer_perceptron_pointer)
00928 {
00929 inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00930 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00931 }
00932
00933 conditions_layer_pointer = new ConditionsLayer(inputs_number, outputs_number);
00934 }
00935
00936 conditions_layer_flag = new_conditions_layer_flag;
00937 }
00938
00939
00940
00941
00944
00945 unsigned int NeuralNetwork::count_parameters_number(void) const
00946 {
00947 unsigned int parameters_number = 0;
00948
00949 if(multilayer_perceptron_pointer)
00950 {
00951 parameters_number += multilayer_perceptron_pointer->count_parameters_number();
00952 }
00953
00954 if(independent_parameters_pointer)
00955 {
00956 parameters_number += independent_parameters_pointer->count_parameters_number();
00957 }
00958
00959 return(parameters_number);
00960 }
00961
00962
00963
00964
00967
00968 Vector<double> NeuralNetwork::arrange_parameters(void) const
00969 {
00970
00971
00972 if(multilayer_perceptron_pointer && !independent_parameters_pointer)
00973 {
00974 return(multilayer_perceptron_pointer->arrange_parameters());
00975 }
00976
00977
00978
00979 else if(!multilayer_perceptron_pointer && independent_parameters_pointer)
00980 {
00981 const bool& independent_parameters_scaling_flag = independent_parameters_pointer->get_scaling_flag();
00982
00983 if(!independent_parameters_scaling_flag)
00984 {
00985 const Vector<double> parameters = independent_parameters_pointer->get_parameters();
00986
00987 return(parameters);
00988 }
00989 else
00990 {
00991 return(independent_parameters_pointer->calculate_scaled_parameters());
00992 }
00993 }
00994
00995
00996
00997 else if(multilayer_perceptron_pointer && independent_parameters_pointer)
00998 {
00999 const Vector<double> network_parameters = multilayer_perceptron_pointer->arrange_parameters();
01000
01001 const bool& independent_parameters_scaling_flag = independent_parameters_pointer->get_scaling_flag();
01002
01003 if(!independent_parameters_scaling_flag)
01004 {
01005 const Vector<double> independent_parameters = independent_parameters_pointer->get_parameters();
01006
01007 return(network_parameters.get_assembly(independent_parameters));
01008 }
01009 else
01010 {
01011 const Vector<double> scaled_independent_parameters = independent_parameters_pointer->calculate_scaled_parameters();
01012
01013 return(network_parameters.get_assembly(scaled_independent_parameters));
01014 }
01015 }
01016
01017
01018
01019 else
01020 {
01021 const Vector<double> parameters;
01022
01023 return(parameters);
01024 }
01025 }
01026
01027
01028
01029
01032
01033 void NeuralNetwork::set_parameters(const Vector<double>& new_parameters)
01034 {
01035
01036
01037 #ifdef _DEBUG
01038
01039 const unsigned int size = new_parameters.size();
01040
01041 const unsigned int parameters_number = count_parameters_number();
01042
01043 if(size != parameters_number)
01044 {
01045 std::ostringstream buffer;
01046
01047 buffer << "OpenNN Exception: NeuralNetwork class.\n"
01048 << "void set_parameters(const Vector<double>&) method.\n"
01049 << "Size must be equal to number of parameters.\n";
01050
01051 throw std::logic_error(buffer.str());
01052 }
01053
01054 #endif
01055
01056 if(multilayer_perceptron_pointer && !independent_parameters_pointer)
01057 {
01058
01059 multilayer_perceptron_pointer->set_parameters(new_parameters);
01060 }
01061 else if(!multilayer_perceptron_pointer && independent_parameters_pointer)
01062 {
01063 if(!independent_parameters_pointer->get_scaling_flag())
01064 {
01065 independent_parameters_pointer->set_parameters(new_parameters);
01066 }
01067 else
01068 {
01069 independent_parameters_pointer->unscale_parameters(new_parameters);
01070 }
01071 }
01072 else if(multilayer_perceptron_pointer && independent_parameters_pointer)
01073 {
01074
01075
01076 const unsigned int network_parameters_number = multilayer_perceptron_pointer->count_parameters_number();
01077 const unsigned int independent_parameters_number = independent_parameters_pointer->count_parameters_number();
01078
01079 const Vector<double> network_parameters = new_parameters.take_out(0, network_parameters_number);
01080
01081 multilayer_perceptron_pointer->set_parameters(network_parameters);
01082
01083
01084
01085 if(!independent_parameters_pointer->get_scaling_flag())
01086 {
01087 const Vector<double> independent_parameters = new_parameters.take_out(network_parameters_number, independent_parameters_number);
01088
01089 independent_parameters_pointer->set_parameters(independent_parameters);
01090 }
01091 else
01092 {
01093 const Vector<double> scaled_independent_parameters = new_parameters.take_out(network_parameters_number, independent_parameters_number);
01094
01095 independent_parameters_pointer->unscale_parameters(scaled_independent_parameters);
01096 }
01097 }
01098 else
01099 {
01100 return;
01101 }
01102 }
01103
01104
01105
01106
01118
01119 void NeuralNetwork::delete_pointers(void)
01120 {
01121 delete multilayer_perceptron_pointer;
01122 delete scaling_layer_pointer;
01123 delete unscaling_layer_pointer;
01124 delete bounding_layer_pointer;
01125 delete probabilistic_layer_pointer;
01126 delete conditions_layer_pointer;
01127 delete inputs_outputs_information_pointer;
01128 delete independent_parameters_pointer;
01129
01130 multilayer_perceptron_pointer = NULL;
01131 scaling_layer_pointer = NULL;
01132 unscaling_layer_pointer = NULL;
01133 bounding_layer_pointer = NULL;
01134 probabilistic_layer_pointer = NULL;
01135 conditions_layer_pointer = NULL;
01136 inputs_outputs_information_pointer = NULL;
01137 independent_parameters_pointer = NULL;
01138 }
01139
01140
01141
01142
01145
01146 void NeuralNetwork::construct_multilayer_perceptron(void)
01147 {
01148 if(!multilayer_perceptron_pointer)
01149 {
01150 multilayer_perceptron_pointer = new MultilayerPerceptron();
01151 }
01152
01153 multilayer_perceptron_flag = true;
01154 }
01155
01156
01157
01158
01162
01163 void NeuralNetwork::construct_scaling_layer(void)
01164 {
01165 if(!scaling_layer_pointer)
01166 {
01167 unsigned int inputs_number = 0;
01168
01169 if(multilayer_perceptron_pointer)
01170 {
01171 inputs_number = multilayer_perceptron_pointer->count_inputs_number();
01172 }
01173
01174 scaling_layer_pointer = new ScalingLayer(inputs_number);
01175 }
01176
01177 scaling_layer_flag = true;
01178 }
01179
01180
01181
01182
01186
01187 void NeuralNetwork::construct_unscaling_layer(void)
01188 {
01189 if(!unscaling_layer_pointer)
01190 {
01191 unsigned int outputs_number = 0;
01192
01193 if(multilayer_perceptron_pointer)
01194 {
01195 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
01196 }
01197
01198 unscaling_layer_pointer = new UnscalingLayer(outputs_number);
01199 }
01200
01201 unscaling_layer_flag = true;
01202 }
01203
01204
01205
01206
01210
01211 void NeuralNetwork::construct_bounding_layer(void)
01212 {
01213 if(!bounding_layer_pointer)
01214 {
01215 unsigned int outputs_number = 0;
01216
01217 if(multilayer_perceptron_pointer)
01218 {
01219 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
01220 }
01221
01222 bounding_layer_pointer = new BoundingLayer(outputs_number);
01223 }
01224
01225 bounding_layer_flag = true;
01226 }
01227
01228
01229
01230
01234
01235 void NeuralNetwork::construct_probabilistic_layer(void)
01236 {
01237 if(!probabilistic_layer_pointer)
01238 {
01239 unsigned int outputs_number = 0;
01240
01241 if(multilayer_perceptron_pointer)
01242 {
01243 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
01244 }
01245
01246 probabilistic_layer_pointer = new ProbabilisticLayer(outputs_number);
01247 }
01248
01249 probabilistic_layer_flag = true;
01250 }
01251
01252
01253
01254
01259
01260 void NeuralNetwork::construct_conditions_layer(void)
01261 {
01262 if(!conditions_layer_pointer)
01263 {
01264 unsigned int inputs_number = 0;
01265 unsigned int outputs_number = 0;
01266
01267 if(multilayer_perceptron_pointer)
01268 {
01269 inputs_number = multilayer_perceptron_pointer->count_inputs_number();
01270 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
01271 }
01272
01273 conditions_layer_pointer = new ConditionsLayer(inputs_number, outputs_number);
01274 }
01275
01276 conditions_layer_flag = true;
01277 }
01278
01279
01280
01281
01285
01286 void NeuralNetwork::construct_inputs_outputs_information(void)
01287 {
01288 if(!inputs_outputs_information_pointer)
01289 {
01290 unsigned int inputs_number = 0;
01291 unsigned int outputs_number = 0;
01292
01293 if(multilayer_perceptron_pointer)
01294 {
01295 inputs_number = multilayer_perceptron_pointer->count_inputs_number();
01296 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
01297 }
01298
01299 inputs_outputs_information_pointer = new InputsOutputsInformation(inputs_number, outputs_number);
01300 }
01301 }
01302
01303
01304
01305
01308
01309 void NeuralNetwork::construct_independent_parameters(void)
01310 {
01311 if(!independent_parameters_pointer)
01312 {
01313 independent_parameters_pointer = new IndependentParameters();
01314 }
01315 }
01316
01317
01318
01319
01322
01323 void NeuralNetwork::destruct_multilayer_perceptron(void)
01324 {
01325 delete multilayer_perceptron_pointer;
01326
01327 multilayer_perceptron_pointer = NULL;
01328
01329 multilayer_perceptron_flag = false;
01330 }
01331
01332
01333
01334
01337
01338 void NeuralNetwork::destruct_scaling_layer(void)
01339 {
01340 delete scaling_layer_pointer;
01341
01342 scaling_layer_pointer = NULL;
01343
01344 scaling_layer_flag = false;
01345 }
01346
01347
01348
01349
01352
01353 void NeuralNetwork::destruct_unscaling_layer(void)
01354 {
01355 delete unscaling_layer_pointer;
01356
01357 unscaling_layer_pointer = NULL;
01358
01359 unscaling_layer_flag = false;
01360 }
01361
01362
01363
01364
01367
01368 void NeuralNetwork::destruct_bounding_layer(void)
01369 {
01370 delete bounding_layer_pointer;
01371
01372 bounding_layer_pointer = NULL;
01373
01374 bounding_layer_flag = false;
01375 }
01376
01377
01378
01379
01382
01383 void NeuralNetwork::destruct_probabilistic_layer(void)
01384 {
01385 delete probabilistic_layer_pointer;
01386
01387 probabilistic_layer_pointer = NULL;
01388
01389 probabilistic_layer_flag = false;
01390 }
01391
01392
01393
01394
01397
01398 void NeuralNetwork::destruct_conditions_layer(void)
01399 {
01400 delete conditions_layer_pointer;
01401
01402 conditions_layer_pointer = NULL;
01403
01404 conditions_layer_flag = false;
01405 }
01406
01407
01408
01409
01411
01412 void NeuralNetwork::destruct_inputs_outputs_information(void)
01413 {
01414 delete inputs_outputs_information_pointer;
01415
01416 inputs_outputs_information_pointer = NULL;
01417 }
01418
01419
01420
01421
01423
01424 void NeuralNetwork::destruct_independent_parameters(void)
01425 {
01426 delete independent_parameters_pointer;
01427
01428 independent_parameters_pointer = NULL;
01429 }
01430
01431
01432
01433
01436
01437 void NeuralNetwork::initialize_random(void)
01438 {
01439 unsigned int inputs_number;
01440 unsigned int outputs_number;
01441
01442
01443
01444 if(rand()%5)
01445 {
01446 if(!multilayer_perceptron_pointer)
01447 {
01448 multilayer_perceptron_pointer = new MultilayerPerceptron();
01449 }
01450
01451 multilayer_perceptron_pointer->initialize_random();
01452
01453 inputs_number = multilayer_perceptron_pointer->count_inputs_number();
01454 outputs_number = multilayer_perceptron_pointer->count_outputs_number();
01455 }
01456 else
01457 {
01458 inputs_number = rand()%10 + 1;
01459 outputs_number = rand()%10 + 1;
01460 }
01461
01462
01463
01464 if(rand()%5)
01465 {
01466 if(scaling_layer_pointer)
01467 {
01468 scaling_layer_pointer = new ScalingLayer(inputs_number);
01469 }
01470
01471 scaling_layer_pointer->initialize_random();
01472 }
01473
01474
01475
01476 if(rand()%5)
01477 {
01478 if(unscaling_layer_pointer)
01479 {
01480 unscaling_layer_pointer = new UnscalingLayer(outputs_number);
01481 }
01482
01483 unscaling_layer_pointer->initialize_random();
01484 }
01485
01486
01487
01488 if(rand()%5)
01489 {
01490 if(bounding_layer_pointer)
01491 {
01492 bounding_layer_pointer = new BoundingLayer(outputs_number);
01493 }
01494
01495 bounding_layer_pointer->initialize_random();
01496 }
01497
01498
01499
01500 if(rand()%5)
01501 {
01502 if(probabilistic_layer_pointer)
01503 {
01504 probabilistic_layer_pointer = new ProbabilisticLayer(outputs_number);
01505 }
01506
01507 probabilistic_layer_pointer->initialize_random();
01508 }
01509
01510
01511
01512 if(rand()%5)
01513 {
01514 if(conditions_layer_pointer)
01515 {
01516 conditions_layer_pointer = new ConditionsLayer(inputs_number, outputs_number);
01517 }
01518
01519 conditions_layer_pointer->initialize_random();
01520 }
01521
01522
01523
01524 if(rand()%5)
01525 {
01526 if(inputs_outputs_information_pointer)
01527 {
01528 inputs_outputs_information_pointer = new InputsOutputsInformation(inputs_number, outputs_number);
01529 }
01530
01531 inputs_outputs_information_pointer->initialize_random();
01532 }
01533
01534
01535
01536 if(rand()%5)
01537 {
01538 if(independent_parameters_pointer)
01539 {
01540 independent_parameters_pointer = new IndependentParameters();
01541 }
01542
01543 inputs_outputs_information_pointer->initialize_random();
01544 }
01545 }
01546
01547
01548
01549
01554
01555 void NeuralNetwork::set_display(const bool& new_display)
01556 {
01557 display = new_display;
01558 }
01559
01560
01561
01562
01565
01566 unsigned int NeuralNetwork::count_layers_number(void)
01567 {
01568 unsigned int layers_number = 0;
01569
01570 if(multilayer_perceptron_pointer)
01571 {
01572 layers_number += multilayer_perceptron_pointer->count_layers_number();
01573 }
01574
01575 if(scaling_layer_pointer)
01576 {
01577 layers_number += 1;
01578 }
01579
01580 if(unscaling_layer_pointer)
01581 {
01582 layers_number += 1;
01583 }
01584
01585 if(bounding_layer_pointer)
01586 {
01587 layers_number += 1;
01588 }
01589
01590 if(probabilistic_layer_pointer)
01591 {
01592 layers_number += 1;
01593 }
01594
01595 if(conditions_layer_pointer)
01596 {
01597 layers_number += 1;
01598 }
01599
01600 return(layers_number);
01601 }
01602
01603
01604
01605
01607
01608 void NeuralNetwork::initialize_parameters(const double& value)
01609 {
01610 if(multilayer_perceptron_pointer)
01611 {
01612 multilayer_perceptron_pointer->initialize_parameters(value);
01613 }
01614
01615 if(independent_parameters_pointer)
01616 {
01617 independent_parameters_pointer->initialize_parameters(value);
01618 }
01619 }
01620
01621
01622
01623
01626
01627 void NeuralNetwork::initialize_parameters_uniform(void)
01628 {
01629 if(multilayer_perceptron_pointer)
01630 {
01631 multilayer_perceptron_pointer->initialize_parameters_uniform();
01632 }
01633
01634 if(independent_parameters_pointer)
01635 {
01636 independent_parameters_pointer->initialize_parameters_uniform();
01637 }
01638 }
01639
01640
01641
01642
01647
01648 void NeuralNetwork::initialize_parameters_uniform(const double& minimum, const double& maximum)
01649 {
01650 if(multilayer_perceptron_pointer)
01651 {
01652 multilayer_perceptron_pointer->initialize_parameters_uniform(minimum, maximum);
01653 }
01654
01655 if(independent_parameters_pointer)
01656 {
01657 independent_parameters_pointer->initialize_parameters_uniform(minimum, maximum);
01658 }
01659 }
01660
01661
01662
01663
01669
01670 void NeuralNetwork::initialize_parameters_uniform(const Vector<double>& minimum, const Vector<double>& maximum)
01671 {
01672 if(multilayer_perceptron_pointer)
01673 {
01674 multilayer_perceptron_pointer->initialize_parameters_uniform(minimum, maximum);
01675 }
01676
01677 if(independent_parameters_pointer)
01678 {
01679 independent_parameters_pointer->initialize_parameters_uniform(minimum, maximum);
01680 }
01681 }
01682
01683
01684
01685
01692
01693 void NeuralNetwork::initialize_parameters_uniform(const Vector< Vector<double> >& minimum_maximum)
01694 {
01695 if(multilayer_perceptron_pointer)
01696 {
01697 multilayer_perceptron_pointer->initialize_parameters_uniform(minimum_maximum);
01698 }
01699
01700 if(independent_parameters_pointer)
01701 {
01702 independent_parameters_pointer->initialize_parameters_uniform(minimum_maximum);
01703 }
01704 }
01705
01706
01707
01708
01711
01712 void NeuralNetwork::initialize_parameters_normal(void)
01713 {
01714 if(multilayer_perceptron_pointer)
01715 {
01716 multilayer_perceptron_pointer->initialize_parameters_normal();
01717 }
01718
01719 if(independent_parameters_pointer)
01720 {
01721 independent_parameters_pointer->initialize_parameters_normal();
01722 }
01723 }
01724
01725
01726
01727
01733
01734 void NeuralNetwork::initialize_parameters_normal(const double& mean, const double& standard_deviation)
01735 {
01736 if(multilayer_perceptron_pointer)
01737 {
01738 multilayer_perceptron_pointer->initialize_parameters_normal(mean, standard_deviation);
01739 }
01740
01741 if(independent_parameters_pointer)
01742 {
01743 independent_parameters_pointer->initialize_parameters_normal(mean, standard_deviation);
01744 }
01745 }
01746
01747
01748
01749
01755
01756 void NeuralNetwork::initialize_parameters_normal(const Vector<double>& mean, const Vector<double>& standard_deviation)
01757 {
01758 if(multilayer_perceptron_pointer)
01759 {
01760 multilayer_perceptron_pointer->initialize_parameters_normal(mean, standard_deviation);
01761 }
01762
01763 if(independent_parameters_pointer)
01764 {
01765 independent_parameters_pointer->initialize_parameters_normal(mean, standard_deviation);
01766 }
01767 }
01768
01769
01770
01771
01779
01780 void NeuralNetwork::initialize_parameters_normal(const Vector< Vector<double> >& mean_standard_deviation)
01781 {
01782 if(multilayer_perceptron_pointer)
01783 {
01784 multilayer_perceptron_pointer->initialize_parameters_normal(mean_standard_deviation);
01785 }
01786
01787 if(independent_parameters_pointer)
01788 {
01789 independent_parameters_pointer->initialize_parameters_normal(mean_standard_deviation);
01790 }
01791 }
01792
01793
01794
01795
01797
01798 double NeuralNetwork::calculate_parameters_norm(void) const
01799 {
01800 const Vector<double> parameters = arrange_parameters();
01801
01802 const double parameters_norm = parameters.calculate_norm();
01803
01804 return(parameters_norm);
01805 }
01806
01807
01808
01809
01821
01822 Vector<double> NeuralNetwork::calculate_outputs(const Vector<double>& inputs) const
01823 {
01824
01825
01826 #ifdef _DEBUG
01827
01828 if(multilayer_perceptron_pointer)
01829 {
01830 const unsigned int inputs_size = inputs.size();
01831
01832 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
01833
01834 if(inputs_size != inputs_number)
01835 {
01836 std::ostringstream buffer;
01837
01838 buffer << "OpenNN Exception: NeuralNetwork class.\n"
01839 << "Vector<double> calculate_outputs(const Vector<double>&) const method.\n"
01840 << "Size of inputs must be equal to number of inputs.\n";
01841
01842 throw std::logic_error(buffer.str());
01843 }
01844 }
01845
01846 #endif
01847
01848 Vector<double> outputs(inputs);
01849
01850
01851
01852 if(scaling_layer_pointer && scaling_layer_flag)
01853 {
01854 outputs = scaling_layer_pointer->calculate_outputs(inputs);
01855 }
01856
01857
01858
01859 if(multilayer_perceptron_pointer && multilayer_perceptron_flag)
01860 {
01861 outputs = multilayer_perceptron_pointer->calculate_outputs(outputs);
01862 }
01863
01864
01865
01866 if(conditions_layer_pointer && conditions_layer_flag)
01867 {
01868 outputs = conditions_layer_pointer->calculate_outputs(inputs, outputs);
01869 }
01870
01871
01872
01873 if(unscaling_layer_pointer && unscaling_layer_flag)
01874 {
01875 outputs = unscaling_layer_pointer->calculate_outputs(outputs);
01876 }
01877
01878
01879
01880 if(probabilistic_layer_pointer && probabilistic_layer_flag)
01881 {
01882 outputs = probabilistic_layer_pointer->calculate_outputs(outputs);
01883 }
01884
01885
01886
01887 if(bounding_layer_pointer && bounding_layer_flag)
01888 {
01889 outputs = bounding_layer_pointer->calculate_outputs(outputs);
01890 }
01891
01892 return(outputs);
01893 }
01894
01895
01896
01897
01901
01902 Vector<double> NeuralNetwork::calculate_parameters_output(const Vector<double>& inputs, const Vector<double>& parameters) const
01903 {
01904
01905
01906 #ifdef _DEBUG
01907
01908 const unsigned int inputs_size = inputs.size();
01909
01910 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
01911
01912 if(inputs_size != inputs_number)
01913 {
01914 std::ostringstream buffer;
01915
01916 buffer << "OpenNN Exception: NeuralNetwork class.\n"
01917 << "Vector<double> calculate_parameters_output(const Vector<double>&, const Vector<double>&) const method.\n"
01918 << "Size of inputs (" << inputs_size << ") must be equal to number of inputs (" << inputs_number << ").\n";
01919
01920 throw std::logic_error(buffer.str());
01921 }
01922
01923 const unsigned int parameters_size = parameters.size();
01924
01925 const unsigned int parameters_number = count_parameters_number();
01926
01927 if(parameters_size != parameters_number)
01928 {
01929 std::ostringstream buffer;
01930
01931 buffer << "OpenNN Exception: NeuralNetwork class.\n"
01932 << "Vector<double> calculate_parameters_output(const Vector<double>&, const Vector<double>&) const method.\n"
01933 << "Size of potential parameters (" << parameters_size << ") must be equal to number of parameters (" << parameters_number << ").\n";
01934
01935 throw std::logic_error(buffer.str());
01936 }
01937
01938 #endif
01939
01940 NeuralNetwork copy(*this);
01941
01942 copy.set_parameters(parameters);
01943
01944 return(copy.calculate_outputs(inputs));
01945 }
01946
01947
01948
01949
01953
01954 Matrix<double> NeuralNetwork::calculate_output_data(const Matrix<double>& input_data) const
01955 {
01956 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
01957 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
01958
01959
01960
01961 #ifdef _DEBUG
01962
01963 const unsigned int columns_number = input_data.get_columns_number();
01964
01965 if(columns_number != inputs_number)
01966 {
01967 std::ostringstream buffer;
01968
01969 buffer << "OpenNN Exception: NeuralNetwork class.\n"
01970 << "Matrix<double> calculate_output_data(const Matrix<double>&) const method.\n"
01971 << "Number of columns must be equal to number of inputs.\n";
01972
01973 throw std::logic_error(buffer.str());
01974 }
01975
01976 #endif
01977
01978 const unsigned int input_vectors_number = input_data.get_rows_number();
01979
01980 Matrix<double> output_data(input_vectors_number, outputs_number);
01981
01982 Vector<double> inputs(inputs_number);
01983 Vector<double> outputs(outputs_number);
01984
01985 for(unsigned int i = 0; i < input_vectors_number; i++)
01986 {
01987 inputs = input_data.arrange_row(i);
01988 outputs = calculate_outputs(inputs);
01989 output_data.set_row(i, outputs);
01990 }
01991
01992 return(output_data);
01993 }
01994
01995
01996
01997
02002
02003 Matrix<double> NeuralNetwork::calculate_Jacobian(const Vector<double>& inputs) const
02004 {
02005 #ifdef _DEBUG
02006
02007 const unsigned int size = inputs.size();
02008
02009 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
02010
02011 if(size != inputs_number)
02012 {
02013 std::ostringstream buffer;
02014
02015 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02016 << "void calculate_Jacobian(const Vector<double>&) const method.\n"
02017 << "Size must be equal to number of inputs.\n";
02018
02019 throw std::logic_error(buffer.str());
02020 }
02021
02022 #endif
02023
02024 Vector<double> outputs(inputs);
02025
02026 Matrix<double> scaling_layer_Jacobian;
02027 Matrix<double> unscaling_layer_Jacobian;
02028 Matrix<double> multilayer_perceptron_Jacobian;
02029 Matrix<double> bounding_layer_Jacobian;
02030 Matrix<double> conditions_layer_Jacobian;
02031 Matrix<double> probabilistic_layer_Jacobian;
02032
02033
02034
02035 if(scaling_layer_flag)
02036 {
02037 const Vector<double> scaling_layer_derivative = scaling_layer_pointer->calculate_derivative(outputs);
02038 scaling_layer_Jacobian = scaling_layer_pointer->arrange_Jacobian(scaling_layer_derivative);
02039
02040 outputs = scaling_layer_pointer->calculate_outputs(outputs);
02041 }
02042
02043
02044
02045 if(multilayer_perceptron_flag)
02046 {
02047 multilayer_perceptron_Jacobian = multilayer_perceptron_pointer->calculate_Jacobian(outputs);
02048
02049 outputs = multilayer_perceptron_pointer->calculate_outputs(outputs);
02050 }
02051
02052
02053
02054 if(unscaling_layer_flag)
02055 {
02056 const Vector<double> unscaling_layer_derivative = unscaling_layer_pointer->calculate_derivative(outputs);
02057 unscaling_layer_Jacobian = scaling_layer_pointer->arrange_Jacobian(unscaling_layer_derivative);
02058
02059 outputs = unscaling_layer_pointer->calculate_outputs(outputs);
02060 }
02061
02062
02063
02064 if(probabilistic_layer_flag)
02065 {
02066 probabilistic_layer_Jacobian = probabilistic_layer_pointer->calculate_Jacobian(outputs);
02067
02068 outputs = probabilistic_layer_pointer->calculate_outputs(outputs);
02069 }
02070
02071
02072
02073 if(bounding_layer_flag)
02074 {
02075 const Vector<double>& derivatives = bounding_layer_pointer->calculate_derivative(outputs);
02076
02077 bounding_layer_Jacobian = bounding_layer_pointer->arrange_Jacobian(derivatives);
02078
02079 outputs = bounding_layer_pointer->calculate_outputs(outputs);
02080 }
02081
02082 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
02083
02084 Matrix<double> Jacobian(outputs_number, outputs_number, 0.0);
02085 Jacobian.set_diagonal(1.0);
02086
02087
02088
02089 if(bounding_layer_flag)
02090 {
02091 Jacobian = Jacobian.dot(bounding_layer_Jacobian);
02092 }
02093
02094
02095
02096 if(probabilistic_layer_flag)
02097 {
02098 Jacobian = Jacobian.dot(probabilistic_layer_Jacobian);
02099 }
02100
02101
02102
02103 if(unscaling_layer_flag)
02104 {
02105 Jacobian = Jacobian.dot(unscaling_layer_Jacobian);
02106 }
02107
02108
02109
02110 if(multilayer_perceptron_flag)
02111 {
02112 Jacobian = Jacobian.dot(multilayer_perceptron_Jacobian);
02113 }
02114
02115
02116
02117 if(scaling_layer_flag)
02118 {
02119 Jacobian = Jacobian.dot(scaling_layer_Jacobian);
02120 }
02121
02122
02123
02124 if(conditions_layer_flag)
02125 {
02126 conditions_layer_Jacobian = conditions_layer_pointer->calculate_Jacobian(inputs, outputs, Jacobian);
02127
02128 outputs = conditions_layer_pointer->calculate_outputs(inputs, outputs);
02129 }
02130
02131 if(conditions_layer_flag)
02132 {
02133 Jacobian = Jacobian.dot(conditions_layer_Jacobian);
02134 }
02135
02136
02137 return(Jacobian);
02138 }
02139
02140
02141
02142
02145
02146 Matrix<double> NeuralNetwork::calculate_parameters_Jacobian(const Vector<double>& inputs, const Vector<double>& parameters) const
02147 {
02148 return(multilayer_perceptron_pointer->calculate_parameters_Jacobian(inputs, parameters));
02149 }
02150
02151
02152
02153
02156
02157 Vector< Matrix<double> > NeuralNetwork::calculate_Hessian_form(const Vector<double>& inputs) const
02158 {
02159 return(multilayer_perceptron_pointer->calculate_Hessian_form(inputs));
02160 }
02161
02162
02163
02164
02167
02168 Vector< Matrix<double> > NeuralNetwork::calculate_parameters_Hessian_form(const Vector<double>& inputs, const Vector<double>& parameters) const
02169 {
02170 return(multilayer_perceptron_pointer->calculate_parameters_Hessian_form(inputs, parameters));
02171 }
02172
02173
02174
02175
02187
02188 void NeuralNetwork::set_inputs_outputs_information(const Vector< Vector<std::string> >& new_inputs_outputs_information)
02189 {
02190 if(!multilayer_perceptron_pointer)
02191 {
02192 std::ostringstream buffer;
02193
02194 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02195 << "void set_inputs_outputs_information(const Vector< Vector<std::string> >&) method.\n"
02196 << "Pointer to multilayer perceptron is NULL.\n";
02197
02198 throw std::logic_error(buffer.str());
02199 }
02200
02201 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
02202 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
02203
02204 #ifdef _DEBUG
02205
02206 const unsigned int size = new_inputs_outputs_information.size();
02207
02208 if(size != 6)
02209 {
02210 std::ostringstream buffer;
02211
02212 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02213 << "void set_inputs_outputs_information(const Vector< Vector<std::string> >&) method.\n"
02214 << "Size of vector must be 6.\n";
02215
02216 throw std::logic_error(buffer.str());
02217 }
02218
02219 for(unsigned int i = 0; i < 3; i++)
02220 {
02221 if(new_inputs_outputs_information[i].size() != inputs_number)
02222 {
02223 std::ostringstream buffer;
02224
02225 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02226 << "void set_inputs_outputs_information(const Vector< Vector<std::string> >&) method.\n"
02227 << "Size of subvector " << i << "must be equal to number of inputs.\n";
02228
02229 throw std::logic_error(buffer.str());
02230 }
02231 }
02232
02233 for(unsigned int i = 3; i < 6; i++)
02234 {
02235 if(new_inputs_outputs_information[i].size() != outputs_number)
02236 {
02237 std::ostringstream buffer;
02238
02239 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02240 << "void set_inputs_outputs_information(const Vector< Vector<std::string> >&) method.\n"
02241 << "Size of subvector " << i << "must be equal to number of outputs.\n";
02242
02243 throw std::logic_error(buffer.str());
02244 }
02245 }
02246
02247 #endif
02248
02249 if(!inputs_outputs_information_pointer)
02250 {
02251 inputs_outputs_information_pointer = new InputsOutputsInformation(inputs_number, outputs_number);
02252 }
02253
02254 inputs_outputs_information_pointer->set_inputs_name(new_inputs_outputs_information[0]);
02255 inputs_outputs_information_pointer->set_inputs_units(new_inputs_outputs_information[1]);
02256 inputs_outputs_information_pointer->set_inputs_description(new_inputs_outputs_information[2]);
02257
02258 inputs_outputs_information_pointer->set_outputs_name(new_inputs_outputs_information[3]);
02259 inputs_outputs_information_pointer->set_outputs_units(new_inputs_outputs_information[4]);
02260 inputs_outputs_information_pointer->set_outputs_description(new_inputs_outputs_information[5]);
02261 }
02262
02263
02264
02265
02276
02277 Vector< Vector<std::string> > NeuralNetwork::arrange_inputs_outputs_information(void)
02278 {
02279 if(!inputs_outputs_information_pointer)
02280 {
02281 if(!multilayer_perceptron_pointer)
02282 {
02283 std::ostringstream buffer;
02284
02285 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02286 << "Vector< Vector<std::string> > arrange_inputs_outputs_information(void) method.\n"
02287 << "Pointer to multilayer perceptron is NULL.\n";
02288
02289 throw std::logic_error(buffer.str());
02290 }
02291
02292 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
02293 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
02294
02295 inputs_outputs_information_pointer = new InputsOutputsInformation(inputs_number, outputs_number);
02296 }
02297
02298 Vector< Vector<std::string> > inputs_outputs_information(6);
02299
02300 inputs_outputs_information[0] = inputs_outputs_information_pointer->get_inputs_name();
02301 inputs_outputs_information[1] = inputs_outputs_information_pointer->get_inputs_units();
02302 inputs_outputs_information[2] = inputs_outputs_information_pointer->get_inputs_description();
02303
02304 inputs_outputs_information[3] = inputs_outputs_information_pointer->get_outputs_name();
02305 inputs_outputs_information[4] = inputs_outputs_information_pointer->get_outputs_units();
02306 inputs_outputs_information[5] = inputs_outputs_information_pointer->get_outputs_description();
02307
02308 return(inputs_outputs_information);
02309 }
02310
02311
02312
02313
02326
02327 Vector< Vector<double> > NeuralNetwork::arrange_inputs_outputs_statistics(void)
02328 {
02329 if(!scaling_layer_pointer)
02330 {
02331 if(!multilayer_perceptron_pointer)
02332 {
02333 std::ostringstream buffer;
02334
02335 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02336 << "Vector< Vector<double> > arrange_inputs_outputs_statistics(void) method.\n"
02337 << "Pointer to multilayer perceptron is NULL.\n";
02338
02339 throw std::logic_error(buffer.str());
02340 }
02341
02342 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
02343
02344 scaling_layer_pointer = new ScalingLayer(inputs_number);
02345 }
02346
02347 if(!unscaling_layer_pointer)
02348 {
02349 if(!multilayer_perceptron_pointer)
02350 {
02351 std::ostringstream buffer;
02352
02353 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02354 << "Vector< Vector<double> > arrange_inputs_outputs_statistics(void) method.\n"
02355 << "Pointer to multilayer perceptron is NULL.\n";
02356
02357 throw std::logic_error(buffer.str());
02358 }
02359
02360 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
02361
02362 unscaling_layer_pointer = new UnscalingLayer(outputs_number);
02363 }
02364
02365 Vector< Vector<double> > statistics(8);
02366
02367 statistics[0] = scaling_layer_pointer->get_minimums();
02368 statistics[1] = scaling_layer_pointer->get_maximums();
02369
02370 statistics[2] = scaling_layer_pointer->get_means();
02371 statistics[3] = scaling_layer_pointer->get_standard_deviations();
02372
02373 statistics[4] = unscaling_layer_pointer->get_minimums();
02374 statistics[5] = unscaling_layer_pointer->get_maximums();
02375
02376 statistics[6] = unscaling_layer_pointer->get_means();
02377 statistics[7] = unscaling_layer_pointer->get_standard_deviations();
02378
02379 return(statistics);
02380 }
02381
02382
02383
02384
02394
02395 void NeuralNetwork::set_inputs_outputs_minimums_maximums(const Vector< Vector<double> >& new_inputs_outputs_minimum_maximum)
02396 {
02397 if(!multilayer_perceptron_pointer)
02398 {
02399 std::ostringstream buffer;
02400
02401 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02402 << "void set_inputs_outputs_minimum_maximum(const Vector< Vector<double> >&) method.\n"
02403 << "Multilayer perceptron pointer is NULL.\n";
02404
02405 throw std::logic_error(buffer.str());
02406 }
02407
02408 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
02409 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
02410
02411
02412
02413 #ifdef _DEBUG
02414
02415 if(new_inputs_outputs_minimum_maximum.size() != 4)
02416 {
02417 std::ostringstream buffer;
02418
02419 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02420 << "void set_variables_minimum_maximum(const Vector< Vector<double> >&) method.\n"
02421 << "Size of inputs-outputs minimums and maximums vector must be 4.\n";
02422
02423 throw std::logic_error(buffer.str());
02424
02425 return;
02426 }
02427
02428
02429
02430 for(unsigned int i = 0; i < 2; i++)
02431 {
02432 if(new_inputs_outputs_minimum_maximum[i].size() != inputs_number)
02433 {
02434 std::ostringstream buffer;
02435
02436 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02437 << "void set_variables_minimum_maximum(const Vector< Vector<double> >&) method.\n"
02438 << "Size of element " << i << " must be equal to number of inputs.\n";
02439
02440 throw std::logic_error(buffer.str());
02441
02442 return;
02443 }
02444 }
02445
02446 for(unsigned int i = 2; i < 4; i++)
02447 {
02448 if(new_inputs_outputs_minimum_maximum[i].size() != outputs_number)
02449 {
02450 std::ostringstream buffer;
02451
02452 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02453 << "void set_variables_minimum_maximum(const Vector< Vector<double> >&) method.\n"
02454 << "Size of element " << i << " must be equal to number of outputs.\n";
02455
02456 throw std::logic_error(buffer.str());
02457 }
02458 }
02459
02460 #endif
02461
02462
02463
02464 if(!scaling_layer_pointer)
02465 {
02466 scaling_layer_pointer = new ScalingLayer(inputs_number);
02467 }
02468
02469 scaling_layer_pointer->set_minimums(new_inputs_outputs_minimum_maximum[0]);
02470 scaling_layer_pointer->set_maximums(new_inputs_outputs_minimum_maximum[1]);
02471
02472
02473
02474 if(!unscaling_layer_pointer)
02475 {
02476 unscaling_layer_pointer = new UnscalingLayer(outputs_number);
02477 }
02478
02479 unscaling_layer_pointer->set_minimums(new_inputs_outputs_minimum_maximum[2]);
02480 unscaling_layer_pointer->set_maximums(new_inputs_outputs_minimum_maximum[3]);
02481 }
02482
02483
02484
02485
02495
02496 void NeuralNetwork::set_inputs_outputs_means_standard_deviations(const Vector< Vector<double> >& new_inputs_outputs_mean_standard_deviation)
02497 {
02498 if(!multilayer_perceptron_pointer)
02499 {
02500 std::ostringstream buffer;
02501
02502 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02503 << "void set_inputs_outputs_means_standard_deviations(const Vector< Vector<double> >&) method.\n"
02504 << "Multilayer perceptron pointer is NULL.\n";
02505
02506 throw std::logic_error(buffer.str());
02507 }
02508
02509 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
02510 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
02511
02512
02513
02514 #ifdef _DEBUG
02515
02516 const unsigned int new_variables_mean_standard_deviation_size = new_inputs_outputs_mean_standard_deviation.size();
02517
02518 if(new_variables_mean_standard_deviation_size != 4)
02519 {
02520 std::ostringstream buffer;
02521
02522 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02523 << "void set_inputs_outputs_mean_standard_deviation(const Vector< Vector<double> >&) method.\n"
02524 << "Size must be 4.\n";
02525
02526 throw std::logic_error(buffer.str());
02527
02528 return;
02529 }
02530
02531 unsigned int size;
02532
02533
02534
02535 for(unsigned int i = 0; i < 2; i++)
02536 {
02537 size = new_inputs_outputs_mean_standard_deviation[i].size();
02538
02539 if(size != inputs_number)
02540 {
02541 std::ostringstream buffer;
02542
02543 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02544 << "void set_inputs_outputs_mean_standard_deviation(const Vector< Vector<double> >&) method.\n"
02545 << "Size of element " << i << " must be equal to number of inputs.\n";
02546
02547 throw std::logic_error(buffer.str());
02548
02549 return;
02550 }
02551 }
02552
02553
02554
02555 for(unsigned int i = 2; i < 4; i++)
02556 {
02557 size = new_inputs_outputs_mean_standard_deviation[i].size();
02558
02559 if(size != outputs_number)
02560 {
02561 std::ostringstream buffer;
02562
02563 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02564 << "void set_inputs_outputs_mean_standard_deviation(const Vector< Vector<double> >&) method.\n"
02565 << "Size of element " << i << " must be equal to number of outputs.\n";
02566
02567 throw std::logic_error(buffer.str());
02568 }
02569 }
02570
02571 #endif
02572
02573
02574
02575 if(!scaling_layer_pointer)
02576 {
02577 scaling_layer_pointer = new ScalingLayer(inputs_number);
02578 }
02579
02580 scaling_layer_pointer->set_means(new_inputs_outputs_mean_standard_deviation[0]);
02581 scaling_layer_pointer->set_standard_deviations(new_inputs_outputs_mean_standard_deviation[1]);
02582
02583
02584
02585 if(!unscaling_layer_pointer)
02586 {
02587 unscaling_layer_pointer = new UnscalingLayer(outputs_number);
02588 }
02589
02590 unscaling_layer_pointer->set_means(new_inputs_outputs_mean_standard_deviation[2]);
02591 unscaling_layer_pointer->set_standard_deviations(new_inputs_outputs_mean_standard_deviation[3]);
02592 }
02593
02594
02595
02596
02610
02611 void NeuralNetwork::set_inputs_outputs_statistics(const Vector< Vector<double> >& new_inputs_outputs_statistics)
02612 {
02613 if(!multilayer_perceptron_pointer)
02614 {
02615 std::ostringstream buffer;
02616
02617 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02618 << "void set_inputs_outputs_statistics(const Vector< Vector<double> >&) method.\n"
02619 << "Multilayer perceptron pointer is NULL.\n";
02620
02621 throw std::logic_error(buffer.str());
02622 }
02623
02624 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
02625 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
02626
02627
02628
02629 #ifdef _DEBUG
02630
02631 std::ostringstream buffer;
02632
02633 const unsigned int new_statistics_size = new_inputs_outputs_statistics.size();
02634
02635 if(new_statistics_size != 8)
02636 {
02637 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02638 << "void set_inputs_outputs_statistics(const Vector< Vector<double> >&) method.\n"
02639 << "Size must be 8.\n";
02640
02641 throw std::logic_error(buffer.str());
02642 }
02643
02644 unsigned int size;
02645
02646 for(unsigned int i = 0; i < 4; i++)
02647 {
02648 size = new_inputs_outputs_statistics[i].size();
02649
02650 if(size != inputs_number)
02651 {
02652 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02653 << "void set_inputs_outputs_statistics(const Vector< Vector<double> >&) method.\n"
02654 << "Size of element " << i << " must be equal to number of inputs.\n";
02655
02656 throw std::logic_error(buffer.str());
02657 }
02658 }
02659
02660 for(unsigned int i = 4; i < 8; i++)
02661 {
02662 size = new_inputs_outputs_statistics[i].size();
02663
02664 if(size != outputs_number)
02665 {
02666 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02667 << "void set_variables_statistics(const Vector< Vector<double> >&) method.\n"
02668 << "Size of element " << i << " must be equal to number of outputs.\n";
02669
02670 throw std::logic_error(buffer.str());
02671 }
02672 }
02673
02674 #endif
02675
02676
02677
02678 if(!scaling_layer_pointer)
02679 {
02680 scaling_layer_pointer = new ScalingLayer(inputs_number);
02681 }
02682
02683 scaling_layer_pointer->set_minimums(new_inputs_outputs_statistics[0]);
02684 scaling_layer_pointer->set_maximums(new_inputs_outputs_statistics[1]);
02685 scaling_layer_pointer->set_means(new_inputs_outputs_statistics[2]);
02686 scaling_layer_pointer->set_standard_deviations(new_inputs_outputs_statistics[3]);
02687
02688 if(!unscaling_layer_pointer)
02689 {
02690 unscaling_layer_pointer = new UnscalingLayer(outputs_number);
02691 }
02692
02693 unscaling_layer_pointer->set_minimums(new_inputs_outputs_statistics[4]);
02694 unscaling_layer_pointer->set_maximums(new_inputs_outputs_statistics[5]);
02695 unscaling_layer_pointer->set_means(new_inputs_outputs_statistics[6]);
02696 unscaling_layer_pointer->set_standard_deviations(new_inputs_outputs_statistics[7]);
02697 }
02698
02699
02700
02701
02705
02706 void NeuralNetwork::set_inputs_scaling_outputs_unscaling_methods(const std::string& new_inputs_scaling_outputs_unscaling_methods)
02707 {
02708 if(new_inputs_scaling_outputs_unscaling_methods == "MinimumMaximum")
02709 {
02710 scaling_layer_pointer->set_scaling_method(ScalingLayer::MinimumMaximum);
02711 unscaling_layer_pointer->set_unscaling_method(UnscalingLayer::MinimumMaximum);
02712 }
02713 else if(new_inputs_scaling_outputs_unscaling_methods == "MeanStandardDeviation")
02714 {
02715 scaling_layer_pointer->set_scaling_method(ScalingLayer::MeanStandardDeviation);
02716 unscaling_layer_pointer->set_unscaling_method(UnscalingLayer::MeanStandardDeviation);
02717 }
02718 else
02719 {
02720 std::ostringstream buffer;
02721
02722 buffer << "OpenNN Exception: NeuralNetwork class.\n"
02723 << "void new_inputs_scaling_outputs_unscaling_methods(const std::string&) method.\n"
02724 << "Unknown scaling/unscaling method: " << new_inputs_scaling_outputs_unscaling_methods << ".\n";
02725
02726 throw std::logic_error(buffer.str());
02727 }
02728 }
02729
02730
02731
02732
02734
02735 std::string NeuralNetwork::to_string(void) const
02736 {
02737 std::ostringstream buffer;
02738
02739 buffer << "NeuralNetwork\n";
02740
02741
02742
02743 if(multilayer_perceptron_pointer)
02744 {
02745 buffer << multilayer_perceptron_pointer->to_string();
02746 }
02747
02748
02749
02750 if(scaling_layer_pointer)
02751 {
02752 buffer << scaling_layer_pointer->to_string();
02753 }
02754
02755
02756
02757 if(unscaling_layer_pointer)
02758 {
02759 buffer << unscaling_layer_pointer->to_string();
02760 }
02761
02762
02763
02764 if(bounding_layer_pointer)
02765 {
02766 buffer << bounding_layer_pointer->to_string();
02767 }
02768
02769
02770
02771 if(probabilistic_layer_pointer)
02772 {
02773 buffer << probabilistic_layer_pointer->to_string();
02774 }
02775
02776
02777
02778 if(conditions_layer_pointer)
02779 {
02780 buffer << conditions_layer_pointer->to_string();
02781 }
02782
02783
02784
02785 if(inputs_outputs_information_pointer)
02786 {
02787 buffer << inputs_outputs_information_pointer->to_string();
02788 }
02789
02790
02791
02792 if(independent_parameters_pointer)
02793 {
02794 buffer << independent_parameters_pointer->to_string();
02795 }
02796
02797 buffer << "Multilayer perceptron flag: " << multilayer_perceptron_flag << "\n"
02798 << "Scaling layer flag: " << scaling_layer_flag << "\n"
02799 << "Unscaling layer flag: " << unscaling_layer_flag << "\n"
02800 << "Bounding layer flag: " << bounding_layer_flag << "\n"
02801 << "Probabilistic layer flag: " << probabilistic_layer_flag << "\n"
02802 << "Conditions layer flag: " << conditions_layer_flag << "\n"
02803 << "Display: " << display << "\n";
02804
02805 return(buffer.str());
02806 }
02807
02808
02809
02810
02813
02814 TiXmlElement* NeuralNetwork::to_XML(void) const
02815 {
02816 std::ostringstream buffer;
02817
02818 TiXmlElement* neural_network_element = new TiXmlElement("NeuralNetwork");
02819 neural_network_element->SetAttribute("Version", 4);
02820
02821
02822
02823 if(inputs_outputs_information_pointer)
02824 {
02825 TiXmlElement* element = inputs_outputs_information_pointer->to_XML();
02826 neural_network_element->LinkEndChild(element);
02827 }
02828
02829
02830
02831 if(multilayer_perceptron_pointer)
02832 {
02833 TiXmlElement* element = multilayer_perceptron_pointer->to_XML();
02834 neural_network_element->LinkEndChild(element);
02835 }
02836
02837
02838
02839 if(scaling_layer_pointer)
02840 {
02841 TiXmlElement* element = scaling_layer_pointer->to_XML();
02842 neural_network_element->LinkEndChild(element);
02843 }
02844
02845
02846
02847 if(unscaling_layer_pointer)
02848 {
02849 TiXmlElement* element = unscaling_layer_pointer->to_XML();
02850 neural_network_element->LinkEndChild(element);
02851 }
02852
02853
02854
02855 if(probabilistic_layer_pointer)
02856 {
02857 TiXmlElement* element = probabilistic_layer_pointer->to_XML();
02858 neural_network_element->LinkEndChild(element);
02859 }
02860
02861
02862
02863 if(bounding_layer_pointer)
02864 {
02865 TiXmlElement* element = bounding_layer_pointer->to_XML();
02866 neural_network_element->LinkEndChild(element);
02867 }
02868
02869
02870
02871 if(conditions_layer_pointer)
02872 {
02873 TiXmlElement* element = conditions_layer_pointer->to_XML();
02874 neural_network_element->LinkEndChild(element);
02875 }
02876
02877
02878
02879 if(independent_parameters_pointer)
02880 {
02881 TiXmlElement* element = independent_parameters_pointer->to_XML();
02882 neural_network_element->LinkEndChild(element);
02883 }
02884
02885
02886 {
02887 TiXmlElement* scaling_layer_flag_element = new TiXmlElement("ScalingLayerFlag");
02888 neural_network_element->LinkEndChild(scaling_layer_flag_element);
02889
02890 buffer.str("");
02891 buffer << scaling_layer_flag;
02892
02893 TiXmlText* scaling_layer_flag_text = new TiXmlText(buffer.str().c_str());
02894 scaling_layer_flag_element->LinkEndChild(scaling_layer_flag_text);
02895 }
02896
02897
02898 {
02899 TiXmlElement* element = new TiXmlElement("UnscalingLayerFlag");
02900 neural_network_element->LinkEndChild(element);
02901
02902 buffer.str("");
02903 buffer << unscaling_layer_flag;
02904
02905 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02906 element->LinkEndChild(text);
02907 }
02908
02909
02910 {
02911 TiXmlElement* element = new TiXmlElement("ProbabilisticLayerFlag");
02912 neural_network_element->LinkEndChild(element);
02913
02914 buffer.str("");
02915 buffer << probabilistic_layer_flag;
02916
02917 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02918 element->LinkEndChild(text);
02919 }
02920
02921
02922 {
02923 TiXmlElement* bounding_layer_flag_element = new TiXmlElement("BoundingLayerFlag");
02924 neural_network_element->LinkEndChild(bounding_layer_flag_element);
02925
02926 buffer.str("");
02927 buffer << bounding_layer_flag;
02928
02929 TiXmlText* bounding_layer_flag_text = new TiXmlText(buffer.str().c_str());
02930 bounding_layer_flag_element->LinkEndChild(bounding_layer_flag_text);
02931 }
02932
02933
02934 {
02935 TiXmlElement* conditions_layer_flag_element = new TiXmlElement("ConditionsLayerFlag");
02936 neural_network_element->LinkEndChild(conditions_layer_flag_element);
02937
02938 buffer.str("");
02939 buffer << conditions_layer_flag;
02940
02941 TiXmlText* conditions_layer_flag_text = new TiXmlText(buffer.str().c_str());
02942 conditions_layer_flag_element->LinkEndChild(conditions_layer_flag_text);
02943 }
02944
02945
02946 {
02947 TiXmlElement* display_element = new TiXmlElement("Display");
02948 neural_network_element->LinkEndChild(display_element);
02949
02950 buffer.str("");
02951 buffer << display;
02952
02953 TiXmlText* display_text = new TiXmlText(buffer.str().c_str());
02954 display_element->LinkEndChild(display_text);
02955 }
02956
02957 return(neural_network_element);
02958 }
02959
02960
02961
02962
02965
02966 void NeuralNetwork::from_XML(TiXmlElement* neural_network_element)
02967 {
02968 if(neural_network_element)
02969 {
02970
02971
02972 {
02973 TiXmlElement* multilayer_perceptron_element = neural_network_element->FirstChildElement("MultilayerPerceptron");
02974
02975 if(multilayer_perceptron_element)
02976 {
02977 if(!multilayer_perceptron_pointer)
02978 {
02979 multilayer_perceptron_pointer = new MultilayerPerceptron();
02980 }
02981
02982 multilayer_perceptron_pointer->from_XML(multilayer_perceptron_element);
02983 }
02984 }
02985
02986
02987 {
02988 TiXmlElement* scaling_layer_element = neural_network_element->FirstChildElement("ScalingLayer");
02989
02990 if(scaling_layer_element)
02991 {
02992 if(!scaling_layer_pointer)
02993 {
02994 scaling_layer_pointer = new ScalingLayer();
02995 }
02996
02997 scaling_layer_pointer->from_XML(scaling_layer_element);
02998 }
02999 }
03000
03001
03002 {
03003 TiXmlElement* unscaling_layer_element = neural_network_element->FirstChildElement("UnscalingLayer");
03004
03005 if(unscaling_layer_element)
03006 {
03007 if(!unscaling_layer_pointer)
03008 {
03009 unscaling_layer_pointer = new UnscalingLayer();
03010 }
03011
03012 unscaling_layer_pointer->from_XML(unscaling_layer_element);
03013 }
03014 }
03015
03016
03017 {
03018 TiXmlElement* bounding_layer_element = neural_network_element->FirstChildElement("BoundingLayer");
03019
03020 if(bounding_layer_element)
03021 {
03022 if(!bounding_layer_pointer)
03023 {
03024 bounding_layer_pointer = new BoundingLayer();
03025 }
03026
03027 bounding_layer_pointer->from_XML(bounding_layer_element);
03028 }
03029 }
03030
03031
03032 {
03033 TiXmlElement* probabilistic_layer_element = neural_network_element->FirstChildElement("ProbabilisticLayer");
03034
03035 if(probabilistic_layer_element)
03036 {
03037 if(!probabilistic_layer_pointer)
03038 {
03039 probabilistic_layer_pointer = new ProbabilisticLayer();
03040 }
03041
03042 probabilistic_layer_pointer->from_XML(probabilistic_layer_element);
03043 }
03044 }
03045
03046
03047 {
03048 TiXmlElement* conditions_layer_element = neural_network_element->FirstChildElement("ConditionsLayer");
03049
03050 if(conditions_layer_element)
03051 {
03052 if(!conditions_layer_pointer)
03053 {
03054 conditions_layer_pointer = new ConditionsLayer();
03055 }
03056
03057 conditions_layer_pointer->from_XML(conditions_layer_element);
03058 }
03059 }
03060
03061
03062 {
03063 TiXmlElement* inputs_outputs_information_element = neural_network_element->FirstChildElement("InputsOutputsInformation");
03064
03065 if(inputs_outputs_information_element)
03066 {
03067 if(!inputs_outputs_information_pointer)
03068 {
03069 inputs_outputs_information_pointer = new InputsOutputsInformation();
03070 }
03071
03072 inputs_outputs_information_pointer->from_XML(inputs_outputs_information_element);
03073 }
03074 }
03075
03076
03077 {
03078 TiXmlElement* independent_parameters_element = neural_network_element->FirstChildElement("IndependentParameters");
03079
03080 if(independent_parameters_element)
03081 {
03082 if(!independent_parameters_pointer)
03083 {
03084 independent_parameters_pointer = new IndependentParameters();
03085 }
03086
03087 independent_parameters_pointer->from_XML(independent_parameters_element);
03088 }
03089 }
03090
03091
03092 {
03093 TiXmlElement* multilayer_perceptron_flag_element = neural_network_element->FirstChildElement("MultilayerPerceptronFlag");
03094
03095 if(multilayer_perceptron_flag_element)
03096 {
03097 std::string new_multilayer_perceptron_flag_string = multilayer_perceptron_flag_element->GetText();
03098
03099 try
03100 {
03101 set_multilayer_perceptron_flag(new_multilayer_perceptron_flag_string != "0");
03102 }
03103 catch(std::exception& e)
03104 {
03105 std::cout << e.what() << std::endl;
03106 }
03107 }
03108 }
03109
03110
03111 {
03112 TiXmlElement* scaling_layer_flag_element = neural_network_element->FirstChildElement("ScalingLayerFlag");
03113
03114 if(scaling_layer_flag_element)
03115 {
03116 std::string new_scaling_layer_flag_string = scaling_layer_flag_element->GetText();
03117
03118 try
03119 {
03120 set_scaling_layer_flag(new_scaling_layer_flag_string != "0");
03121 }
03122 catch(std::exception& e)
03123 {
03124 std::cout << e.what() << std::endl;
03125 }
03126 }
03127 }
03128
03129
03130 {
03131 TiXmlElement* unscaling_layer_flag_element = neural_network_element->FirstChildElement("UnscalingLayerFlag");
03132
03133 if(unscaling_layer_flag_element)
03134 {
03135 std::string new_unscaling_layer_flag_string = unscaling_layer_flag_element->GetText();
03136
03137 try
03138 {
03139 set_unscaling_layer_flag(new_unscaling_layer_flag_string != "0");
03140 }
03141 catch(std::exception& e)
03142 {
03143 std::cout << e.what() << std::endl;
03144 }
03145 }
03146 }
03147
03148
03149 {
03150 TiXmlElement* bounding_layer_flag_element = neural_network_element->FirstChildElement("BoundingLayerFlag");
03151
03152 if(bounding_layer_flag_element)
03153 {
03154 std::string new_bounding_layer_flag_string = bounding_layer_flag_element->GetText();
03155
03156 try
03157 {
03158 set_bounding_layer_flag(new_bounding_layer_flag_string != "0");
03159 }
03160 catch(std::exception& e)
03161 {
03162 std::cout << e.what() << std::endl;
03163 }
03164 }
03165 }
03166
03167
03168 {
03169 TiXmlElement* probabilistic_layer_flag_element = neural_network_element->FirstChildElement("ProbabilisticLayerFlag");
03170
03171 if(probabilistic_layer_flag_element)
03172 {
03173 std::string new_probabilistic_layer_flag_string = probabilistic_layer_flag_element->GetText();
03174
03175 try
03176 {
03177 set_probabilistic_layer_flag(new_probabilistic_layer_flag_string != "0");
03178 }
03179 catch(std::exception& e)
03180 {
03181 std::cout << e.what() << std::endl;
03182 }
03183 }
03184 }
03185
03186
03187 {
03188 TiXmlElement* conditions_layer_flag_element = neural_network_element->FirstChildElement("ConditionsLayerFlag");
03189
03190 if(conditions_layer_flag_element)
03191 {
03192 std::string new_conditions_layer_flag_string = conditions_layer_flag_element->GetText();
03193
03194 try
03195 {
03196 set_conditions_layer_flag(new_conditions_layer_flag_string != "0");
03197 }
03198 catch(std::exception& e)
03199 {
03200 std::cout << e.what() << std::endl;
03201 }
03202 }
03203 }
03204
03205
03206 {
03207 TiXmlElement* display_element = neural_network_element->FirstChildElement("Display");
03208
03209 if(display_element)
03210 {
03211 std::string new_display_string = display_element->GetText();
03212
03213 try
03214 {
03215 set_display(new_display_string != "0");
03216 }
03217 catch(std::exception& e)
03218 {
03219 std::cout << e.what() << std::endl;
03220 }
03221 }
03222 }
03223 }
03224 }
03225
03226
03227
03228
03230
03231 void NeuralNetwork::print(void) const
03232 {
03233 if(display)
03234 {
03235 std::cout << to_string();
03236 }
03237 }
03238
03239
03240
03241
03244
03245 void NeuralNetwork::save(const std::string& filename) const
03246 {
03247 TiXmlDocument document;
03248
03249
03250
03251 TiXmlDeclaration* declaration = new TiXmlDeclaration("1.0", "", "");
03252 document.LinkEndChild(declaration);
03253
03254
03255
03256 TiXmlElement* multilayer_perceptron_element = to_XML();
03257 document.LinkEndChild(multilayer_perceptron_element);
03258
03259
03260
03261 document.SaveFile(filename.c_str());
03262 }
03263
03264
03265
03266
03269
03270 void NeuralNetwork::save_parameters(const std::string& filename) const
03271 {
03272 std::ofstream file(filename.c_str());
03273
03274 if(!file.is_open())
03275 {
03276 std::ostringstream buffer;
03277
03278 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03279 << "void save_parameters(const std::string&) const method.\n"
03280 << "Cannot open parameters data file.\n";
03281
03282 throw std::logic_error(buffer.str());
03283 }
03284
03285 const Vector<double> parameters = arrange_parameters();
03286
03287 file << parameters << std::endl;
03288
03289
03290
03291 file.close();
03292 }
03293
03294
03295
03296
03300
03301 void NeuralNetwork::load(const std::string& filename)
03302 {
03303 std::ostringstream buffer;
03304
03305 TiXmlDocument document(filename.c_str());
03306
03307 if(!document.LoadFile())
03308 {
03309 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03310 << "void load(const std::string&) method.\n"
03311 << "Cannot load XML file " << filename << ".\n";
03312
03313 throw std::logic_error(buffer.str());
03314 }
03315
03316
03317
03318 TiXmlElement* neural_network_element = document.FirstChildElement();
03319
03320 if(!neural_network_element)
03321 {
03322 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03323 << "void load(const std::string&) method.\n"
03324 << "File " << filename << " is not a valid neural network file.\n";
03325
03326 throw std::logic_error(buffer.str());
03327 }
03328
03329 from_XML(neural_network_element);
03330 }
03331
03332
03333
03334
03338
03339 void NeuralNetwork::load_parameters(const std::string& filename)
03340 {
03341 std::ifstream file(filename.c_str());
03342
03343 if(!file.is_open())
03344 {
03345 std::ostringstream buffer;
03346
03347 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03348 << "void load_parameters(const std::string&) method.\n"
03349 << "Cannot open parameters data file.\n";
03350
03351 throw std::logic_error(buffer.str());
03352 }
03353
03354 const unsigned int parameters_number = count_parameters_number();
03355
03356 Vector<double> new_parameters(parameters_number);
03357
03358 new_parameters.load(filename);
03359
03360 set_parameters(new_parameters);
03361
03362 file.close();
03363 }
03364
03365
03366
03367
03369
03370 std::string NeuralNetwork::write_expression(void) const
03371 {
03372 std::ostringstream buffer;
03373
03374 #ifdef _DEBUG
03375
03376 if(!inputs_outputs_information_pointer)
03377 {
03378 buffer.str("");
03379
03380 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03381 << "std::string write_expression(void) const method.\n"
03382 << "Pointer to inputs-outputs information is NULL.\n";
03383
03384 throw std::logic_error(buffer.str());
03385 }
03386
03387 #endif
03388
03389
03390 #ifdef _DEBUG
03391
03392 if(!multilayer_perceptron_pointer)
03393 {
03394 buffer.str("");
03395
03396 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03397 << "std::string write_expression(void) const method.\n"
03398 << "Pointer to multilayer perceptron is NULL.\n";
03399
03400 throw std::logic_error(buffer.str());
03401 }
03402
03403 #endif
03404
03405 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
03406 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
03407
03408 const Vector<std::string> inputs_name = inputs_outputs_information_pointer->write_default_inputs_name();
03409 const Vector<std::string> outputs_name = inputs_outputs_information_pointer->write_default_outputs_name();
03410
03411
03412
03413 Vector<std::string> scaled_inputs_name(inputs_number);
03414
03415 for(unsigned int i = 0; i < inputs_number; i++)
03416 {
03417 buffer.str("");
03418
03419 buffer << "scaled_" << inputs_name[i];
03420
03421 scaled_inputs_name[i] = buffer.str();
03422 }
03423
03424
03425
03426 Vector<std::string> scaled_outputs_name(outputs_number);
03427
03428 for(unsigned int i = 0; i < outputs_number; i++)
03429 {
03430 buffer.str("");
03431
03432 buffer << "scaled_" << outputs_name[i];
03433
03434 scaled_outputs_name[i] = buffer.str();
03435 }
03436
03437
03438
03439 Vector<std::string> probabilistic_outputs_name(outputs_number);
03440
03441 for(unsigned int i = 0; i < outputs_number; i++)
03442 {
03443 buffer.str("");
03444
03445 buffer << "probabilistic_" << outputs_name[i];
03446
03447 probabilistic_outputs_name[i] = buffer.str();
03448 }
03449
03450 buffer.str("");
03451
03452
03453
03454 if(scaling_layer_flag)
03455 {
03456 buffer << scaling_layer_pointer->write_expression(inputs_name, scaled_inputs_name);
03457 }
03458
03459
03460
03461 if(multilayer_perceptron_flag)
03462 {
03463 if(scaling_layer_flag && unscaling_layer_flag)
03464 {
03465 buffer << multilayer_perceptron_pointer->write_expression(scaled_inputs_name, scaled_outputs_name);
03466 }
03467 else if(scaling_layer_flag)
03468 {
03469 buffer << multilayer_perceptron_pointer->write_expression(scaled_inputs_name, outputs_name);
03470 }
03471 else if(unscaling_layer_flag)
03472 {
03473 buffer << multilayer_perceptron_pointer->write_expression(inputs_name, scaled_outputs_name);
03474 }
03475 else
03476 {
03477 buffer << multilayer_perceptron_pointer->write_expression(inputs_name, outputs_name);
03478 }
03479 }
03480
03481
03482
03483 if(unscaling_layer_flag)
03484 {
03485 buffer << unscaling_layer_pointer->write_expression(scaled_outputs_name, outputs_name);
03486 }
03487
03488
03489
03490 if(probabilistic_layer_flag)
03491 {
03492 buffer << probabilistic_layer_pointer->write_expression(outputs_name, probabilistic_outputs_name);
03493 }
03494
03495
03496
03497 if(conditions_layer_flag)
03498 {
03499
03500 }
03501
03502 return(buffer.str());
03503 }
03504
03505
03506
03507
03510
03511 void NeuralNetwork::save_expression(const std::string& filename)
03512 {
03513 std::ofstream file(filename.c_str());
03514
03515 if(!file.is_open())
03516 {
03517 std::ostringstream buffer;
03518
03519 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03520 << "void save_expression(const std::string&) method.\n"
03521 << "Cannot open expression text file.\n";
03522
03523 throw std::logic_error(buffer.str());
03524 }
03525
03526 file << write_expression();
03527
03528 file.close();
03529 }
03530
03531
03532
03533
03536
03537 void NeuralNetwork::save_data(const std::string& filename) const
03538 {
03539 #ifdef _DEBUG
03540
03541 std::ostringstream buffer;
03542
03543 if(!multilayer_perceptron_pointer)
03544 {
03545 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03546 << "void save_data(const std::string&) const method.\n"
03547 << "Pointer to multilayer perceptron is NULL.\n";
03548
03549 throw std::logic_error(buffer.str());
03550 }
03551
03552 #endif
03553
03554 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
03555
03556 #ifdef _DEBUG
03557
03558 if(inputs_number != 1)
03559 {
03560 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03561 << "void save_data(const std::string&) const method.\n"
03562 << "Number of inputs is not 1.\n";
03563
03564 throw std::logic_error(buffer.str());
03565 }
03566
03567 #endif
03568
03569 #ifdef _DEBUG
03570
03571 if(!scaling_layer_pointer)
03572 {
03573 buffer << "OpenNN Exception: NeuralNetwork class.\n"
03574 << "void save_data(const std::string&) const method.\n"
03575 << "Pointer to scaling layer is NULL.\n";
03576
03577 throw std::logic_error(buffer.str());
03578 }
03579
03580 #endif
03581
03582 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
03583
03584 const unsigned int variables_number = inputs_number + outputs_number;
03585
03586 const Vector<double> inputs_minimums = scaling_layer_pointer->get_minimums();
03587 const Vector<double> inputs_maximums = scaling_layer_pointer->get_maximums();
03588
03589 const unsigned int points_number = 101;
03590
03591 Matrix<double> data(points_number, variables_number);
03592
03593 Vector<double> inputs(inputs_minimums);
03594 Vector<double> outputs(outputs_number);
03595 Vector<double> row(variables_number);
03596
03597 const Vector<double> increment = (inputs_maximums - inputs_minimums)/(double)(points_number-1.0);
03598
03599 for(unsigned int i = 0; i < points_number; i++)
03600 {
03601 outputs = calculate_outputs(inputs);
03602
03603 row = inputs.get_assembly(outputs);
03604
03605 data.set_row(i, row);
03606
03607 inputs += increment;
03608 }
03609
03610 data.save(filename);
03611 }
03612
03613
03615
03616
03617
03618
03619
03620
03621
03622
03623
03624
03625
03626
03627
03628
03629
03630
03631
03632
03633
03635
03636
03637
03638
03639
03640
03641
03642
03643
03644
03645
03646
03647
03648
03649
03650
03651
03652
03653
03654
03655
03656
03658
03659
03660
03661
03662
03663
03664
03665
03666
03667
03668
03669
03670
03671
03672
03673
03674
03675
03676
03677
03678
03679
03681
03682
03683
03684
03685
03686
03687
03688
03689
03690
03691
03692
03693
03694
03695
03696
03697
03698
03699
03700
03701
03702
03703
03704
03705
03706
03707
03708
03709
03710
03712
03713
03714
03715
03716
03717
03718
03719
03720
03721
03722
03723
03724
03725
03726
03727
03728
03729
03730
03731
03732
03733
03734
03735
03736
03737
03738
03739
03740
03741
03743
03744
03745
03746
03747
03748
03749
03750
03751
03752
03753
03754
03755
03756
03757
03758
03759
03760
03761
03762
03763
03764
03765
03766
03767
03768
03769
03770
03771
03772
03774
03775
03776
03777
03778
03779
03780
03781
03782
03783
03784
03785
03786
03787
03788
03789
03790
03791
03792
03793
03794
03795
03796
03797
03798
03799
03800
03801
03802
03803
03805
03809
03812
03815
03817
03820
03822
03825
03827
03830
03833
03834
03836
03837
03838
03839
03840
03841
03842
03843
03844
03845
03846
03847
03848
03849
03850
03851
03852
03853
03854
03855
03856
03857
03858
03859
03860
03861
03862
03863
03864
03865
03867
03868
03869
03870
03871
03872
03873
03874
03875
03876
03877
03878
03879
03880
03881
03882
03884
03887
03889
03892
03893
03894
03895
03896
03898
03899
03900
03901
03902
03903
03904
03905
03906
03907
03908
03909
03910
03911
03912
03913
03914
03915
03916
03917
03918
03919
03920
03921
03922
03923
03924
03925
03926
03927
03929
03933
03936
03939
03941
03944
03947
03948
03950
03951
03952
03953
03954
03955
03956
03957
03958 }
03959
03960
03961
03962
03963
03964
03965
03966
03967
03968
03969
03970
03971
03972
03973
03974
03975