main.cpp

神经网络BP算法,实现数字识别 VC++代码实现

#include <stdlib.h>    
#include <stdio.h>    
#include <math.h>    
#include <conio.h>    
  
/******************************************************************************   
                宏定义                    
******************************************************************************/    
typedef int          BOOL;     
typedef int          INT;    
typedef double        REAL;    
typedef char          CHAR;    
  
#define FALSE        0    
#define TRUE          1    
#define NOT          !    
#define AND          &&    
#define OR            ||    
  
#define MIN(x,y)      ((x)<(y) ? (x) : (y))    
#define MAX(x,y)      ((x)>(y) ? (x) : (y))    
#define sqr(x)        ((x)*(x))    
  
#define LO            0.1    
#define HI            0.9    
#define BIAS          0.5    
  
#define NUM_LAYERS    3      //网络层数    
#define NUM_DATA      10      //样本数    
#define X            6      //每个样本的列数    
#define Y            7      //每个样本的行数    
  
#define N            (X * Y) //输入层神经元个数    
#define M            10      //输出层神经元个数    
/////////////////////////////////////////////////////////////////////////////////////////    
//                              结构变量声明                                              //    
/////////////////////////////////////////////////////////////////////////////////////////    
typedef struct {                       
        INT          Units;        //层神经元数量    
        REAL*        Output;        //输出数 （即输出个矢量元素个数）    
        REAL*        Activation;    //激活值    
        REAL*        Error;        //本层误差               
        REAL**        Weight;        //连接权    
        REAL**        WeightSave;    //保存训练调整后的连接权    
        REAL**        dWeight;      //调整量    
} LAYER;    //神经网络层结构    
  
typedef struct {                       
        LAYER**      Layer;        //神经网络各层指针    
        LAYER*        InputLayer;    //输入层    
        LAYER*        OutputLayer;  //输出层    
        REAL          Alpha;        //冲量参数    
        REAL          Eta;          //学习率           
        REAL          Error;        //总误差    
        REAL          Epsilon;      //控制精度    
} NET; //  神经网络    
  
INT                  Units[NUM_LAYERS] = {N, 10, M}; //用一维数组记录各层神经元个数    
  
FILE*                f;//声明文件指针    
  
REAL                  Input[NUM_DATA][N];//用来记录学习样本输入模式    
REAL                  Inputtest[NUM_DATA][N];//用来记录测试样本输入模式    
  
/******************************************************************************   
                  各函数声明   
******************************************************************************/    
void InitializeRandoms(); //设置伪随机数种子    
INT  RandomEqualINT(INT Low, INT High);//产生一个LOW - TOP之间的伪随机整数    
REAL RandomEqualREAL(REAL Low, REAL High);//产生一个LOW - TOP之间的伪随机浮点数    
void FinalizeApplication(NET* Net);//关闭文件    
void RandomWeights(NET* Net) ;//随机生成网络各层联接权    
void SaveWeights(NET* Net);//保存网络各层联接权，以防丢失宝贵的联接权    
void RestoreWeights(NET* Net);//恢复网络各层联接权，以便重建网络    
void GenerateNetwork(NET* Net);//创建网络，为网络分配空间    
void InitializeApplication(NET* Net);//将学习样本转换成为输入模式，并创建一个文件以保存显示结果    
void SimulateNet(NET* Net, REAL* Input, REAL* Target, BOOL Training,BOOL Protocoling);//将每个样本投入网络运作    
void SetInput(NET* Net, REAL* Input,BOOL Protocoling);// 获得输入层的输出         
void PropagateLayer(NET* Net, LAYER* Lower, LAYER* Upper);//计算当前层的网络输出，upper 为当前层，LOWER为前一层    
void PropagateNet(NET* Net);//计算整个网络各层的输出    
void GetOutput(NET* Net, REAL* Output,BOOL Protocoling);//获得输出层的输出    
void ComputeOutputError(NET* Net, REAL* Target);//计算网络输出层的输出误差    
void BackpropagateLayer(NET* Net, LAYER* Upper, LAYER* Lower);//当前层误差反向传播    
void BackpropagateNet(NET* Net);////整个网络误差的后传    
void AdjustWeights(NET* Net); //调整网络各层联接权，提取样本特征    
void WriteInput(NET* Net, REAL* Input);//显示输入模式       
void WriteOutput(NET* Net, REAL* Output);//显示输出模式     
void Initializetest();//将测试样本转换成为输入模式    
  
/******************************************************************************   
    学习样本      
******************************************************************************/    
CHAR           Pattern[NUM_DATA][Y][X]={    {" OOO ",    
                                              "O  O",    
                                              "O  O",    
                                              "O  O",    
                                              "O  O",    
                                              "O  O",    
                                              " OOO "  },    
  
                                             { "  O  ",    
                                               " OO  ",    
                                               "O O  ",    
                                               "  O  ",    
                                               "  O  ",    
                                               "  O  ",    
                                               "  O  "  },    
  
                                              { " OOO ",    
                                                "O  O",    
                                                "    O",    
                                                "  O ",    
                                                "  O  ",    
                                                " O  ",    
                                                "OOOOO"  },    
  
                                              { " OOO ",    
                                                "O  O",    
                                                "    O",    
                                                " OOO ",    
                                                "    O",    
                                                "O  O",    
                                                " OOO "  },    
  
                                                  { "  O ",    
                                                    "  OO ",    
                                                    " O O ",    
                                                    "O  O ",    
                                                    "OOOOO",    
                                                    "  O ",    
                                                    "  O "  },    
  
                                                  { "OOOOO",    
                                                    "O    ",    
                                                    "O    ",    
                                                    "OOOO ",    
                                                    "    O",    
                                                    "O  O",    
                                                    " OOO "  },    
  
                                                  { " OOO ",    
                                                    "O  O",    
                                                    "O    ",    
                                                    "OOOO ",    
                                                    "O  O",    
                                                    "O  O",    
                                                    " OOO "  },    
  
                                                  { "OOOOO",    
                                                    "    O",    
                                                    "    O",    
                                                    "  O ",    
                                                    "  O  ",    
                                                    " O  ",    
                                                    "O    "  },    
  
                                                  { " OOO ",    
                                                    "O  O",    
                                                    "O  O",    
                                                    " OOO ",    
                                                    "O  O",    
                                                    "O  O",    
                                                    " OOO "  },    
  
                                                  { " OOO ",    
                                                    "O  O",    
                                                    "O  O",    
                                                    " OOOO",    
                                                    "    O",    
                                                    "O  O",    
                                                    " OOO "  } };    
  
/******************************************************************************   
                  测试样本   
******************************************************************************/    
CHAR            testPattern[NUM_DATA][Y][X] = {    {"  OO ",    
                                                    "O  O",    
                                                    "   O",    
                                                    "O  O",    
                                                    "    ",    
                                                    "O  O",    
                                                    " OOO "  },    
  
                                                  { "  O O",    
                                                    "  O O",    
                                                    "  O  ",    
                                                    "    ",    
                                                    "  O  ",    
                                                    "  O  ",    
                                                    "  O  "  },    
  
                                                  { " OOO ",    
                                                    "O  O",    
                                                    "O  O",    
                                                    "    ",    
                                                    "  O  ",    
                                                    " O  ",    
                                                    "OOOOO"  },    
  
                                                  { " OOO ",    
                                                    "O  O",    
                                                    "    O",    
                                                    "O OO ",    
                                                    "    O",    
                                                    "O   ",    
                                                    " OOO "  },    
  
                                                  { "  O ",    
                                                    "  OO ",    
                                                    " O O ",    
                                                    "O  O ",    
                                                    "  OO ",    
                                                    "  O ",    
                                                    "  O "  },