#include <iostream>
#include <cmath>
#include "stdio.h"
#include "stdlib.h"
#include "time.h"
using namespace std;

#define  innode 8       //輸入結點數
#define  hidenode 4     //隱含結點數
#define  outnode 8      //輸出結點數
#define  trainsample 8  //BP訓練樣本數

class BpNet
{
public:
    void train(double p[trainsample][innode], double
 
 t[trainsample][outnode]);//Bp訓練
    double p[trainsample][innode];     //輸入的樣本
    double t[trainsample][outnode];    //樣本要輸出的

    double *recognize(double *p);      //Bp識別

    BpNet();
    virtual ~BpNet();

public:
    void init();
    double w[innode][hidenode];     //隱含結點權值
    double w1[hidenode][outnode];   //輸出結點權值
 

    double b1[hidenode];            //隱含結點閥值
    double b2[outnode];             //輸出結點閥值

    double rate_w;      //權值學習率（輸入層-隱含層)
    double rate_w1;     //權值學習率 (隱含層-輸出層)
    double rate_b1;     //隱含層閥值學習率
    double rate_b2;     //輸出層閥值學習率

    double e;           //誤差計算
    double error;       //允許的最大誤差
    double
 
 result[outnode];         // Bp輸出
};

BpNet::BpNet()
{
    error=1.0;
    e=0.0;

    rate_w = 0.1;   //權值學習率（輸入層--隱含層)
    rate_w1 = 0.1;  //權值學習率 (隱含層--輸出層)
    rate_b1 = 0.1;  //隱含層閥值學習率
    rate_b2 = 0.1;  //輸出層閥值學習率
}

BpNet::~BpNet()
{

}

//產生[low, high)之間的隨機數
double randval(double low, double high)  
{   
    double val;   
    val = ((double)(rand() % RAND_MAX)/(double)RAND_MAX) * (high - low) + low;   
    return(val);   
}

void winit(double w[], int n) //權值初始化
{
    for(int i=0; i<n; i++)
        w[i] = randval(-0.01, 0.01);
}

//初始化
void BpNet::init()
{
    winit((double*)w, innode * hidenode);
    winit((double*)w1, hidenode * outnode);
    winit(b1, hidenode);
    winit(b2, outnode);
}

//訓練
void BpNet::train(double p[trainsample][innode], double t[trainsample][outnode])
{
    double pp[hidenode];    //隱含結點的校正誤差
    double qq[outnode];     //希望輸出值與實際輸出值的偏差
    double yd[outnode];     //希望輸出值

    double x[innode];       //輸入向量
    double x1[hidenode];    //隱含結點狀態值
    double x2[outnode];     //輸出結點狀態值
    double o1[hidenode];    //隱含層啟用值
    double o2[hidenode];    //輸出層啟用值

    for(int isamp=0; isamp<trainsample; isamp++)  //迴圈訓練一次樣品
    {
        int i, j, k;
        for(i=0; i<innode; i++)
            x[i] = p[isamp][i];     //輸入的樣本
        for(i=0; i<outnode; i++)
            yd[i] = t[isamp][i];    //希望輸出的樣本

        //正向傳播
        //構造每個樣品的輸入和輸出標準
        for(j=0; j<hidenode; j++)
        {
            o1[j] = 0.0;
            for(i=0; i< innode; i++)
                o1[j] += w[i][j] * x[i];                //隱含層各單元輸入啟用值
            x1[j] = 1.0 / (1.0 + exp(-o1[j] - b1[j]));  //隱含層各單元的輸出
        }

        for(k=0; k<outnode; k++)
        {
            o2[k] = 0.0;
            for(int j=0; j<hidenode; j++)
                o2[k] += w1[j][k] * x1[j];              //輸出層各單元輸入啟用值
            x2[k] = 1.0 / (1.0 + exp(-o2[k] - b2[k]));  //輸出層各單元輸出
        }

        //誤差反向傳播
        for(k=0; k<outnode; k++)  //對於網路中每個輸出單元，計算誤差項，並更新權值
        {
            qq[k] = (yd[k] - x2[k]) * x2[k] * (1-x2[k]);    //希望輸出與實際輸出的偏差
            for(j=0; j<hidenode; j++)
                w1[j][k] += rate_w1 * qq[k] * x1[j];        //更新隱含層和輸出層之間的連線權
        }

        for(j=0; j<hidenode; j++) //對於網路中每個隱藏單元，計算誤差項，並更新權值
        {
            pp[j] = 0.0;
            for(k=0; k<outnode; k++)
                pp[j] += qq[k] * w1[j][k];
            pp[j] = pp[j] * x1[j] * (1 - x1[j]);    //隱含層的校正誤差

            for(i=0; i<innode; i++)
                w[i][j] += rate_w * pp[j] * x[i];   //更新輸入層和隱含層之間的連線權
        }

        for(k=0; k<outnode; k++)
        {
            e += pow(yd[k] - x2[k], 2);  //計算均方差
        }
        error = e/2.0;

        for(k=0; k<outnode; k++)
            b2[k] += rate_b2 * qq[k]; //更新隱含層和輸出層之間的閾值
        for(j=0; j<hidenode; j++)
            b1[j] += rate_b1 * pp[j]; //更新輸入層和隱含層之間的閾值
    }
}

//識別
double *BpNet::recognize(double *p)
{
    double x[innode];       //輸入向量
    double x1[hidenode];    //隱含結點狀態值
    double x2[outnode];     //輸出結點狀態值
    double o1[hidenode];    //隱含層啟用值
    double o2[hidenode];    //輸出層啟用值

    int i, j, k;
    for(i=0; i<innode; i++)
        x[i] = p[i];

    for(j=0; j<hidenode; j++)
    {
        o1[j] = 0.0;
        for(i=0; i<innode; i++)
            o1[j] = o1[j] + w[i][j] * x[i];         //隱含層各單元啟用值
        x1[j] = 1.0 / (1.0 + exp(-o1[j] - b1[j]));  //隱含層各單元輸出
    }

    for(k=0; k<outnode; k++)
    {
        o2[k] = 0.0;
        for(j=0; j<hidenode; j++)
            o2[k] = o2[k] + w1[j][k] * x1[j];       //輸出層各單元啟用值
        x2[k] = 1.0 / (1.0 + exp(-o2[k] - b2[k]));  //輸出層各單元輸出
    }

    for(k=0; k<outnode; k++)
    {
        result[k] = x2[k];
    }
    return result;
}

//輸入樣本
double X[trainsample][innode] = 
{
    {1,0,0,0,0,0,0,0},
    {0,1,0,0,0,0,0,0},
    {0,0,1,0,0,0,0,0},
    {0,0,0,1,0,0,0,0},
    {0,0,0,0,1,0,0,0},
    {0,0,0,0,0,1,0,0},
    {0,0,0,0,0,0,1,0},
    {0,0,0,0,0,0,0,1}
};

int main()
{
    srand(time(NULL));
    int i, j, k;
    BpNet bp;
    bp.init();
    int times = 0;

    while(bp.error > 0.0001 && times < 5000)
    {
        bp.e = 0.0;
        times++;
        bp.train(X, X);
    }
    double m[innode] = {0,0,1,0,0,0,0,0};
    bp.recognize(m);
    for(i=0; i<innode; ++i)
        cout << m[i];
    cout << " is ";
    for(i=0; i<outnode; i++)
        printf("%d", (int)floor(bp.result[i] + 0.5));
    cout << endl;
    return 0;
}

當將隱藏結點數設定為：13，可以識別任意2個位置為1的二進位制數