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

具体原理参考如下讲义：

1、神经网络

2、反向传导

3、梯度检验与高级优化

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

//Backpropagation, 25x25x8 units, binary sigmoid function network
//Written by Thomas Riga, University of Genoa, Italy
//thomas@magister.magi.unige.it

#include <iostream>
#include <fstream>
#include <conio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <stdio.h>
#include <float.h>
using namespace std;

double **input,
    *hidden,
    **output,
    **target,
    *bias,
    **weight_i_h,
    **weight_h_o,
    *errorsignal_hidden,
    *errorsignal_output;

int input_array_size,
    hidden_array_size,
    output_array_size,
    max_patterns,
    bias_array_size,
    gaset = -2500,
    number_of_input_patterns,
    pattern,
    file_loaded = 0,
    ytemp = 0,
    ztemp = 0;
double learning_rate,
    max_error_tollerance = 0.1;
char filename[128];
#define IA   16807
#define IM   2147483647
#define AM   (1.0 / IM)
#define IQ   127773
#define IR   2836
#define NTAB 32
#define NDIV (1+(IM-1) / NTAB)
#define EPS  1.2e-7
#define RNMX (1.0 - EPS)
int compare_output_to_target();
void load_data(char *arg);
void save_data(char *argres);
void forward_pass(int pattern);
void backward_pass(int pattern);
void custom();
void compute_output_pattern();
void get_file_name();
float bedlam(long *idum);
void learn();
void make();
void test();
void print_data();
void print_data_to_screen();
void print_data_to_file();
void output_to_screen();
int getnumber();
void change_learning_rate();
void initialize_net();
void clear_memory();

int main()
{
    cout << "backpropagation network by Thomas Riga, University of Genoa, Italy" << endl;
    for(;;) {
        char choice;
        cout << endl << "1. load data" << endl;
        cout << "2. learn from data" << endl;
        cout << "3. compute output pattern" << endl;
        cout << "4. make new data file" << endl;
        cout << "5. save data" << endl;
        cout << "6. print data" << endl;
        cout << "7. change learning rate" << endl;
        cout << "8. exit" << endl << endl;
        cout << "Enter your choice (1-8)";
        do { choice = getch(); } while (choice != '1' && choice != '2' && choice != '3' && choice != '4' && choice != '5' && choice != '6' && choice != '7' && choice != '8');
        switch(choice) {
        case '1':
            {
                if (file_loaded == 1) clear_memory();
                get_file_name();
                file_loaded = 1;
                load_data(filename);
            }
            break;
        case '2': learn();
            break;
        case '3': compute_output_pattern();
            break;
        case '4': make();
            break;
        case '5':
            {
                if (file_loaded == 0)
                {
                    cout << endl
                        << "there is no data loaded into memory"
                        << endl;
                    break;
                }
                cout << endl << "enter a filename to save data to: ";
                cin >> filename;
                save_data(filename);
            }
            break;
        case '6': print_data();
            break;
        case '7': change_learning_rate();
            break;
        case '8': return 0;
        };
    }
}

void initialize_net()
{
    int x;
    input = new double * [number_of_input_patterns];
    if(!input) { cout << endl << "memory problem!"; exit(1); }
    for(x=0; x<number_of_input_patterns; x++)
    {
        input[x] = new double [input_array_size];
        if(!input[x]) { cout << endl << "memory problem!"; exit(1); }
    }
    hidden = new double [hidden_array_size];
    if(!hidden) { cout << endl << "memory problem!"; exit(1); }
    output = new double * [number_of_input_patterns];
    if(!output) { cout << endl << "memory problem!"; exit(1); }
    for(x=0; x<number_of_input_patterns; x++)
    {
        output[x] = new double [output_array_size];
        if(!output[x]) { cout << endl << "memory problem!"; exit(1); }
    }
    target = new double * [number_of_input_patterns];
    if(!target) { cout << endl << "memory problem!"; exit(1); }
    for(x=0; x<number_of_input_patterns; x++)
    {
        target[x] = new double [output_array_size];
        if(!target[x]) { cout << endl << "memory problem!"; exit(1); }
    }
    bias = new double [bias_array_size];
    if(!bias) { cout << endl << "memory problem!"; exit(1); }
    weight_i_h = new double * [input_array_size];
    if(!weight_i_h) { cout << endl << "memory problem!"; exit(1); }
    for(x=0; x<input_array_size; x++)
    {
        weight_i_h[x] = new double [hidden_array_size];
        if(!weight_i_h[x]) { cout << endl << "memory problem!"; exit(1); }
    }
    weight_h_o = new double * [hidden_array_size];
    if(!weight_h_o) { cout << endl << "memory problem!"; exit(1); }
    for(x=0; x<hidden_array_size; x++)
    {
        weight_h_o[x] = new double [output_array_size];
        if(!weight_h_o[x]) { cout << endl << "memory problem!"; exit(1); }
    }
    errorsignal_hidden = new double [hidden_array_size];
    if(!errorsignal_hidden) { cout << endl << "memory problem!"; exit(1); }
    errorsignal_output = new double [output_array_size];
    if(!errorsignal_output) { cout << endl << "memory problem!"; exit(1); }
    return;
}

void learn()
{
    if (file_loaded == 0)
    {
        cout << endl
            << "there is no data loaded into memory"
            << endl;
        return;
    }
    cout << endl << "learning..." << endl << "press a key to return to menu" << endl;
    register int y;
    while(!kbhit()) {
        for(y=0; y<number_of_input_patterns; y++) {
            forward_pass(y);
            backward_pass(y);
        }
        if(compare_output_to_target()) {
            cout << endl << "learning successful" << endl;
            return;
        }

    }
    cout << endl << "learning not successful yet" << endl;
    return;
}

void load_data(char *arg) {
    int x, y;
    ifstream in(arg);
    if(!in) { cout << endl << "failed to load data file" << endl; file_loaded = 0; return; }
    in >> input_array_size;
    in >> hidden_array_size;
    in >> output_array_size;
    in >> learning_rate;
    in >> number_of_input_patterns;
    bias_array_size = hidden_array_size + output_array_size;
    initialize_net();
    for(x = 0; x < bias_array_size; x++) in >> bias[x];
    for(x=0; x<input_array_size; x++) { 
        for(y=0; y<hidden_array_size; y++) in >> weight_i_h[x][y];
    }
    for(x = 0; x < hidden_array_size; x++) { 
        for(y=0; y<output_array_size; y++) in >> weight_h_o[x][y];
    }
    for(x=0; x < number_of_input_patterns; x++) {
        for(y=0; y<input_array_size; y++) in >> input[x][y];
    }
    for(x=0; x < number_of_input_patterns; x++) {
        for(y=0; y<output_array_size; y++) in >> target[x][y];
    }
    in.close();
    cout << endl << "data loaded" << endl;
    return;
}


void forward_pass(int pattern)
{
    _control87(MCW_EM, MCW_EM);
    register double temp=0;
    register int x,y;

    // INPUT -> HIDDEN
    for(y=0; y<hidden_array_size; y++) {
        for(x=0; x<input_array_size; x++) {
            temp += (input[pattern][x] * weight_i_h[x][y]);
        }
        hidden[y] = (1.0 / (1.0 + exp(-1.0 * (temp + bias[y]))));
        temp = 0;
    }

    // HIDDEN -> OUTPUT
    for(y=0; y<output_array_size; y++) {
        for(x=0; x<hidden_array_size; x++) {
            temp += (hidden[x] * weight_h_o[x][y]);
        }
        output[pattern][y] = (1.0 / (1.0 + exp(-1.0 * (temp + bias[y + hidden_array_size]))));
        temp = 0;
    }
    return;
}



void backward_pass(int pattern)
{
    register int x, y;
    register double temp = 0;

    // COMPUTE ERRORSIGNAL FOR OUTPUT UNITS
    for(x=0; x<output_array_size; x++) {
        errorsignal_output[x] = (target[pattern][x] - output[pattern][x]);
    }

    // COMPUTE ERRORSIGNAL FOR HIDDEN UNITS
    for(x=0; x<hidden_array_size; x++) {
        for(y=0; y<output_array_size; y++) { 
            temp += (errorsignal_output[y] * weight_h_o[x][y]);
        }
        errorsignal_hidden[x] = hidden[x] * (1-hidden[x]) * temp;
        temp = 0.0;
    }

    // ADJUST WEIGHTS OF CONNECTIONS FROM HIDDEN TO OUTPUT UNITS
    double length = 0.0;
    for (x=0; x<hidden_array_size; x++) {
        length += hidden[x]*hidden[x];
    }
    if (length<=0.1) length = 0.1;
    for(x=0; x<hidden_array_size; x++) {
        for(y=0; y<output_array_size; y++) {
            weight_h_o[x][y] += (learning_rate * errorsignal_output[y] * 
                hidden[x]/length);
        }
    }

    // ADJUST BIASES OF HIDDEN UNITS
    for(x=hidden_array_size; x<bias_array_size; x++) {
        bias[x] += (learning_rate * errorsignal_output[x] / length);
    }

    // ADJUST WEIGHTS OF CONNECTIONS FROM INPUT TO HIDDEN UNITS
    length = 0.0;
    for (x=0; x<input_array_size; x++) {
        length += input[pattern][x]*input[pattern][x];
    }
    if (length<=0.1) length = 0.1;
    for(x=0; x<input_array_size; x++) {
        for(y=0; y<hidden_array_size; y++) {
            weight_i_h[x][y] += (learning_rate * errorsignal_hidden[y] * 
                input[pattern][x]/length);
        }
    }

    // ADJUST BIASES FOR OUTPUT UNITS
    for(x=0; x<hidden_array_size; x++) {
        bias[x] += (learning_rate * errorsignal_hidden[x] / length);
    }
    return;
}

int compare_output_to_target()
{
    register int y,z;
    register double temp, error = 0.0;
    temp = target[ytemp][ztemp] - output[ytemp][ztemp];
    if (temp < 0) error -= temp;
    else error += temp;
    if(error > max_error_tollerance) return 0;
    error = 0.0;
    for(y=0; y < number_of_input_patterns; y++) {
        for(z=0; z < output_array_size; z++) {
            temp = target[y][z] - output[y][z];
            if (temp < 0) error -= temp;
            else error += temp;
            if(error > max_error_tollerance) {
                ytemp = y;
                ztemp = z;
                return 0;
            }
            error = 0.0;
        }
    }
    return 1;
}

void save_data(char *argres) {
    int x, y;
    ofstream out;    
    out.open(argres);
    if(!out) { cout << endl << "failed to save file" << endl; return; }
    out << input_array_size << endl;
    out << hidden_array_size << endl;
    out << output_array_size << endl;
    out << learning_rate << endl;
    out << number_of_input_patterns << endl << endl;
    for(x=0; x<bias_array_size; x++) out << bias[x] << ' ';
    out << endl << endl;
    for(x=0; x<input_array_size; x++) {
        for(y=0; y<hidden_array_size; y++) out << weight_i_h[x][y] << ' ';
    }
    out << endl << endl;
    for(x=0; x<hidden_array_size; x++) {
        for(y=0; y<output_array_size; y++) out << weight_h_o[x][y] << ' ';
    }
    out << endl << endl;
    for(x=0; x<number_of_input_patterns; x++) {
        for(y=0; y<input_array_size; y++) out << input[x][y] << ' ';
        out << endl;
    }
    out << endl;
    for(x=0; x<number_of_input_patterns; x++) {
        for(y=0; y<output_array_size; y++) out << target[x][y] << ' ';
        out << endl;
    }
    out.close();
    cout << endl << "data saved" << endl;
    return;
}    

void make()
{
    int x, y, z;
    double inpx, bias_array_size, input_array_size, hidden_array_size, output_array_size;
    char makefilename[128];
    cout << endl << "enter name of new data file: ";
    cin >> makefilename;
    ofstream out;
    out.open(makefilename);
    if(!out) { cout << endl << "failed to open file" << endl; return;}
    cout << "how many input units? ";
    cin >> input_array_size;
    out << input_array_size << endl;
    cout << "how many hidden units? ";
    cin >> hidden_array_size;
    out << hidden_array_size << endl;
    cout << "how many output units? ";
    cin >> output_array_size;
    out << output_array_size << endl;
    bias_array_size = hidden_array_size + output_array_size;
    cout << endl << "Learning rate: ";
    cin >> inpx;
    out << inpx << endl;
    cout << endl << "Number of input patterns: ";
    cin >> z;
    out << z << endl << endl;
    for(x=0; x<bias_array_size; x++) out << (1.0 - (2.0 * bedlam((long*)(gaset)))) << ' ';
    out << endl << endl;
    for(x=0; x<input_array_size; x++) {
        for(y=0; y<hidden_array_size; y++) out << (1.0 - (2.0 * bedlam((long*)(gaset)))) << ' ';
    }
    out << endl << endl;
    for(x=0; x<hidden_array_size; x++) {
        for(y=0; y<output_array_size; y++) out << (1.0 - (2.0 * bedlam((long*)(gaset)))) << ' ';
    }
    out << endl << endl;
    for(x=0; x < z; x++) {
        cout << endl << "input pattern " << (x + 1) << endl;
        for(y=0; y<input_array_size; y++) {
            cout << (y+1) << ": ";
            cin >> inpx;
            out << inpx << ' ';
        }
        out << endl;
    }
    out << endl;
    for(x=0; x < z; x++) {
        cout << endl << "target output pattern " << (x+1) << endl;
        for(y=0; y<output_array_size; y++) {
            cout << (y+1) << ": ";
            cin >> inpx;
            out << inpx << ' ';
        }
        out << endl;
    }
    out.close();
    cout << endl << "data saved, to work with this new data file you first have to load it" << endl;
    return;
}

float bedlam(long *idum)
{
    int xj;
    long xk;
    static long iy=0;
    static long iv[NTAB];
    float temp;

    if(*idum <= 0 || !iy)
    {
        if(-(*idum) < 1)
        {
            *idum = 1 + *idum;
        }
        else
        {
            *idum = -(*idum);
        }
        for(xj = NTAB+7; xj >= 0; xj--)
        {
            xk = (*idum) / IQ;
            *idum = IA * (*idum - xk * IQ) - IR * xk;
            if(*idum < 0)
            {
                *idum += IM;
            }
            if(xj < NTAB)
            {
                iv[xj] = *idum;
            }
        }
        iy = iv[0];
    }

    xk = (*idum) / IQ;
    *idum = IA * (*idum - xk * IQ) - IR * xk;
    if(*idum < 0)
    {
        *idum += IM;
    }
    xj = iy / NDIV;
    iy = iv[xj];
    iv[xj] = *idum;

    if((temp=AM*iy) > RNMX)
    {
        return(RNMX);
    }
    else
    {
        return(temp);
    }
}

void test()
{
    pattern = 0;
    while(pattern == 0) {
        cout << endl << endl << "There are " << number_of_input_patterns << " input patterns in the file," << endl << "enter a number within this range: ";
        pattern = getnumber();
    }
    pattern--;
    forward_pass(pattern);
    output_to_screen();
    return;
}

void output_to_screen()
{
    int x;
    cout << endl << "Output pattern:" << endl;
    for(x=0; x<output_array_size; x++) {
        cout << endl << (x+1) << ": " << output[pattern][x] << "    binary: ";
        if(output[pattern][x] >= 0.9) cout << "1";
        else if(output[pattern][x]<=0.1) cout << "0";
        else cout << "intermediate value";
    }
    cout << endl;
    return;
}

int getnumber()
{
    int a, b = 0;
    char c, d[5];
    while(b<4) {
        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);
        if(toascii(c)==13) break;
        if(toascii(c)==27) return 0;
        d[b] = c;
        cout << c;
        b++;
    }
    d[b] = '';
    a = atoi(d);
    if(a < 0 || a > number_of_input_patterns) a = 0;
    return a;
}

void get_file_name()
{
    cout << endl << "enter name of file to load: ";
    cin >> filename;
    return;
}

void print_data()
{
    char choice;
    if (file_loaded == 0)
    {
        cout << endl
            << "there is no data loaded into memory"
            << endl;
        return;
    }
    cout << endl << "1. print data to screen" << endl;
    cout << "2. print data to file" << endl;
    cout << "3. return to main menu" << endl << endl;
    cout << "Enter your choice (1-3)" << endl;
    do { choice = getch(); } while (choice != '1' && choice != '2' && choice != '3');
    switch(choice) {
    case '1': print_data_to_screen();
        break;
    case '2': print_data_to_file();
        break;
    case '3': return;
    };
    return;
}


void print_data_to_screen() {
    register int x, y;
    cout << endl << endl << "DATA FILE: " << filename << endl;
    cout << "learning rate: " << learning_rate << endl;
    cout << "input units: " << input_array_size << endl;
    cout << "hidden units: " << hidden_array_size << endl;
    cout << "output units: " << output_array_size << endl;
    cout << "number of input and target output patterns: " << number_of_input_patterns  << endl << endl;
    cout << "INPUT AND TARGET OUTPUT PATTERNS:";
    for(x=0; x<number_of_input_patterns; x++) {
        cout << endl << "input pattern: " << (x+1) << endl;
        for(y=0; y<input_array_size; y++) cout << input[x][y] << "  ";
        cout << endl << "target output pattern: " << (x+1) << endl;
        for(y=0; y<output_array_size; y++) cout << target[x][y] << "  ";
    }
    cout << endl << endl << "BIASES:" << endl;
    for(x=0; x<hidden_array_size; x++) {
        cout << "bias of hidden unit " << (x+1) << ": " << bias[x];
        if(x<output_array_size) cout << "      bias of output unit " << (x+1) << ": " << bias[x+hidden_array_size];
        cout << endl;
    }
    cout << endl << "WEIGHTS:" << endl;
    for(x=0; x<input_array_size; x++) {
        for(y=0; y<hidden_array_size; y++) cout << "i_h[" << x << "][" << y << "]: " << weight_i_h[x][y] << endl;
    }
    for(x=0; x<hidden_array_size; x++) {
        for(y=0; y<output_array_size; y++) cout << "h_o[" << x << "][" << y << "]: " << weight_h_o[x][y] << endl;
    }
    return;
}

void print_data_to_file()
{
    char printfile[128];
    cout << endl << "enter name of file to print data to: ";
    cin >> printfile;
    ofstream out;
    out.open(printfile);
    if(!out) { cout << endl << "failed to open file"; return; }
    register int x, y;
    out << endl << endl << "DATA FILE: " << filename << endl;
    out << "input units: " << input_array_size << endl;
    out << "hidden units: " << hidden_array_size << endl;
    out << "output units: " << output_array_size << endl;
    out << "learning rate: " << learning_rate << endl;
    out << "number of input and target output patterns: " << number_of_input_patterns << endl << endl;
    out << "INPUT AND TARGET OUTPUT PATTERNS:";
    for(x=0; x<number_of_input_patterns; x++) {
        out << endl << "input pattern: " << (x+1) << endl;
        for(y=0; y<input_array_size; y++) out << input[x][y] << "  ";
        out << endl << "target output pattern: " << (x+1) << endl;
        for(y=0; y<output_array_size; y++) out << target[x][y] << "  ";
    }
    out << endl << endl << "BIASES:" << endl;
    for(x=0; x<hidden_array_size; x++) {
        out << "bias of hidden unit " << (x+1) << ": " << bias[x];
        if(x<output_array_size) out << "      bias of output unit " << (x+1) << ": " << bias[x+hidden_array_size];
        out << endl;
    }
    out << endl << "WEIGHTS:" << endl;
    for(x=0; x<input_array_size; x++) {
        for(y=0; y<hidden_array_size; y++) out << "i_h[" << x << "][" << y << "]: " << weight_i_h[x][y] << endl;
    }
    for(x=0; x<hidden_array_size; x++) {
        for(y=0; y<output_array_size; y++) out << "h_o[" << x << "][" << y << "]: " << weight_h_o[x][y] << endl;
    }
    out.close();
    cout << endl << "data has been printed to " << printfile << endl;
    return;
}

void change_learning_rate()
{
    if (file_loaded == 0)
    {
        cout << endl
            << "there is no data loaded into memory"
            << endl;
        return;
    }
    cout << endl << "actual learning rate: " << learning_rate << " new value: ";
    cin >> learning_rate;
    return;
}

void compute_output_pattern()
{
    if (file_loaded == 0)
    {
        cout << endl
            << "there is no data loaded into memory"
            << endl;
        return;
    }
    char choice;
    cout << endl << endl << "1. load trained input pattern into network" << endl;
    cout << "2. load custom input pattern into network" << endl;
    cout << "3. go back to main menu" << endl << endl;
    cout << "Enter your choice (1-3)" << endl;
    do { choice = getch(); } while (choice != '1' && choice != '2' && choice != '3');
    switch(choice) {
    case '1': test();
        break;
    case '2': custom();
        break;
    case '3': return;
    };
}

void custom()
{
    _control87 (MCW_EM, MCW_EM);
    char filename[128];
    register double temp=0;
    register int x,y;
    double *custom_input = new double [input_array_size];
    if(!custom_input)
    {
        cout << endl << "memory problem!";
        return;
    }
    double *custom_output = new double [output_array_size];
    if(!custom_output)
    {
        delete [] custom_input;
        cout << endl << "memory problem!";
        return;
    }
    cout << endl << endl << "enter file that contains test input pattern: ";
    cin >> filename;
    ifstream in(filename);
    if(!in) { cout << endl << "failed to load data file" << endl; return; }
    for(x = 0; x < input_array_size; x++) {
        in >> custom_input[x];
    }
    for(y=0; y<hidden_array_size; y++) {
        for(x=0; x<input_array_size; x++) {
            temp += (custom_input[x] * weight_i_h[x][y]);
        }
        hidden[y] = (1.0 / (1.0 + exp(-1.0 * (temp + bias[y]))));
        temp = 0;
    }
    for(y=0; y<output_array_size; y++) {
        for(x=0; x<hidden_array_size; x++) {
            temp += (hidden[x] * weight_h_o[x][y]);
        }
        custom_output[y] = (1.0 / (1.0 + exp(-1.0 * (temp + bias[y + hidden_array_size]))));
        temp = 0;
    }
    cout << endl << "Input pattern:" << endl;
    for(x = 0; x < input_array_size; x++) {
        cout << "[" << (x + 1) << ": " << custom_input[x] << "]  ";
    }
    cout << endl << endl << "Output pattern:";
    for(x=0; x<output_array_size; x++) {
        cout << endl << (x+1) << ": " << custom_output[x] << "    binary: ";
        if(custom_output[x] >= 0.9) cout << "1";
        else if(custom_output[x]<=0.1) cout << "0";
        else cout << "intermediate value";
    }
    cout << endl;
    delete [] custom_input;
    delete [] custom_output;
    return;
}

void clear_memory()
{
    int x;
    for(x=0; x<number_of_input_patterns; x++)
    {
        delete [] input[x];
    }
    delete [] input;
    delete [] hidden;
    for(x=0; x<number_of_input_patterns; x++)
    {
        delete [] output[x];
    }
    delete [] output;
    for(x=0; x<number_of_input_patterns; x++)
    {
        delete [] target[x];
    }
    delete [] target;
    delete [] bias;
    for(x=0; x<input_array_size; x++)
    {
        delete [] weight_i_h[x];
    }
    delete [] weight_i_h;
    for(x=0; x<hidden_array_size; x++)
    {
        delete [] weight_h_o[x];
    }
    delete [] weight_h_o;
    delete [] errorsignal_hidden;
    delete [] errorsignal_output;
    file_loaded = 0;
    return;
}

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

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],对应的输入结果如下：

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

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