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 "scaling_layer.h"
00028
00029 namespace OpenNN
00030 {
00031
00032
00033
00036
00037 ScalingLayer::ScalingLayer(void)
00038 {
00039 set();
00040 }
00041
00042
00043
00044
00049
00050 ScalingLayer::ScalingLayer(const unsigned int& new_scaling_neurons_number)
00051 {
00052 set(new_scaling_neurons_number);
00053 }
00054
00055
00056
00057
00062
00063 ScalingLayer::ScalingLayer(const Vector< Vector<double> >& new_statistics)
00064 {
00065 set(new_statistics);
00066 }
00067
00068
00069
00070
00072
00073 ScalingLayer::ScalingLayer(const ScalingLayer& new_scaling_layer)
00074 {
00075 set(new_scaling_layer);
00076 }
00077
00078
00079
00080
00082
00083 ScalingLayer::~ScalingLayer(void)
00084 {
00085 }
00086
00087
00088
00089
00090
00091
00094
00095 ScalingLayer& ScalingLayer::operator = (const ScalingLayer& other_scaling_layer)
00096 {
00097 if(this != &other_scaling_layer)
00098 {
00099 minimums = other_scaling_layer.minimums;
00100
00101 maximums = other_scaling_layer.maximums;
00102
00103 means = other_scaling_layer.means;
00104
00105 standard_deviations = other_scaling_layer.standard_deviations;
00106
00107 scaling_method = other_scaling_layer.scaling_method;
00108 display = other_scaling_layer.display;
00109 }
00110
00111 return(*this);
00112 }
00113
00114
00115
00116
00117
00118
00122
00123 bool ScalingLayer::operator == (const ScalingLayer& other_scaling_layer) const
00124 {
00125 if(minimums == other_scaling_layer.minimums
00126 && maximums == other_scaling_layer.maximums
00127 && means == other_scaling_layer.means
00128 && standard_deviations == other_scaling_layer.standard_deviations
00129 && scaling_method == other_scaling_layer.scaling_method
00130 && display == other_scaling_layer.display)
00131 {
00132 return(true);
00133 }
00134 else
00135 {
00136 return(false);
00137 }
00138 }
00139
00140
00141
00142
00144
00145 unsigned int ScalingLayer::count_scaling_neurons_number(void) const
00146 {
00147 return(minimums.size());
00148 }
00149
00150
00151
00152
00155
00156 const Vector<double>& ScalingLayer::get_maximums(void) const
00157 {
00158 return(maximums);
00159 }
00160
00161
00162
00163
00166
00167 double ScalingLayer::get_maximum(const unsigned int& i) const
00168 {
00169
00170
00171 #ifdef _DEBUG
00172
00173 const unsigned int inputs_number = count_scaling_neurons_number();
00174
00175 if(inputs_number == 0)
00176 {
00177 std::ostringstream buffer;
00178
00179 buffer << "OpenNN Exception: ScalingLayer class.\n"
00180 << "double get_maximum(const unsigned int&) const method.\n"
00181 << "Number of inputs is zero.\n";
00182
00183 throw std::logic_error(buffer.str());
00184 }
00185 else if(i >= inputs_number)
00186 {
00187 std::ostringstream buffer;
00188
00189 buffer << "OpenNN Exception: ScalingLayer class.\n"
00190 << "double get_maximum(const unsigned int&) const method.\n"
00191 << "Index must be less than number of scaling neurons.\n";
00192
00193 throw std::logic_error(buffer.str());
00194 }
00195
00196 #endif
00197
00198 return(maximums[i]);
00199 }
00200
00201
00202
00203
00206
00207 const Vector<double>& ScalingLayer::get_minimums(void) const
00208 {
00209 return(minimums);
00210 }
00211
00212
00213
00214
00217
00218 double ScalingLayer::get_minimum(const unsigned int& i) const
00219 {
00220
00221
00222 #ifdef _DEBUG
00223
00224 const unsigned int inputs_number = count_scaling_neurons_number();
00225
00226 if(inputs_number == 0)
00227 {
00228 std::ostringstream buffer;
00229
00230 buffer << "OpenNN Exception: ScalingLayer class.\n"
00231 << "double get_minimum(const unsigned int&) const method.\n"
00232 << "Number of inputs is zero.\n";
00233
00234 throw std::logic_error(buffer.str());
00235 }
00236 else if(i >= inputs_number)
00237 {
00238 std::ostringstream buffer;
00239
00240 buffer << "OpenNN Exception: ScalingLayer class.\n"
00241 << "double get_minimum(const unsigned int&) const method.\n"
00242 << "Index must be less than number of scaling neurons.\n";
00243
00244 throw std::logic_error(buffer.str());
00245 }
00246
00247 #endif
00248
00249 return(minimums[i]);
00250 }
00251
00252
00253
00254
00257
00258 const Vector<double>& ScalingLayer::get_means(void) const
00259 {
00260 return(means);
00261 }
00262
00263
00264
00265
00269
00270 double ScalingLayer::get_mean(const unsigned int& index) const
00271 {
00272
00273
00274 #ifdef _DEBUG
00275
00276 const unsigned int inputs_number = count_scaling_neurons_number();
00277
00278 if(index >= inputs_number)
00279 {
00280 std::ostringstream buffer;
00281
00282 buffer << "OpenNN Exception: ScalingLayer class.\n"
00283 << "double get_mean(const unsigned int&) const method.\n"
00284 << "Index of input variable must be less than number of scaling neurons.\n";
00285
00286 throw std::logic_error(buffer.str());
00287 }
00288
00289 #endif
00290
00291 return(means[index]);
00292 }
00293
00294
00295
00296
00299
00300 const Vector<double>& ScalingLayer::get_standard_deviations(void) const
00301 {
00302 return(standard_deviations);
00303 }
00304
00305
00306
00307
00311
00312 double ScalingLayer::get_standard_deviation(const unsigned int& index) const
00313 {
00314
00315
00316 #ifdef _DEBUG
00317
00318 const unsigned int inputs_number = count_scaling_neurons_number();
00319
00320 if(index >= inputs_number)
00321 {
00322 std::ostringstream buffer;
00323
00324 buffer << "OpenNN Exception: ScalingLayer class.\n"
00325 << "double get_standard_deviation(const unsigned int&) const method.\n"
00326 << "Index of input variable must be less than number of scaling neurons.\n";
00327
00328 throw std::logic_error(buffer.str());
00329 }
00330
00331 #endif
00332
00333 return(standard_deviations[index]);
00334 }
00335
00336
00337
00338
00344
00345 Vector< Vector<double>* > ScalingLayer::get_minimums_maximums(void)
00346 {
00347 Vector< Vector<double>* > minimums_maximums(2);
00348
00349 minimums_maximums[0] = &minimums;
00350 minimums_maximums[1] = &maximums;
00351
00352 return(minimums_maximums);
00353 }
00354
00355
00356
00357
00363
00364 Vector< Vector<double>* > ScalingLayer::get_means_standard_deviations(void)
00365 {
00366 Vector< Vector<double>* > means_standard_deviations(2);
00367
00368 means_standard_deviations[0] = &means;
00369 means_standard_deviations[1] = &standard_deviations;
00370
00371 return(means_standard_deviations);
00372 }
00373
00374
00375
00376
00385
00386 Vector< Vector<double>* > ScalingLayer::get_statistics(void)
00387 {
00388 Vector< Vector<double>* > statistics(4);
00389
00390 statistics[0] = &minimums;
00391 statistics[1] = &maximums;
00392 statistics[2] = &means;
00393 statistics[3] = &standard_deviations;
00394
00395 return(statistics);
00396 }
00397
00398
00399
00400
00402
00403 const ScalingLayer::ScalingMethod& ScalingLayer::get_scaling_method(void) const
00404 {
00405 return(scaling_method);
00406 }
00407
00408
00409
00410
00412
00413 std::string ScalingLayer::write_scaling_method(void) const
00414 {
00415 if(scaling_method == MeanStandardDeviation)
00416 {
00417 return("MeanStandardDeviation");
00418 }
00419 else if(scaling_method == MinimumMaximum)
00420 {
00421 return("MinimumMaximum");
00422 }
00423 else
00424 {
00425 std::ostringstream buffer;
00426
00427 buffer << "OpenNN Exception: ScalingLayer class.\n"
00428 << "std::string write_scaling_method(void) const method.\n"
00429 << "Unknown scaling method.\n";
00430
00431 throw std::logic_error(buffer.str());
00432 }
00433 }
00434
00435
00436
00437
00440
00441 const bool& ScalingLayer::get_display(void) const
00442 {
00443 return(display);
00444 }
00445
00446
00447
00448
00450
00451 void ScalingLayer::set(void)
00452 {
00453 minimums.set();
00454 maximums.set();
00455 means.set();
00456 standard_deviations.set();
00457
00458 set_default();
00459 }
00460
00461
00462
00463
00466
00467 void ScalingLayer::set(const unsigned int& new_inputs_number)
00468 {
00469 minimums.set(new_inputs_number, -1.0);
00470 maximums.set(new_inputs_number, 1.0);
00471 means.set(new_inputs_number, 0.0);
00472 standard_deviations.set(new_inputs_number, 1.0);
00473
00474 set_default();
00475 }
00476
00477
00478
00479
00484
00485 void ScalingLayer::set(const Vector< Vector<double> >& new_statistics)
00486 {
00487 minimums = new_statistics[0];
00488 maximums = new_statistics[1];
00489 means = new_statistics[2];
00490 standard_deviations = new_statistics[3];
00491
00492 set_default();
00493 }
00494
00495
00496
00497
00500
00501 void ScalingLayer::set(TiXmlElement* new_scaling_layer_element)
00502 {
00503 from_XML(new_scaling_layer_element);
00504 }
00505
00506
00507
00508
00511
00512 void ScalingLayer::set(const ScalingLayer& new_scaling_layer)
00513 {
00514 minimums = new_scaling_layer.minimums;
00515 maximums = new_scaling_layer.maximums;
00516 means = new_scaling_layer.means;
00517 standard_deviations = new_scaling_layer.standard_deviations;
00518
00519 scaling_method = new_scaling_layer.scaling_method;
00520
00521 display = new_scaling_layer.display;
00522 }
00523
00524
00525
00526
00536
00537 void ScalingLayer::set_default(void)
00538 {
00539 minimums.initialize(-1.0);
00540 maximums.initialize(1.0);
00541 means.initialize(0.0);
00542 standard_deviations.initialize(1.0);
00543
00544 set_scaling_method(MinimumMaximum);
00545
00546 set_display(true);
00547 }
00548
00549
00550
00551
00555
00556 void ScalingLayer::set_minimums(const Vector<double>& new_minimums)
00557 {
00558
00559
00560 #ifdef _DEBUG
00561
00562 const unsigned int inputs_number = count_scaling_neurons_number();
00563
00564 if(new_minimums.size() != inputs_number)
00565 {
00566 std::ostringstream buffer;
00567
00568 buffer << "OpenNN Exception: ScalingLayer class.\n"
00569 << "void set_minimums(const Vector<double>&) method.\n"
00570 << "Size must be equal to number of scaling neurons.\n";
00571
00572 throw std::logic_error(buffer.str());
00573 }
00574
00575 #endif
00576
00577
00578
00579 minimums = new_minimums;
00580
00581 }
00582
00583
00584
00585
00590
00591 void ScalingLayer::set_minimum(const unsigned int& index, const double& new_minimum)
00592 {
00593 const unsigned int inputs_number = count_scaling_neurons_number();
00594
00595
00596
00597 #ifdef _DEBUG
00598
00599 if(index >= inputs_number)
00600 {
00601 std::ostringstream buffer;
00602
00603 buffer << "OpenNN Exception: ScalingLayer class.\n"
00604 << "void set_minimum(const unsigned int&, const double&) method.\n"
00605 << "Index of variable must be less than number of scaling neurons.\n";
00606
00607 throw std::logic_error(buffer.str());
00608 }
00609
00610 #endif
00611
00612 if(minimums.size() == 0)
00613 {
00614 minimums.set(inputs_number, -1.0);
00615 }
00616
00617
00618
00619 minimums[index] = new_minimum;
00620 }
00621
00622
00623
00624
00628
00629 void ScalingLayer::set_maximums(const Vector<double>& new_maximum)
00630 {
00631
00632
00633 #ifdef _DEBUG
00634
00635 const unsigned int inputs_number = count_scaling_neurons_number();
00636
00637 if(new_maximum.size() != inputs_number)
00638 {
00639 std::ostringstream buffer;
00640
00641 buffer << "OpenNN Exception: ScalingLayer class.\n"
00642 << "void set_maximum(const Vector<double>&) method.\n"
00643 << "Size must be equal to number of scaling neurons.\n";
00644
00645 throw std::logic_error(buffer.str());
00646 }
00647
00648 #endif
00649
00650
00651
00652 maximums = new_maximum;
00653 }
00654
00655
00656
00657
00662
00663 void ScalingLayer::set_maximum(const unsigned int& index, const double& new_maximum)
00664 {
00665 const unsigned int inputs_number = count_scaling_neurons_number();
00666
00667
00668
00669 #ifdef _DEBUG
00670
00671 if(index >= inputs_number)
00672 {
00673 std::ostringstream buffer;
00674
00675 buffer << "OpenNN Exception: ScalingLayer class.\n"
00676 << "void set_maximum(const unsigned int&, const double&) method.\n"
00677 << "Index of input variable must be less than scaling neurons.\n";
00678
00679 throw std::logic_error(buffer.str());
00680 }
00681
00682 #endif
00683
00684 if(maximums.size() == 0)
00685 {
00686 maximums.set(inputs_number, 1.0);
00687 }
00688
00689
00690
00691 maximums[index] = new_maximum;
00692 }
00693
00694
00695
00696
00701
00702 void ScalingLayer::set_means(const Vector<double>& new_mean)
00703 {
00704
00705
00706 #ifdef _DEBUG
00707
00708 const unsigned int inputs_number = count_scaling_neurons_number();
00709
00710 if(new_mean.size() != inputs_number)
00711 {
00712 std::ostringstream buffer;
00713
00714 buffer << "OpenNN Exception: ScalingLayer class.\n"
00715 << "void set_means(const Vector<double>&) method.\n"
00716 << "Size must be equal to number of scaling neurons.\n";
00717
00718 throw std::logic_error(buffer.str());
00719 }
00720
00721 #endif
00722
00723
00724
00725 means = new_mean;
00726 }
00727
00728
00729
00730
00736
00737 void ScalingLayer::set_mean(const unsigned int& index, const double& new_mean)
00738 {
00739 const unsigned int inputs_number = count_scaling_neurons_number();
00740
00741
00742
00743 #ifdef _DEBUG
00744
00745 if(index >= inputs_number)
00746 {
00747 std::ostringstream buffer;
00748
00749 buffer << "OpenNN Exception: ScalingLayer class.\n"
00750 << "void set_mean(const unsigned int&, const double&) method.\n"
00751 << "Index of input variable must be less than number of scaling neurons.\n";
00752
00753 throw std::logic_error(buffer.str());
00754 }
00755
00756 #endif
00757
00758
00759
00760 if(means.size() != inputs_number)
00761 {
00762 means.set(inputs_number, 0.0);
00763 }
00764
00765
00766
00767 means[index] = new_mean;
00768 }
00769
00770
00771
00772
00778
00779 void ScalingLayer::set_standard_deviations(const Vector<double>& new_standard_deviation)
00780 {
00781
00782
00783 #ifdef _DEBUG
00784
00785 const unsigned int inputs_number = count_scaling_neurons_number();
00786
00787 if(new_standard_deviation.size() != inputs_number)
00788 {
00789 std::ostringstream buffer;
00790
00791 buffer << "OpenNN Exception: ScalingLayer class.\n"
00792 << "void set_standard_deviations(const Vector<double>&) method.\n"
00793 << "Size must be equal to number of scaling neurons.\n";
00794
00795 throw std::logic_error(buffer.str());
00796 }
00797
00798 #endif
00799
00800
00801
00802 standard_deviations = new_standard_deviation;
00803 }
00804
00805
00806
00807
00813
00814 void ScalingLayer::set_standard_deviation(const unsigned int& index, const double& new_standard_deviation)
00815 {
00816 const unsigned int inputs_number = count_scaling_neurons_number();
00817
00818
00819
00820 #ifdef _DEBUG
00821
00822 if(index >= inputs_number)
00823 {
00824 std::ostringstream buffer;
00825
00826 buffer << "OpenNN Exception: ScalingLayer class.\n"
00827 << "void set_standard_deviation(const unsigned int&, const double&) method.\n"
00828 << "Index of input variable must be less than number of scaling neurons.\n";
00829
00830 throw std::logic_error(buffer.str());
00831 }
00832
00833 #endif
00834
00835
00836
00837 if(standard_deviations.size() != inputs_number)
00838 {
00839 standard_deviations.set(inputs_number, 1.0);
00840 }
00841
00842
00843
00844 standard_deviations[index] = new_standard_deviation;
00845 }
00846
00847
00848
00849
00857
00858 void ScalingLayer::set_minimums_maximums(const Vector< Vector<double> >& new_minimums_maximums)
00859 {
00860
00861
00862 #ifdef _DEBUG
00863
00864 std::ostringstream buffer;
00865
00866 const unsigned int scaling_neurons_number = count_scaling_neurons_number();
00867
00868 if(new_minimums_maximums.size() != 2)
00869 {
00870 buffer << "OpenNN Exception: ScalingLayer class.\n"
00871 << "void set_minimums_maximums(const Vector< Vector<double> >&) method.\n"
00872 << "Size of minimums maximums vector must be 2.\n";
00873
00874 throw std::logic_error(buffer.str());
00875 }
00876
00877 if(new_minimums_maximums[0].size() != scaling_neurons_number)
00878 {
00879 buffer << "OpenNN Exception: ScalingLayer class.\n"
00880 << "void set_minimum_maximum(const Vector< Vector<double> >&) method.\n"
00881 << "Size of minimums (" << new_minimums_maximums[0].size() << ") must be equal to number of scaling neurons (" << scaling_neurons_number << ").\n";
00882
00883 throw std::logic_error(buffer.str());
00884 }
00885
00886 if(new_minimums_maximums[1].size() != scaling_neurons_number)
00887 {
00888 buffer << "OpenNN Exception: ScalingLayer class.\n"
00889 << "void set_minimum_maximum(const Vector< Vector<double> >&) method.\n"
00890 << "Size of maximums " << new_minimums_maximums[1].size() << " must be equal to number of scaling neurons (" << scaling_neurons_number << ").\n";
00891
00892 throw std::logic_error(buffer.str());
00893 }
00894
00895
00896
00897 for(unsigned int i = 0; i < scaling_neurons_number; i++)
00898 {
00899 if(new_minimums_maximums[0][i] >= new_minimums_maximums[1][i])
00900 {
00901 buffer << "OpenNN Exception: ScalingLayer class.\n"
00902 << "void set_minimum_maximum(const Vector< Vector<double> >&) method.\n"
00903 << "Minimum of variable " << i << " is equal or greater than maximum of that variable.\n";
00904
00905 throw std::logic_error(buffer.str());
00906 }
00907 }
00908
00909 #endif
00910
00911
00912
00913 minimums = new_minimums_maximums[0];
00914 maximums = new_minimums_maximums[1];
00915 }
00916
00917
00918
00919
00926
00927 void ScalingLayer::set_means_standard_deviations(const Vector< Vector<double> >& new_means_standard_deviations)
00928 {
00929
00930
00931 #ifdef _DEBUG
00932
00933 const unsigned int inputs_number = count_scaling_neurons_number();
00934
00935 if(new_means_standard_deviations.size() != 2)
00936 {
00937 std::ostringstream buffer;
00938
00939 buffer << "OpenNN Exception: ScalingLayer class.\n"
00940 << "void set_means_standard_deviations(const Vector< Vector<double> >&) method.\n"
00941 << "Size of vector must be 2.\n";
00942
00943 throw std::logic_error(buffer.str());
00944 }
00945 else if(new_means_standard_deviations[0].size() != inputs_number && new_means_standard_deviations[1].size() != inputs_number)
00946 {
00947 std::ostringstream buffer;
00948
00949 buffer << "OpenNN Exception: ScalingLayer class.\n"
00950 << "void set_means_standard_deviations(const Vector< Vector<double> >&) method.\n"
00951 << "Number of columns must be equal to number of scaling neurons.\n";
00952
00953 throw std::logic_error(buffer.str());
00954 }
00955
00956
00957
00958 for(unsigned int i = 0; i < inputs_number; i++)
00959 {
00960 if(new_means_standard_deviations[1][i] < 1.0e-99)
00961 {
00962 std::ostringstream buffer;
00963
00964 buffer << "OpenNN Exception: ScalingLayer class: \n"
00965 << "void set_means_standard_deviations(const Vector< Vector<double> >&) method.\n"
00966 << "Standard deviation of scaling neuron " << i << " is zero.\n";
00967
00968 throw std::logic_error(buffer.str());
00969 }
00970 }
00971
00972 #endif
00973
00974
00975
00976 means = new_means_standard_deviations[0];
00977 standard_deviations = new_means_standard_deviations[1];
00978 }
00979
00980
00981
00982
00992
00993 void ScalingLayer::set_statistics(const Vector< Vector<double> >& new_statistics)
00994 {
00995
00996
00997 #ifdef _DEBUG
00998
00999 const unsigned int new_statistics_size = new_statistics.size();
01000
01001 const unsigned int inputs_number = count_scaling_neurons_number();
01002
01003 if(new_statistics_size != 4)
01004 {
01005 std::ostringstream buffer;
01006
01007 buffer << "OpenNN Exception: ScalingLayer class.\n"
01008 << "void set_statistics(const Vector< Vector<double> >&) method.\n"
01009 << "Size must be 4.\n";
01010
01011 throw std::logic_error(buffer.str());
01012 }
01013
01014 unsigned int size;
01015
01016 for(unsigned int i = 0; i < 4; i++)
01017 {
01018 size = new_statistics[i].size();
01019
01020 if(size != inputs_number)
01021 {
01022 std::ostringstream buffer;
01023
01024 buffer << "OpenNN Exception: ScalingLayer class.\n"
01025 << "void set_statistics(const Vector< Vector<double> >&) method.\n"
01026 << "Size of element " << i << " must be equal to number of scaling neurons.\n";
01027
01028 throw std::logic_error(buffer.str());
01029 }
01030 }
01031
01032 #endif
01033
01034
01035
01036 set_means(new_statistics[0]);
01037 set_standard_deviations(new_statistics[1]);
01038 set_minimums(new_statistics[2]);
01039 set_maximums(new_statistics[3]);
01040 }
01041
01042
01043
01044
01047
01048 void ScalingLayer::set_scaling_method(const ScalingLayer::ScalingMethod& new_scaling_method)
01049 {
01050 scaling_method = new_scaling_method;
01051 }
01052
01053
01054
01055
01059
01060 void ScalingLayer::set_scaling_method(const std::string& new_scaling_method)
01061 {
01062 if(new_scaling_method == "MeanStandardDeviation")
01063 {
01064 set_scaling_method(MeanStandardDeviation);
01065 }
01066 else if(new_scaling_method == "MinimumMaximum")
01067 {
01068 set_scaling_method(MinimumMaximum);
01069 }
01070 else
01071 {
01072 std::ostringstream buffer;
01073
01074 buffer << "OpenNN Exception: ScalingLayer class.\n"
01075 << "void set_scaling_method(const std::string&) method.\n"
01076 << "Unknown scaling method: " << new_scaling_method << ".\n";
01077
01078 throw std::logic_error(buffer.str());
01079 }
01080 }
01081
01082
01083
01084
01089
01090 void ScalingLayer::set_display(const bool& new_display)
01091 {
01092 display = new_display;
01093 }
01094
01095
01096
01097
01099
01100 bool ScalingLayer::is_empty(void) const
01101 {
01102 const unsigned int inputs_number = count_scaling_neurons_number();
01103
01104 if(inputs_number == 0)
01105 {
01106 return(true);
01107 }
01108 else
01109 {
01110 return(false);
01111 }
01112 }
01113
01114
01115
01116
01122
01123 void ScalingLayer::check_range(const Vector<double>& inputs) const
01124 {
01125 const unsigned int inputs_number = count_scaling_neurons_number();
01126
01127
01128
01129 #ifdef _DEBUG
01130
01131 const unsigned int size = inputs.size();
01132
01133 if(size != inputs_number)
01134 {
01135 std::ostringstream buffer;
01136
01137 buffer << "OpenNN Exception: ScalingLayer class.\n"
01138 << "void check_range(const Vector<double>&) const method.\n"
01139 << "Size of inputs must be equal to number of inputs.\n";
01140
01141 throw std::logic_error(buffer.str());
01142 }
01143
01144 #endif
01145
01146
01147
01148 if(display)
01149 {
01150 if(minimums.size() != 0)
01151 {
01152 for(unsigned int i = 0; i < inputs_number; i++)
01153 {
01154 if(inputs[i] < minimums[i])
01155 {
01156 std::cout << "OpenNN Warning: ScalingLayer class.\n"
01157 << "void check_range(const Vector<double>&) const method.\n"
01158 << "Input variable " << i << " is less than minimums.\n";
01159 }
01160 }
01161 }
01162 if(maximums.size() != 0)
01163 {
01164 for(unsigned int i = 0; i < inputs_number; i++)
01165 {
01166 if(inputs[i] > maximums[i])
01167 {
01168 std::cout << "OpenNN Warning: ScalingLayer class.\n"
01169 << "void check_range(const Vector<double>&) const method.\n"
01170 << "Input variable " << i << " is greater than maximums.\n";
01171 }
01172 }
01173 }
01174 }
01175 }
01176
01177
01178
01179
01181
01182 void ScalingLayer::initialize_random(void)
01183 {
01184
01185 }
01186
01187
01188
01189
01192
01193 Vector<double> ScalingLayer::calculate_outputs(const Vector<double>& inputs) const
01194 {
01195
01196
01197 #ifdef _DEBUG
01198
01199 std::ostringstream buffer;
01200
01201 const unsigned int inputs_number = count_scaling_neurons_number();
01202
01203 const unsigned int size = inputs.size();
01204
01205 if(size != inputs_number)
01206 {
01207 buffer << "OpenNN Exception: ScalingLayer class.\n"
01208 << "Vector<double> calculate_outputs(const Vector<double>&) const method.\n"
01209 << "Size of inputs must be equal to number of scaling neurons.\n";
01210
01211 throw std::logic_error(buffer.str());
01212 }
01213
01214 #endif
01215
01216 switch(scaling_method)
01217 {
01218 case MinimumMaximum:
01219 {
01220 return(calculate_minimum_maximum_output(inputs));
01221 }
01222 break;
01223
01224 case MeanStandardDeviation:
01225 {
01226 return(calculate_mean_standard_deviation_output(inputs));
01227 }
01228 break;
01229
01230 default:
01231 {
01232 std::ostringstream buffer;
01233
01234 buffer << "OpenNN Exception: ScalingLayer class\n"
01235 << "Vector<double> calculate_outputs(const Vector<double>&) const method.\n"
01236 << "Unknown scaling and unscaling method.\n";
01237
01238 throw std::logic_error(buffer.str());
01239 }
01240 break;
01241 }
01242 }
01243
01244
01245
01246
01249
01250 Vector<double> ScalingLayer::calculate_derivative(const Vector<double>& dummy) const
01251 {
01252 switch(scaling_method)
01253 {
01254 case MinimumMaximum:
01255 {
01256 return(calculate_minimum_maximum_derivative(dummy));
01257 }
01258 break;
01259
01260 case MeanStandardDeviation:
01261 {
01262 return(calculate_mean_standard_deviation_derivative(dummy));
01263 }
01264 break;
01265
01266 default:
01267 {
01268 std::ostringstream buffer;
01269
01270 buffer << "OpenNN Exception: ScalingLayer class.\n"
01271 << "Vector<double> calculate_derivative(const Vector<double>&) const method.\n"
01272 << "Unknown scaling and unscaling method.\n";
01273
01274 throw std::logic_error(buffer.str());
01275 }
01276 break;
01277
01278 }
01279 }
01280
01281
01282
01283
01286
01287 Vector<double> ScalingLayer::calculate_second_derivative(const Vector<double>& dummy) const
01288 {
01289 switch(scaling_method)
01290 {
01291 case MinimumMaximum:
01292 {
01293 return(calculate_minimum_maximum_second_derivative(dummy));
01294 }
01295 break;
01296
01297 case MeanStandardDeviation:
01298 {
01299 return(calculate_mean_standard_deviation_second_derivative(dummy));
01300 }
01301 break;
01302
01303 default:
01304 {
01305 std::ostringstream buffer;
01306
01307 buffer << "OpenNN Exception: ScalingLayer class.\n"
01308 << "Vector<double> calculate_second_derivative(const Vector<double>&) const method.\n"
01309 << "Unknown scaling and unscaling method.\n";
01310
01311 throw std::logic_error(buffer.str());
01312 }
01313 break;
01314
01315 }
01316 }
01317
01318
01319
01320
01323
01324 Vector<double> ScalingLayer::calculate_minimum_maximum_output(const Vector<double>& inputs) const
01325 {
01326 const unsigned int scaling_neurons_number = count_scaling_neurons_number();
01327
01328 Vector<double> outputs(scaling_neurons_number);
01329
01330 for(unsigned int i = 0; i < scaling_neurons_number; i++)
01331 {
01332 if(maximums[i]-minimums[i] < 1e-99)
01333 {
01334 if(display)
01335 {
01336 std::cout << "OpenNN Warning: ScalingLayer class\n"
01337 << "Vector<double> calculate_minimum_maximum_output(Vector<double>&) const method.\n"
01338 << "Minimum and maximum values of variable " << i << " are equal.\n"
01339 << "Those inputs won't be scaled.\n";
01340 }
01341
01342 outputs[i] = inputs[i];
01343 }
01344 else
01345 {
01346 outputs[i] = 2.0*(inputs[i] - minimums[i])/(maximums[i]-minimums[i]) - 1.0;
01347 }
01348 }
01349
01350 return(outputs);
01351 }
01352
01353
01354
01355
01358
01359 Vector<double> ScalingLayer::calculate_minimum_maximum_derivative(const Vector<double>&) const
01360 {
01361 const unsigned int scaling_neurons_number = count_scaling_neurons_number();
01362
01363 Vector<double> scaled_derivative(scaling_neurons_number);
01364
01365 for(unsigned int i = 0; i < scaling_neurons_number; i++)
01366 {
01367 if(maximums[i]-minimums[i] < 1e-99)
01368 {
01369 if(display)
01370 {
01371 std::cout << "OpenNN Warning: ScalingLayer class.\n"
01372 << "Vector<double> calculate_minimum_maximum_derivative(const Vector<double>&) const method.\n"
01373 << "Minimum and maximum values of variable " << i << " are equal.\n"
01374 << "That inputs is not scaled.\n";
01375 }
01376
01377 scaled_derivative[i] = 1.0;
01378 }
01379 else
01380 {
01381 scaled_derivative[i] = 2.0/(maximums[i]-minimums[i]);
01382 }
01383 }
01384
01385 return(scaled_derivative);
01386 }
01387
01388
01389
01390
01393
01394 Vector<double> ScalingLayer::calculate_minimum_maximum_second_derivative(const Vector<double>&) const
01395 {
01396 const unsigned int scaling_neurons_number = count_scaling_neurons_number();
01397
01398 const Vector<double> scaled_second_derivative(scaling_neurons_number, 0.0);
01399
01400 return(scaled_second_derivative);
01401 }
01402
01403
01404
01405
01408
01409 Vector<double> ScalingLayer::calculate_mean_standard_deviation_output(const Vector<double>& inputs) const
01410 {
01411
01412 const unsigned int scaling_neurons_number = count_scaling_neurons_number();
01413
01414 Vector<double> outputs(scaling_neurons_number);
01415
01416 for(unsigned int i = 0; i < scaling_neurons_number; i++)
01417 {
01418 if(standard_deviations[i] < 1e-99)
01419 {
01420 if(display)
01421 {
01422 std::cout << "OpenNN Warning: ScalingLayer class.\n"
01423 << "Vector<double> calculate_mean_standard_deviation_output(const Vector<double>&) const method.\n"
01424 << "Standard deviation of variable " << i << " is zero.\n"
01425 << "Those variables won't be scaled.\n";
01426 }
01427
01428 outputs[i] = inputs[i];
01429 }
01430 else
01431 {
01432 outputs[i] = (inputs[i] - means[i])/standard_deviations[i];
01433 }
01434 }
01435
01436 return(outputs);
01437 }
01438
01439
01440
01441
01444
01445 Vector<double> ScalingLayer::calculate_mean_standard_deviation_derivative(const Vector<double>&) const
01446 {
01447 const unsigned int scaling_neurons_number = count_scaling_neurons_number();
01448
01449 Vector<double> derivative(scaling_neurons_number);
01450
01451 for(unsigned int i = 0; i < scaling_neurons_number; i++)
01452 {
01453 if(standard_deviations[i] < 1e-99)
01454 {
01455 if(display)
01456 {
01457 std::cout << "OpenNN Warning: ScalingLayer class.\n"
01458 << "Vector<double> calculate_mean_standard_deviation_derivative(const Vector<double>&) const method.\n"
01459 << "Standard deviation of input variable " << i << " is zero.\n"
01460 << "That inputs is not be scaled.\n";
01461 }
01462
01463 derivative[i] = 1.0;
01464 }
01465 else
01466 {
01467 derivative[i] = 1.0/standard_deviations[i];
01468 }
01469 }
01470
01471 return(derivative);
01472 }
01473
01474
01475
01476
01479
01480 Vector<double> ScalingLayer::calculate_mean_standard_deviation_second_derivative(const Vector<double>&) const
01481 {
01482 const unsigned int scaling_neurons_number = count_scaling_neurons_number();
01483
01484 const Vector<double> second_derivative(scaling_neurons_number, 0.0);
01485
01486 return(second_derivative);
01487 }
01488
01489
01490
01491
01493
01494 Matrix<double> ScalingLayer::arrange_Jacobian(const Vector<double>& derivative) const
01495 {
01496 const unsigned int scaling_neurons_number = count_scaling_neurons_number();
01497
01498 Matrix<double> Jacobian(scaling_neurons_number, scaling_neurons_number, 0.0);
01499
01500 Jacobian.set_diagonal(derivative);
01501
01502 return(Jacobian);
01503 }
01504
01505
01506
01507
01509
01510 Vector< Matrix<double> > ScalingLayer::arrange_Hessian_form(const Vector<double>& second_derivative) const
01511 {
01512 const unsigned int scaling_neurons_number = count_scaling_neurons_number();
01513
01514 Vector< Matrix<double> > Hessian_form(scaling_neurons_number);
01515
01516 for(unsigned int i = 0; i < scaling_neurons_number; i++)
01517 {
01518 Hessian_form[i].set(scaling_neurons_number, scaling_neurons_number, 0.0);
01519
01520 Hessian_form[i][i][i] = second_derivative[i];
01521 }
01522
01523 return(Hessian_form);
01524 }
01525
01526
01527
01528
01532
01533 std::string ScalingLayer::write_minimum_maximum_expression(const Vector<std::string>& inputs_name, const Vector<std::string>& outputs_name) const
01534 {
01535 const unsigned int inputs_number = count_scaling_neurons_number();
01536
01537 std::ostringstream buffer;
01538
01539 for(unsigned int i = 0; i < inputs_number; i++)
01540 {
01541 buffer << outputs_name[i] << "=2*(" << inputs_name[i] << "-" << minimums[i] << ")/(" << maximums[i] << "-" << minimums[i] << ")-1;\n";
01542 }
01543
01544 return(buffer.str());
01545 }
01546
01547
01548
01549
01553
01554 std::string ScalingLayer::write_mean_standard_deviation_expression(const Vector<std::string>& inputs_name, const Vector<std::string>& outputs_name) const
01555 {
01556 const unsigned int inputs_number = count_scaling_neurons_number();
01557
01558 std::ostringstream buffer;
01559
01560 for(unsigned int i = 0; i < inputs_number; i++)
01561 {
01562 buffer << outputs_name[i] << "=(" << inputs_name[i] << "-" << means[i] << ")/" << standard_deviations[i] << ";\n";
01563 }
01564
01565 return(buffer.str());
01566 }
01567
01568
01569
01570
01572
01573 std::string ScalingLayer::write_expression(const Vector<std::string>& inputs_name, const Vector<std::string>& outputs_name) const
01574 {
01575 std::ostringstream buffer;
01576
01577 switch(scaling_method)
01578 {
01579 case MinimumMaximum:
01580 {
01581 return(write_minimum_maximum_expression(inputs_name, outputs_name));
01582 }
01583 break;
01584
01585 case MeanStandardDeviation:
01586 {
01587 return(write_mean_standard_deviation_expression(inputs_name, outputs_name));
01588 }
01589 break;
01590
01591 default:
01592 {
01593 std::ostringstream buffer;
01594
01595 buffer << "OpenNN Exception: ScalingLayer class.\n"
01596 << "std::string write_expression(void) const method.\n"
01597 << "Unknown inputs scaling method.\n";
01598
01599 throw std::logic_error(buffer.str());
01600 }
01601 break;
01602 }
01603
01604
01605 }
01606
01607
01608
01609
01611
01612 std::string ScalingLayer::to_string(void) const
01613 {
01614 std::ostringstream buffer;
01615
01616 buffer << "Scaling layer\n"
01617 << "Minimums: " << minimums << "\n"
01618 << "Maximums: " << maximums << "\n"
01619 << "Means: " << means << "\n"
01620 << "Standard deviations: " << standard_deviations << "\n"
01621 << "Scaling method: " << write_scaling_method() << "\n"
01622 << "Display: " << display << "\n";
01623
01624 return(buffer.str());
01625 }
01626
01627
01628
01629
01632
01633 TiXmlElement* ScalingLayer::to_XML(void) const
01634 {
01635 std::ostringstream buffer;
01636
01637 TiXmlElement* scaling_layer_element = new TiXmlElement("ScalingLayer");
01638 scaling_layer_element->SetAttribute("Version", 4);
01639
01640
01641
01642 TiXmlElement* minimums_element = new TiXmlElement("Minimums");
01643 scaling_layer_element->LinkEndChild(minimums_element);
01644
01645 buffer.str("");
01646 buffer << minimums;
01647
01648 TiXmlText* minimums_text = new TiXmlText(buffer.str().c_str());
01649 minimums_element->LinkEndChild(minimums_text);
01650
01651
01652
01653 TiXmlElement* maximums_element = new TiXmlElement("Maximums");
01654 scaling_layer_element->LinkEndChild(maximums_element);
01655
01656 buffer.str("");
01657 buffer << maximums;
01658
01659 TiXmlText* maximums_text = new TiXmlText(buffer.str().c_str());
01660 maximums_element->LinkEndChild(maximums_text);
01661
01662
01663
01664 TiXmlElement* means_element = new TiXmlElement("Means");
01665 scaling_layer_element->LinkEndChild(means_element);
01666
01667 buffer.str("");
01668 buffer << means;
01669
01670 TiXmlText* means_text = new TiXmlText(buffer.str().c_str());
01671 means_element->LinkEndChild(means_text);
01672
01673
01674
01675 TiXmlElement* standard_deviations_element = new TiXmlElement("StandardDeviations");
01676 scaling_layer_element->LinkEndChild(standard_deviations_element);
01677
01678 buffer.str("");
01679 buffer << standard_deviations;
01680
01681 TiXmlText* standard_deviations_text = new TiXmlText(buffer.str().c_str());
01682 standard_deviations_element->LinkEndChild(standard_deviations_text);
01683
01684
01685
01686 TiXmlElement* method_element = new TiXmlElement("ScalingMethod");
01687 scaling_layer_element->LinkEndChild(method_element);
01688
01689 TiXmlText* method_text = new TiXmlText(write_scaling_method().c_str());
01690 method_element->LinkEndChild(method_text);
01691
01692
01693
01694 TiXmlElement* display_element = new TiXmlElement("Display");
01695 scaling_layer_element->LinkEndChild(display_element);
01696
01697 buffer.str("");
01698 buffer << display;
01699
01700 TiXmlText* display_text = new TiXmlText(buffer.str().c_str());
01701 display_element->LinkEndChild(display_text);
01702
01703 return(scaling_layer_element);
01704 }
01705
01706
01707
01708
01711
01712 void ScalingLayer::from_XML(TiXmlElement* scaling_layer_element)
01713 {
01714 if(scaling_layer_element)
01715 {
01716
01717 {
01718 TiXmlElement* scaling_method_element = scaling_layer_element->FirstChildElement("ScalingMethod");
01719
01720 if(scaling_method_element)
01721 {
01722 std::string new_method = scaling_method_element->GetText();
01723
01724 try
01725 {
01726 set_scaling_method(new_method);
01727 }
01728 catch(std::exception& e)
01729 {
01730 std::cout << e.what() << std::endl;
01731 }
01732 }
01733 }
01734
01735
01736 {
01737 TiXmlElement* minimums_element = scaling_layer_element->FirstChildElement("Minimums");
01738
01739 if(minimums_element)
01740 {
01741 const char* minimums_text = minimums_element->GetText();
01742
01743 if(minimums_text)
01744 {
01745 Vector<double> new_minimums;
01746 new_minimums.parse(minimums_text);
01747
01748 try
01749 {
01750 set_minimums(new_minimums);
01751 }
01752 catch(std::exception& e)
01753 {
01754 std::cout << e.what() << std::endl;
01755 }
01756 }
01757 }
01758 }
01759
01760
01761 {
01762 TiXmlElement* maximums_element = scaling_layer_element->FirstChildElement("Maximums");
01763
01764 if(maximums_element)
01765 {
01766 const char* maximums_text = maximums_element->GetText();
01767
01768 if(maximums_text)
01769 {
01770 Vector<double> new_maximums;
01771 new_maximums.parse(maximums_text);
01772
01773 try
01774 {
01775 set_maximums(new_maximums);
01776 }
01777 catch(std::exception& e)
01778 {
01779 std::cout << e.what() << std::endl;
01780 }
01781 }
01782 }
01783 }
01784
01785
01786 {
01787 TiXmlElement* means_element = scaling_layer_element->FirstChildElement("Means");
01788
01789 if(means_element)
01790 {
01791 const char* means_text = means_element->GetText();
01792
01793 if(means_text)
01794 {
01795 Vector<double> new_means;
01796 new_means.parse(means_text);
01797
01798 try
01799 {
01800 set_means(new_means);
01801 }
01802 catch(std::exception& e)
01803 {
01804 std::cout << e.what() << std::endl;
01805 }
01806 }
01807 }
01808 }
01809
01810
01811 {
01812 TiXmlElement* standard_deviations_element = scaling_layer_element->FirstChildElement("StandardDeviations");
01813
01814 if(standard_deviations_element)
01815 {
01816 const char* standard_deviations_text = standard_deviations_element->GetText();
01817
01818 if(standard_deviations_text)
01819 {
01820 Vector<double> new_standard_deviations;
01821 new_standard_deviations.parse(standard_deviations_text);
01822
01823 try
01824 {
01825 set_standard_deviations(new_standard_deviations);
01826 }
01827 catch(std::exception& e)
01828 {
01829 std::cout << e.what() << std::endl;
01830 }
01831 }
01832 }
01833 }
01834
01835
01836 {
01837 TiXmlElement* display_element = scaling_layer_element->FirstChildElement("Display");
01838
01839 if(display)
01840 {
01841 std::string new_display_string = display_element->GetText();
01842
01843 try
01844 {
01845 set_display(new_display_string != "0");
01846 }
01847 catch(std::exception& e)
01848 {
01849 std::cout << e.what() << std::endl;
01850 }
01851 }
01852 }
01853 }
01854 }
01855
01856 }
01857
01858
01859
01860
01861
01862
01863
01864
01865
01866
01867
01868
01869
01870
01871
01872
01873