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

  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.                     !!!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!