deep learning(1)BP神经网络原理与练习

╰+攻爆jí腚メ 2022-01-10 03:23 199阅读 0赞

具体原理参考如下讲义：

1、[神经网络][Link 1]

2、[反向传导][Link 2]

3、[梯度检验与高级优化][Link 3]

看完材料1和2就可以梳理清楚bp神经网络的基本工作原理，下面通过一个C语言实现的程序来练习这个算法

1 //Backpropagation, 25x25x8 units, binary sigmoid function network
      2 //Written by Thomas Riga, University of Genoa, Italy
      3 //thomas@magister.magi.unige.it
      4 
      5 #include <iostream>
      6 #include <fstream>
      7 #include <conio.h>
      8 #include <stdlib.h>
      9 #include <math.h>
     10 #include <ctype.h>
     11 #include <stdio.h>
     12 #include <float.h>
     13 using namespace std;
     14 
     15 double **input,
     16     *hidden,
     17     **output,
     18     **target,
     19     *bias,
     20     **weight_i_h,
     21     **weight_h_o,
     22     *errorsignal_hidden,
     23     *errorsignal_output;
     24 
     25 int input_array_size,
     26     hidden_array_size,
     27     output_array_size,
     28     max_patterns,
     29     bias_array_size,
     30     gaset = -2500,
     31     number_of_input_patterns,
     32     pattern,
     33     file_loaded = 0,
     34     ytemp = 0,
     35     ztemp = 0;
     36 double learning_rate,
     37     max_error_tollerance = 0.1;
     38 char filename[128];
     39 #define IA   16807
     40 #define IM   2147483647
     41 #define AM   (1.0 / IM)
     42 #define IQ   127773
     43 #define IR   2836
     44 #define NTAB 32
     45 #define NDIV (1+(IM-1) / NTAB)
     46 #define EPS  1.2e-7
     47 #define RNMX (1.0 - EPS)
     48 int compare_output_to_target();
     49 void load_data(char *arg);
     50 void save_data(char *argres);
     51 void forward_pass(int pattern);
     52 void backward_pass(int pattern);
     53 void custom();
     54 void compute_output_pattern();
     55 void get_file_name();
     56 float bedlam(long *idum);
     57 void learn();
     58 void make();
     59 void test();
     60 void print_data();
     61 void print_data_to_screen();
     62 void print_data_to_file();
     63 void output_to_screen();
     64 int getnumber();
     65 void change_learning_rate();
     66 void initialize_net();
     67 void clear_memory();
     68 
     69 int main()
     70 {
     71     cout << "backpropagation network by Thomas Riga, University of Genoa, Italy" << endl;
     72     for(;;) {
     73         char choice;
     74         cout << endl << "1. load data" << endl;
     75         cout << "2. learn from data" << endl;
     76         cout << "3. compute output pattern" << endl;
     77         cout << "4. make new data file" << endl;
     78         cout << "5. save data" << endl;
     79         cout << "6. print data" << endl;
     80         cout << "7. change learning rate" << endl;
     81         cout << "8. exit" << endl << endl;
     82         cout << "Enter your choice (1-8)";
     83         do { choice = getch(); } while (choice != '1' && choice != '2' && choice != '3' && choice != '4' && choice != '5' && choice != '6' && choice != '7' && choice != '8');
     84         switch(choice) {
     85         case '1':
     86             {
     87                 if (file_loaded == 1) clear_memory();
     88                 get_file_name();
     89                 file_loaded = 1;
     90                 load_data(filename);
     91             }
     92             break;
     93         case '2': learn();
     94             break;
     95         case '3': compute_output_pattern();
     96             break;
     97         case '4': make();
     98             break;
     99         case '5':
    100             {
    101                 if (file_loaded == 0)
    102                 {
    103                     cout << endl
    104                         << "there is no data loaded into memory"
    105                         << endl;
    106                     break;
    107                 }
    108                 cout << endl << "enter a filename to save data to: ";
    109                 cin >> filename;
    110                 save_data(filename);
    111             }
    112             break;
    113         case '6': print_data();
    114             break;
    115         case '7': change_learning_rate();
    116             break;
    117         case '8': return 0;
    118         };
    119     }
    120 }
    121 
    122 void initialize_net()
    123 {
    124     int x;
    125     input = new double * [number_of_input_patterns];
    126     if(!input) { cout << endl << "memory problem!"; exit(1); }
    127     for(x=0; x<number_of_input_patterns; x++)
    128     {
    129         input[x] = new double [input_array_size];
    130         if(!input[x]) { cout << endl << "memory problem!"; exit(1); }
    131     }
    132     hidden = new double [hidden_array_size];
    133     if(!hidden) { cout << endl << "memory problem!"; exit(1); }
    134     output = new double * [number_of_input_patterns];
    135     if(!output) { cout << endl << "memory problem!"; exit(1); }
    136     for(x=0; x<number_of_input_patterns; x++)
    137     {
    138         output[x] = new double [output_array_size];
    139         if(!output[x]) { cout << endl << "memory problem!"; exit(1); }
    140     }
    141     target = new double * [number_of_input_patterns];
    142     if(!target) { cout << endl << "memory problem!"; exit(1); }
    143     for(x=0; x<number_of_input_patterns; x++)
    144     {
    145         target[x] = new double [output_array_size];
    146         if(!target[x]) { cout << endl << "memory problem!"; exit(1); }
    147     }
    148     bias = new double [bias_array_size];
    149     if(!bias) { cout << endl << "memory problem!"; exit(1); }
    150     weight_i_h = new double * [input_array_size];
    151     if(!weight_i_h) { cout << endl << "memory problem!"; exit(1); }
    152     for(x=0; x<input_array_size; x++)
    153     {
    154         weight_i_h[x] = new double [hidden_array_size];
    155         if(!weight_i_h[x]) { cout << endl << "memory problem!"; exit(1); }
    156     }
    157     weight_h_o = new double * [hidden_array_size];
    158     if(!weight_h_o) { cout << endl << "memory problem!"; exit(1); }
    159     for(x=0; x<hidden_array_size; x++)
    160     {
    161         weight_h_o[x] = new double [output_array_size];
    162         if(!weight_h_o[x]) { cout << endl << "memory problem!"; exit(1); }
    163     }
    164     errorsignal_hidden = new double [hidden_array_size];
    165     if(!errorsignal_hidden) { cout << endl << "memory problem!"; exit(1); }
    166     errorsignal_output = new double [output_array_size];
    167     if(!errorsignal_output) { cout << endl << "memory problem!"; exit(1); }
    168     return;
    169 }
    170 
    171 void learn()
    172 {
    173     if (file_loaded == 0)
    174     {
    175         cout << endl
    176             << "there is no data loaded into memory"
    177             << endl;
    178         return;
    179     }
    180     cout << endl << "learning..." << endl << "press a key to return to menu" << endl;
    181     register int y;
    182     while(!kbhit()) {
    183         for(y=0; y<number_of_input_patterns; y++) {
    184             forward_pass(y);
    185             backward_pass(y);
    186         }
    187         if(compare_output_to_target()) {
    188             cout << endl << "learning successful" << endl;
    189             return;
    190         }
    191 
    192     }
    193     cout << endl << "learning not successful yet" << endl;
    194     return;
    195 }
    196 
    197 void load_data(char *arg) {
    198     int x, y;
    199     ifstream in(arg);
    200     if(!in) { cout << endl << "failed to load data file" << endl; file_loaded = 0; return; }
    201     in >> input_array_size;
    202     in >> hidden_array_size;
    203     in >> output_array_size;
    204     in >> learning_rate;
    205     in >> number_of_input_patterns;
    206     bias_array_size = hidden_array_size + output_array_size;
    207     initialize_net();
    208     for(x = 0; x < bias_array_size; x++) in >> bias[x];
    209     for(x=0; x<input_array_size; x++) { 
    210         for(y=0; y<hidden_array_size; y++) in >> weight_i_h[x][y];
    211     }
    212     for(x = 0; x < hidden_array_size; x++) { 
    213         for(y=0; y<output_array_size; y++) in >> weight_h_o[x][y];
    214     }
    215     for(x=0; x < number_of_input_patterns; x++) {
    216         for(y=0; y<input_array_size; y++) in >> input[x][y];
    217     }
    218     for(x=0; x < number_of_input_patterns; x++) {
    219         for(y=0; y<output_array_size; y++) in >> target[x][y];
    220     }
    221     in.close();
    222     cout << endl << "data loaded" << endl;
    223     return;
    224 }
    225 
    226 
    227 void forward_pass(int pattern)
    228 {
    229     _control87(MCW_EM, MCW_EM);
    230     register double temp=0;
    231     register int x,y;
    232 
    233     // INPUT -> HIDDEN
    234     for(y=0; y<hidden_array_size; y++) {
    235         for(x=0; x<input_array_size; x++) {
    236             temp += (input[pattern][x] * weight_i_h[x][y]);
    237         }
    238         hidden[y] = (1.0 / (1.0 + exp(-1.0 * (temp + bias[y]))));
    239         temp = 0;
    240     }
    241 
    242     // HIDDEN -> OUTPUT
    243     for(y=0; y<output_array_size; y++) {
    244         for(x=0; x<hidden_array_size; x++) {
    245             temp += (hidden[x] * weight_h_o[x][y]);
    246         }
    247         output[pattern][y] = (1.0 / (1.0 + exp(-1.0 * (temp + bias[y + hidden_array_size]))));
    248         temp = 0;
    249     }
    250     return;
    251 }
    252 
    253 
    254 
    255 void backward_pass(int pattern)
    256 {
    257     register int x, y;
    258     register double temp = 0;
    259 
    260     // COMPUTE ERRORSIGNAL FOR OUTPUT UNITS
    261     for(x=0; x<output_array_size; x++) {
    262         errorsignal_output[x] = (target[pattern][x] - output[pattern][x]);
    263     }
    264 
    265     // COMPUTE ERRORSIGNAL FOR HIDDEN UNITS
    266     for(x=0; x<hidden_array_size; x++) {
    267         for(y=0; y<output_array_size; y++) { 
    268             temp += (errorsignal_output[y] * weight_h_o[x][y]);
    269         }
    270         errorsignal_hidden[x] = hidden[x] * (1-hidden[x]) * temp;
    271         temp = 0.0;
    272     }
    273 
    274     // ADJUST WEIGHTS OF CONNECTIONS FROM HIDDEN TO OUTPUT UNITS
    275     double length = 0.0;
    276     for (x=0; x<hidden_array_size; x++) {
    277         length += hidden[x]*hidden[x];
    278     }
    279     if (length<=0.1) length = 0.1;
    280     for(x=0; x<hidden_array_size; x++) {
    281         for(y=0; y<output_array_size; y++) {
    282             weight_h_o[x][y] += (learning_rate * errorsignal_output[y] * 
    283                 hidden[x]/length);
    284         }
    285     }
    286 
    287     // ADJUST BIASES OF HIDDEN UNITS
    288     for(x=hidden_array_size; x<bias_array_size; x++) {
    289         bias[x] += (learning_rate * errorsignal_output[x] / length);
    290     }
    291 
    292     // ADJUST WEIGHTS OF CONNECTIONS FROM INPUT TO HIDDEN UNITS
    293     length = 0.0;
    294     for (x=0; x<input_array_size; x++) {
    295         length += input[pattern][x]*input[pattern][x];
    296     }
    297     if (length<=0.1) length = 0.1;
    298     for(x=0; x<input_array_size; x++) {
    299         for(y=0; y<hidden_array_size; y++) {
    300             weight_i_h[x][y] += (learning_rate * errorsignal_hidden[y] * 
    301                 input[pattern][x]/length);
    302         }
    303     }
    304 
    305     // ADJUST BIASES FOR OUTPUT UNITS
    306     for(x=0; x<hidden_array_size; x++) {
    307         bias[x] += (learning_rate * errorsignal_hidden[x] / length);
    308     }
    309     return;
    310 }
    311 
    312 int compare_output_to_target()
    313 {
    314     register int y,z;
    315     register double temp, error = 0.0;
    316     temp = target[ytemp][ztemp] - output[ytemp][ztemp];
    317     if (temp < 0) error -= temp;
    318     else error += temp;
    319     if(error > max_error_tollerance) return 0;
    320     error = 0.0;
    321     for(y=0; y < number_of_input_patterns; y++) {
    322         for(z=0; z < output_array_size; z++) {
    323             temp = target[y][z] - output[y][z];
    324             if (temp < 0) error -= temp;
    325             else error += temp;
    326             if(error > max_error_tollerance) {
    327                 ytemp = y;
    328                 ztemp = z;
    329                 return 0;
    330             }
    331             error = 0.0;
    332         }
    333     }
    334     return 1;
    335 }
    336 
    337 void save_data(char *argres) {
    338     int x, y;
    339     ofstream out;    
    340     out.open(argres);
    341     if(!out) { cout << endl << "failed to save file" << endl; return; }
    342     out << input_array_size << endl;
    343     out << hidden_array_size << endl;
    344     out << output_array_size << endl;
    345     out << learning_rate << endl;
    346     out << number_of_input_patterns << endl << endl;
    347     for(x=0; x<bias_array_size; x++) out << bias[x] << ' ';
    348     out << endl << endl;
    349     for(x=0; x<input_array_size; x++) {
    350         for(y=0; y<hidden_array_size; y++) out << weight_i_h[x][y] << ' ';
    351     }
    352     out << endl << endl;
    353     for(x=0; x<hidden_array_size; x++) {
    354         for(y=0; y<output_array_size; y++) out << weight_h_o[x][y] << ' ';
    355     }
    356     out << endl << endl;
    357     for(x=0; x<number_of_input_patterns; x++) {
    358         for(y=0; y<input_array_size; y++) out << input[x][y] << ' ';
    359         out << endl;
    360     }
    361     out << endl;
    362     for(x=0; x<number_of_input_patterns; x++) {
    363         for(y=0; y<output_array_size; y++) out << target[x][y] << ' ';
    364         out << endl;
    365     }
    366     out.close();
    367     cout << endl << "data saved" << endl;
    368     return;
    369 }    
    370 
    371 void make()
    372 {
    373     int x, y, z;
    374     double inpx, bias_array_size, input_array_size, hidden_array_size, output_array_size;
    375     char makefilename[128];
    376     cout << endl << "enter name of new data file: ";
    377     cin >> makefilename;
    378     ofstream out;
    379     out.open(makefilename);
    380     if(!out) { cout << endl << "failed to open file" << endl; return;}
    381     cout << "how many input units? ";
    382     cin >> input_array_size;
    383     out << input_array_size << endl;
    384     cout << "how many hidden units? ";
    385     cin >> hidden_array_size;
    386     out << hidden_array_size << endl;
    387     cout << "how many output units? ";
    388     cin >> output_array_size;
    389     out << output_array_size << endl;
    390     bias_array_size = hidden_array_size + output_array_size;
    391     cout << endl << "Learning rate: ";
    392     cin >> inpx;
    393     out << inpx << endl;
    394     cout << endl << "Number of input patterns: ";
    395     cin >> z;
    396     out << z << endl << endl;
    397     for(x=0; x<bias_array_size; x++) out << (1.0 - (2.0 * bedlam((long*)(gaset)))) << ' ';
    398     out << endl << endl;
    399     for(x=0; x<input_array_size; x++) {
    400         for(y=0; y<hidden_array_size; y++) out << (1.0 - (2.0 * bedlam((long*)(gaset)))) << ' ';
    401     }
    402     out << endl << endl;
    403     for(x=0; x<hidden_array_size; x++) {
    404         for(y=0; y<output_array_size; y++) out << (1.0 - (2.0 * bedlam((long*)(gaset)))) << ' ';
    405     }
    406     out << endl << endl;
    407     for(x=0; x < z; x++) {
    408         cout << endl << "input pattern " << (x + 1) << endl;
    409         for(y=0; y<input_array_size; y++) {
    410             cout << (y+1) << ": ";
    411             cin >> inpx;
    412             out << inpx << ' ';
    413         }
    414         out << endl;
    415     }
    416     out << endl;
    417     for(x=0; x < z; x++) {
    418         cout << endl << "target output pattern " << (x+1) << endl;
    419         for(y=0; y<output_array_size; y++) {
    420             cout << (y+1) << ": ";
    421             cin >> inpx;
    422             out << inpx << ' ';
    423         }
    424         out << endl;
    425     }
    426     out.close();
    427     cout << endl << "data saved, to work with this new data file you first have to load it" << endl;
    428     return;
    429 }
    430 
    431 float bedlam(long *idum)
    432 {
    433     int xj;
    434     long xk;
    435     static long iy=0;
    436     static long iv[NTAB];
    437     float temp;
    438 
    439     if(*idum <= 0 || !iy)
    440     {
    441         if(-(*idum) < 1)
    442         {
    443             *idum = 1 + *idum;
    444         }
    445         else
    446         {
    447             *idum = -(*idum);
    448         }
    449         for(xj = NTAB+7; xj >= 0; xj--)
    450         {
    451             xk = (*idum) / IQ;
    452             *idum = IA * (*idum - xk * IQ) - IR * xk;
    453             if(*idum < 0)
    454             {
    455                 *idum += IM;
    456             }
    457             if(xj < NTAB)
    458             {
    459                 iv[xj] = *idum;
    460             }
    461         }
    462         iy = iv[0];
    463     }
    464 
    465     xk = (*idum) / IQ;
    466     *idum = IA * (*idum - xk * IQ) - IR * xk;
    467     if(*idum < 0)
    468     {
    469         *idum += IM;
    470     }
    471     xj = iy / NDIV;
    472     iy = iv[xj];
    473     iv[xj] = *idum;
    474 
    475     if((temp=AM*iy) > RNMX)
    476     {
    477         return(RNMX);
    478     }
    479     else
    480     {
    481         return(temp);
    482     }
    483 }
    484 
    485 void test()
    486 {
    487     pattern = 0;
    488     while(pattern == 0) {
    489         cout << endl << endl << "There are " << number_of_input_patterns << " input patterns in the file," << endl << "enter a number within this range: ";
    490         pattern = getnumber();
    491     }
    492     pattern--;
    493     forward_pass(pattern);
    494     output_to_screen();
    495     return;
    496 }
    497 
    498 void output_to_screen()
    499 {
    500     int x;
    501     cout << endl << "Output pattern:" << endl;
    502     for(x=0; x<output_array_size; x++) {
    503         cout << endl << (x+1) << ": " << output[pattern][x] << "    binary: ";
    504         if(output[pattern][x] >= 0.9) cout << "1";
    505         else if(output[pattern][x]<=0.1) cout << "0";
    506         else cout << "intermediate value";
    507     }
    508     cout << endl;
    509     return;
    510 }
    511 
    512 int getnumber()
    513 {
    514     int a, b = 0;
    515     char c, d[5];
    516     while(b<4) {
    517         do { c = getch(); } while (c != '1' && c != '2' && c != '3' && c != '4' && c != '5' && c != '6' && c != '7' && c != '8' && c != '9' && c != '0' && toascii(c) != 13);
    518         if(toascii(c)==13) break;
    519         if(toascii(c)==27) return 0;
    520         d[b] = c;
    521         cout << c;
    522         b++;
    523     }
    524     d[b] = '\0';
    525     a = atoi(d);
    526     if(a < 0 || a > number_of_input_patterns) a = 0;
    527     return a;
    528 }
    529 
    530 void get_file_name()
    531 {
    532     cout << endl << "enter name of file to load: ";
    533     cin >> filename;
    534     return;
    535 }
    536 
    537 void print_data()
    538 {
    539     char choice;
    540     if (file_loaded == 0)
    541     {
    542         cout << endl
    543             << "there is no data loaded into memory"
    544             << endl;
    545         return;
    546     }
    547     cout << endl << "1. print data to screen" << endl;
    548     cout << "2. print data to file" << endl;
    549     cout << "3. return to main menu" << endl << endl;
    550     cout << "Enter your choice (1-3)" << endl;
    551     do { choice = getch(); } while (choice != '1' && choice != '2' && choice != '3');
    552     switch(choice) {
    553     case '1': print_data_to_screen();
    554         break;
    555     case '2': print_data_to_file();
    556         break;
    557     case '3': return;
    558     };
    559     return;
    560 }
    561 
    562 
    563 void print_data_to_screen() {
    564     register int x, y;
    565     cout << endl << endl << "DATA FILE: " << filename << endl;
    566     cout << "learning rate: " << learning_rate << endl;
    567     cout << "input units: " << input_array_size << endl;
    568     cout << "hidden units: " << hidden_array_size << endl;
    569     cout << "output units: " << output_array_size << endl;
    570     cout << "number of input and target output patterns: " << number_of_input_patterns  << endl << endl;
    571     cout << "INPUT AND TARGET OUTPUT PATTERNS:";
    572     for(x=0; x<number_of_input_patterns; x++) {
    573         cout << endl << "input pattern: " << (x+1) << endl;
    574         for(y=0; y<input_array_size; y++) cout << input[x][y] << "  ";
    575         cout << endl << "target output pattern: " << (x+1) << endl;
    576         for(y=0; y<output_array_size; y++) cout << target[x][y] << "  ";
    577     }
    578     cout << endl << endl << "BIASES:" << endl;
    579     for(x=0; x<hidden_array_size; x++) {
    580         cout << "bias of hidden unit " << (x+1) << ": " << bias[x];
    581         if(x<output_array_size) cout << "      bias of output unit " << (x+1) << ": " << bias[x+hidden_array_size];
    582         cout << endl;
    583     }
    584     cout << endl << "WEIGHTS:" << endl;
    585     for(x=0; x<input_array_size; x++) {
    586         for(y=0; y<hidden_array_size; y++) cout << "i_h[" << x << "][" << y << "]: " << weight_i_h[x][y] << endl;
    587     }
    588     for(x=0; x<hidden_array_size; x++) {
    589         for(y=0; y<output_array_size; y++) cout << "h_o[" << x << "][" << y << "]: " << weight_h_o[x][y] << endl;
    590     }
    591     return;
    592 }
    593 
    594 void print_data_to_file()
    595 {
    596     char printfile[128];
    597     cout << endl << "enter name of file to print data to: ";
    598     cin >> printfile;
    599     ofstream out;
    600     out.open(printfile);
    601     if(!out) { cout << endl << "failed to open file"; return; }
    602     register int x, y;
    603     out << endl << endl << "DATA FILE: " << filename << endl;
    604     out << "input units: " << input_array_size << endl;
    605     out << "hidden units: " << hidden_array_size << endl;
    606     out << "output units: " << output_array_size << endl;
    607     out << "learning rate: " << learning_rate << endl;
    608     out << "number of input and target output patterns: " << number_of_input_patterns << endl << endl;
    609     out << "INPUT AND TARGET OUTPUT PATTERNS:";
    610     for(x=0; x<number_of_input_patterns; x++) {
    611         out << endl << "input pattern: " << (x+1) << endl;
    612         for(y=0; y<input_array_size; y++) out << input[x][y] << "  ";
    613         out << endl << "target output pattern: " << (x+1) << endl;
    614         for(y=0; y<output_array_size; y++) out << target[x][y] << "  ";
    615     }
    616     out << endl << endl << "BIASES:" << endl;
    617     for(x=0; x<hidden_array_size; x++) {
    618         out << "bias of hidden unit " << (x+1) << ": " << bias[x];
    619         if(x<output_array_size) out << "      bias of output unit " << (x+1) << ": " << bias[x+hidden_array_size];
    620         out << endl;
    621     }
    622     out << endl << "WEIGHTS:" << endl;
    623     for(x=0; x<input_array_size; x++) {
    624         for(y=0; y<hidden_array_size; y++) out << "i_h[" << x << "][" << y << "]: " << weight_i_h[x][y] << endl;
    625     }
    626     for(x=0; x<hidden_array_size; x++) {
    627         for(y=0; y<output_array_size; y++) out << "h_o[" << x << "][" << y << "]: " << weight_h_o[x][y] << endl;
    628     }
    629     out.close();
    630     cout << endl << "data has been printed to " << printfile << endl;
    631     return;
    632 }
    633 
    634 void change_learning_rate()
    635 {
    636     if (file_loaded == 0)
    637     {
    638         cout << endl
    639             << "there is no data loaded into memory"
    640             << endl;
    641         return;
    642     }
    643     cout << endl << "actual learning rate: " << learning_rate << " new value: ";
    644     cin >> learning_rate;
    645     return;
    646 }
    647 
    648 void compute_output_pattern()
    649 {
    650     if (file_loaded == 0)
    651     {
    652         cout << endl
    653             << "there is no data loaded into memory"
    654             << endl;
    655         return;
    656     }
    657     char choice;
    658     cout << endl << endl << "1. load trained input pattern into network" << endl;
    659     cout << "2. load custom input pattern into network" << endl;
    660     cout << "3. go back to main menu" << endl << endl;
    661     cout << "Enter your choice (1-3)" << endl;
    662     do { choice = getch(); } while (choice != '1' && choice != '2' && choice != '3');
    663     switch(choice) {
    664     case '1': test();
    665         break;
    666     case '2': custom();
    667         break;
    668     case '3': return;
    669     };
    670 }
    671 
    672 void custom()
    673 {
    674     _control87 (MCW_EM, MCW_EM);
    675     char filename[128];
    676     register double temp=0;
    677     register int x,y;
    678     double *custom_input = new double [input_array_size];
    679     if(!custom_input)
    680     {
    681         cout << endl << "memory problem!";
    682         return;
    683     }
    684     double *custom_output = new double [output_array_size];
    685     if(!custom_output)
    686     {
    687         delete [] custom_input;
    688         cout << endl << "memory problem!";
    689         return;
    690     }
    691     cout << endl << endl << "enter file that contains test input pattern: ";
    692     cin >> filename;
    693     ifstream in(filename);
    694     if(!in) { cout << endl << "failed to load data file" << endl; return; }
    695     for(x = 0; x < input_array_size; x++) {
    696         in >> custom_input[x];
    697     }
    698     for(y=0; y<hidden_array_size; y++) {
    699         for(x=0; x<input_array_size; x++) {
    700             temp += (custom_input[x] * weight_i_h[x][y]);
    701         }
    702         hidden[y] = (1.0 / (1.0 + exp(-1.0 * (temp + bias[y]))));
    703         temp = 0;
    704     }
    705     for(y=0; y<output_array_size; y++) {
    706         for(x=0; x<hidden_array_size; x++) {
    707             temp += (hidden[x] * weight_h_o[x][y]);
    708         }
    709         custom_output[y] = (1.0 / (1.0 + exp(-1.0 * (temp + bias[y + hidden_array_size]))));
    710         temp = 0;
    711     }
    712     cout << endl << "Input pattern:" << endl;
    713     for(x = 0; x < input_array_size; x++) {
    714         cout << "[" << (x + 1) << ": " << custom_input[x] << "]  ";
    715     }
    716     cout << endl << endl << "Output pattern:";
    717     for(x=0; x<output_array_size; x++) {
    718         cout << endl << (x+1) << ": " << custom_output[x] << "    binary: ";
    719         if(custom_output[x] >= 0.9) cout << "1";
    720         else if(custom_output[x]<=0.1) cout << "0";
    721         else cout << "intermediate value";
    722     }
    723     cout << endl;
    724     delete [] custom_input;
    725     delete [] custom_output;
    726     return;
    727 }
    728 
    729 void clear_memory()
    730 {
    731     int x;
    732     for(x=0; x<number_of_input_patterns; x++)
    733     {
    734         delete [] input[x];
    735     }
    736     delete [] input;
    737     delete [] hidden;
    738     for(x=0; x<number_of_input_patterns; x++)
    739     {
    740         delete [] output[x];
    741     }
    742     delete [] output;
    743     for(x=0; x<number_of_input_patterns; x++)
    744     {
    745         delete [] target[x];
    746     }
    747     delete [] target;
    748     delete [] bias;
    749     for(x=0; x<input_array_size; x++)
    750     {
    751         delete [] weight_i_h[x];
    752     }
    753     delete [] weight_i_h;
    754     for(x=0; x<hidden_array_size; x++)
    755     {
    756         delete [] weight_h_o[x];
    757     }
    758     delete [] weight_h_o;
    759     delete [] errorsignal_hidden;
    760     delete [] errorsignal_output;
    761     file_loaded = 0;
    762     return;
    763 }

初始化的神经网络的数据文件：

2
    3
    4
    0.5
    4
    5.747781 -6.045236 1.206744 -41.245163 -0.249886 -0.35452 0.0718 
    
    -8.446443 9.25553 -6.50087 7.357942 7.777944 1.238442 
    
    15.957281 0.452741 -8.19198 9.140881 29.124746 9.806898 5.859479 -5.09182 -3.475694 -4.896269 6.320669 0.213897 
    
    1 1 
    1 0 
    0 1 
    0 0 
    
    1 1 0 1 
    0 1 1 0 
    0 1 1 1 
    0 0 0 1 
    
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    !!!!explanation of datafile. Can be deleted. Not necessary for network to work!!!!
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    
    2    (number of input units)
    3    (number of hidden units)
    4    (number of output units)
    0.5  (learning rate)
    4    (number of input and target output patterns)     (has to correspond to the amount of patterns at the end of the datafile)
    5.747781 -6.045236 1.206744 -41.245163 -0.249886 -0.35452 0.0718   (biases of hidden and output units, first three are biases of the hidden units, last four are biases of the output units)
    
    -8.446443 9.25553 -6.50087 7.357942 7.777944 1.238442 (values of weights from input to hidden units)
    
    15.957281 0.452741 -8.19198 9.140881 29.124746 9.806898 5.859479 -5.09182 -3.475694 -4.896269 6.320669 0.213897 (values of weights from hidden to output units)
    
    1 1 (input pattern #1)
    1 0 (input pattern #2)
    0 1 (input pattern #3)
    0 0 (input pattern #4)
    
    1 1 0 1 (target output pattern #1)
    0 1 1 0 (target output pattern #2)
    0 1 1 1 (target output pattern #3) 
    0 0 0 1 (target output pattern #4) 
    
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    !!!!                      end of explanation of datafile.                     !!!!
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

按照数据输入说明，可以再b.txt文件中保存输入数据\[0, 1\],对应的输入结果如下：

![132211598952700.png][]

可以看到，输入\[0,1\]得到的结果为0110，与训练时候的结果一直。

最后，本代码没有深入测试过，同时也只有一个隐层，所以建议只用来配合梳理算法原理用。

转载于:https://www.cnblogs.com/zhxfl/p/3841746.html

[Link 1]: http://deeplearning.stanford.edu/wiki/index.php/%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C
[Link 2]: http://deeplearning.stanford.edu/wiki/index.php/Backpropagation_Algorithm
[Link 3]: http://deeplearning.stanford.edu/wiki/index.php/%E6%A2%AF%E5%BA%A6%E6%A3%80%E9%AA%8C%E4%B8%8E%E9%AB%98%E7%BA%A7%E4%BC%98%E5%8C%96
[132211598952700.png]: /images/20220109/eb3bc282d91c4aaab490e698fbfb0d5d.png