main.cpp

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

                                                  { "OOOOO",    
                                                    "O    ",    
                                                    "O    ",    
                                                    "O    ",    
                                                    "    O",    
                                                    "O  O",    
                                                    " OOO "  },    
  
                                                  { " OOO ",    
                                                    "   O",    
                                                    "O   ",    
                                                    "OOOO ",    
                                                    "O  O",    
                                                    "   O",    
                                                    " O O "  },    
  
                                                  { "O O O",    
                                                    "    O",    
                                                    "    O",    
                                                    "  O  ",    
                                                    "  O  ",    
                                                    "  O  ",    
                                                    "O    "  },    
  
                                                  { " OOO ",    
                                                    "   O",    
                                                    "O  O",    
                                                    " OOO ",    
                                                    "O  O",    
                                                    "O   ",    
                                                    " OOO "  },    
  
                                                  { "O  O ",    
                                                    "    O",    
                                                    "O   O",    
                                                    "  OOO",    
                                                    "     ",    
                                                    "    O",    
                                                    "O OO "  } };    
/******************************************************************************   
//导师信号，按从上到下的顺序分别表示0～9                    
******************************************************************************/    
  
REAL                  Target[NUM_DATA][M] =                       
                                  { {HI, LO, LO, LO, LO, LO, LO, LO, LO, LO},    
                                    {LO, HI, LO, LO, LO, LO, LO, LO, LO, LO},    
                                    {LO, LO, HI, LO, LO, LO, LO, LO, LO, LO},    
                                    {LO, LO, LO, HI, LO, LO, LO, LO, LO, LO},    
                                    {LO, LO, LO, LO, HI, LO, LO, LO, LO, LO},    
                                    {LO, LO, LO, LO, LO, HI, LO, LO, LO, LO},    
                                    {LO, LO, LO, LO, LO, LO, HI, LO, LO, LO},    
                                    {LO, LO, LO, LO, LO, LO, LO, HI, LO, LO},    
                                    {LO, LO, LO, LO, LO, LO, LO, LO, HI, LO},    
                                    {LO, LO, LO, LO, LO, LO, LO, LO, LO, HI}  };    
/******************************************************************************   
                                    主程序   
******************************************************************************/    
void main()    
{    
  INT  m,n,count;//循环变量    
  NET  Net;//网络变量声明    
  BOOL Stop;//学习是否结束的控制变量    
  
  REAL Error;//记录当前所有样本的最大误差    
  InitializeRandoms();//生成随机数    
  GenerateNetwork(&Net);//创建网络并初始化网络，分配空间    
  RandomWeights(&Net);//初始化网络联接权    
  InitializeApplication(&Net);//初始化输入层，将学习样本转换成输入模式    
     
  count=0;//显示学习进度的控制变量    
  do {    
    Error = 0;//误差    
    Stop = TRUE;//初始化    
    for (n=0; n<NUM_DATA; n++) {    //对每个模式计算模拟神经网络误差    
      SimulateNet(&Net, Input[n],Target[n], FALSE, FALSE);  //计算模拟神经网络误差    
      Error = MAX(Error, Net.Error);//巧妙的做法，获取结构的值,获取误差最大值    
      Stop = Stop AND (Net.Error < Net.Epsilon);    
      count++;    
    }    
    Error = MAX(Error, Net.Epsilon);//作用:防止溢出,保证到100%的时候停止训练，获取误差最大值    
    if (count%300==0){    
        printf("Training %0.0f%% completed \n", (Net.Epsilon / Error) * 100);    
    }//只能做一个参考，并非单调上升的值    
    if (NOT Stop) {    
        for (m=0; m<10*NUM_DATA; m++) { //对各模式进行训练    
        n = RandomEqualINT(0,NUM_DATA-1); //随机选择训练模式       
        SimulateNet(&Net, Input[n],Target[n], TRUE,FALSE );    
      }    
    }       
  } while (NOT Stop);    
  printf("BP神经网络学习结束!\n 请按一键继续工作：读入测试数据进行识别！\n");    
  getch();    
  SaveWeights(&Net);//学习结束后保存宝贵的联接权    
  //网络开始工作     
  Initializetest();//初始化测试样本，将其转化成输入模式    
     
  for (n=0; n<NUM_DATA; n++) {    
    SimulateNet(&Net, Inputtest[n],Target[n], FALSE, TRUE);       
  }    
  FinalizeApplication(&Net);//关闭文件    
  
  printf("BP神经网络完成了识别任务！\n请在result.txt文件中检查识别结果。\n");    
  printf("请按任意键以结束程序！\n");    
  //getch();    
  getch();    
}    
  
/******************************************************************************   
        产生随机数   
******************************************************************************/    
  
//设置伪随机数种子    
void InitializeRandoms()     
{    
  srand(4711);    
}    
//产生一个LOW - TOP之间的伪随机整数    
INT RandomEqualINT(INT Low, INT High)     
{    
  return rand() % (High-Low+1) + Low;    
}         
//产生一个LOW - TOP之间的伪随机浮点数    
REAL RandomEqualREAL(REAL Low, REAL High)    
{    
  return ((REAL) rand() / RAND_MAX) * (High-Low) + Low;    
}    
/******************************************************************************   
  //关闭文件            
******************************************************************************/    
void FinalizeApplication(NET* Net)    
{    
  fclose(f);    
}         
/******************************************************************************   
//随机生成联接权              
******************************************************************************/    
void RandomWeights(NET* Net)     
{    
  INT l,i,j;    
     
  for (l=1; l<NUM_LAYERS; l++) {  //每层    
    for (i=1; i<=Net->Layer[l]->Units; i++) {    
      for (j=0; j<=Net->Layer[l-1]->Units; j++) {    
        Net->Layer[l]->Weight[i][j] = RandomEqualREAL(-0.5, 0.5);//随机值    
      }    
    }    
  }    
}    
/******************************************************************************   
//保存连接权，防止丢失宝贵的联接权                                      
******************************************************************************/    
void SaveWeights(NET* Net)    
{    
  INT l,i,j;    
  
  for (l=1; l<NUM_LAYERS; l++) {    
    for (i=1; i<=Net->Layer[l]->Units; i++) {    
      for (j=0; j<=Net->Layer[l-1]->Units; j++) {    
        Net->Layer[l]->WeightSave[i][j] = Net->Layer[l]->Weight[i][j];    
      }    
    }    
  }    
}    
/******************************************************************************   
//恢复连接权，以便需要的时候可以重新调用，重组网络                
******************************************************************************/    
void RestoreWeights(NET* Net)                   
{    
  INT l,i,j;    
  
  for (l=1; l<NUM_LAYERS; l++) {    
    for (i=1; i<=Net->Layer[l]->Units; i++) {    
      for (j=0; j<=Net->Layer[l-1]->Units; j++) {    
        Net->Layer[l]->Weight[i][j] = Net->Layer[l]->WeightSave[i][j];       
      }    
    }    
  }    
}    
/******************************************************************************   
//创建网络，为网络分配空间                          
******************************************************************************/    
void GenerateNetwork(NET* Net)    
{    
  INT l,i;    
  
  Net->Layer = (LAYER**) calloc(NUM_LAYERS, sizeof(LAYER*));    
     
  for (l=0; l<NUM_LAYERS; l++) {    
    Net->Layer[l] = (LAYER*) malloc(sizeof(LAYER));    
         
    Net->Layer[l]->Units      = Units[l];    
    Net->Layer[l]->Output    = (REAL*)  calloc(Units[l]+1, sizeof(REAL));    
    Net->Layer[l]->Activation = (REAL*)  calloc(Units[l]+1, sizeof(REAL));    
    Net->Layer[l]->Error      = (REAL*)  calloc(Units[l]+1, sizeof(REAL));    
    Net->Layer[l]->Weight    = (REAL**) calloc(Units[l]+1, sizeof(REAL*));    
    Net->Layer[l]->WeightSave = (REAL**) calloc(Units[l]+1, sizeof(REAL*));    
    Net->Layer[l]->dWeight    = (REAL**) calloc(Units[l]+1, sizeof(REAL*));    
    Net->Layer[l]->Output[0]  = BIAS;    
         
    if (l != 0) {    
      for (i=1; i<=Units[l]; i++) {    
        Net->Layer[l]->Weight[i]    = (REAL*) calloc(Units[l-1]+1, sizeof(REAL));    
        Net->Layer[l]->WeightSave[i] = (REAL*) calloc(Units[l-1]+1, sizeof(REAL));    
        Net->Layer[l]->dWeight[i]    = (REAL*) calloc(Units[l-1]+1, sizeof(REAL));    
      }    
    }    
  }    
  Net->InputLayer  = Net->Layer[0];//为输入层分配指针    
  Net->OutputLayer = Net->Layer[NUM_LAYERS-1];//为输出层分配指针    
  Net->Alpha      = 0.8;//冲量参数    
  Net->Eta        = 0.5;//学习率    
  Net->Epsilon    =0.005;//控制精度    
}    
/******************************************************************************   
将输入样本转换成为输入模式，并创建一个文件以保存显示结果