设为首页收藏本站联系我们
切换到宽版

声振论坛

 找回密码
 我要加入

QQ登录

只需一步，快速开始

声振论坛»论坛 › 算法编程 › 算法及编程语言 › 用BP神经网络算法实现数字识别
返回列表 发新帖
查看: 3194|回复: 6

[人工智能] 用BP神经网络算法实现数字识别

[复制链接]
frogfish
发表于 2007-7-5 15:01 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？我要加入

x
转：http://www.higo123.com/hg/r.asp?id=16&tid=873

  1. /* =====================
  2. 用BP神经网络算法实现数字识别
  3. ************************/
  4. #include <stdlib.h>
  5. #include <stdio.h>
  6. #include <math.h>
  7. #include <conio.h>  /***********************
  8. 宏定义
  9. ************************/
  10. typedef int BOOL;  
  11. typedef int INT;
  12. typedef double REAL;
  13. typedef char CHAR;  #define FALSE 0
  14. #define TRUE 1
  15. #define NOT !
  16. #define AND &&
  17. #define OR   ||  #define MIN(x,y)      ((x)<(y) ? (x) : (y))
  18. #define MAX(x,y)      ((x)>(y) ? (x) : (y))
  19. #define sqr(x) ((x)*(x))  #define LO   0.1
  20. #define HI   0.9
  21. #define BIAS 0.5  #define NUM_LAYERS    3      //网络层数
  22. #define NUM_DATA      10      //样本数
  23. #define X   6      //每个样本的列数
  24. #define Y   7      //每个样本的行数  #define N   (X * Y) //输入层神经元个数
  25. #define M   10      //输出层神经元个数
  26. ///////////////////////////
  27. //  结构变量声明       //
  28. ///////////////////////////
  29. typedef struct {   
  30. INT Units; //层神经元数量
  31. REAL* Output; //输出数 （即输出个矢量元素个数）
  32. REAL* Activation;    //激活值
  33. REAL* Error; //本层误差   
  34. REAL** Weight; //连接权
  35. REAL** WeightSave;    //保存训练调整后的连接权
  36. REAL** dWeight;      //调整量
  37. } LAYER;    //神经网络层结构  typedef struct {   
  38. LAYER**      Layer; //神经网络各层指针
  39. LAYER* InputLayer;    //输入层
  40. LAYER* OutputLayer;  //输出层
  41. REAL Alpha; //冲量参数
  42. REAL Eta; //学习率
  43. REAL Error; //总误差
  44. REAL Epsilon;      //控制精度
  45. } NET; //  神经网络  INT Units[NUM_LAYERS] = {N, 10, M}; //用一维数组记录各层神经元个数  FILE* f;//声明文件指针  REAL Input[NUM_DATA][N];//用来记录学习样本输入模式
  46. REAL Inputtest[NUM_DATA][N];//用来记录测试样本输入模式  /***********************
  47. 各函数声明
  48. ************************/
  49. void InitializeRandoms(); //设置伪随机数种子
  50. INT  RandomEqualINT(INT Low, INT High);//产生一个LOW - TOP之间的伪随机整数
  51. REAL RandomEqualREAL(REAL Low, REAL High);//产生一个LOW - TOP之间的伪随机浮点数
  52. void FinalizeApplication(NET* Net);//关闭文件
  53. void RandomWeights(NET* Net) ;//随机生成网络各层联接权
  54. void SaveWeights(NET* Net);//保存网络各层联接权，以防丢失宝贵的联接权
  55. void RestoreWeights(NET* Net);//恢复网络各层联接权，以便重建网络
  56. void GenerateNetwork(NET* Net);//创建网络，为网络分配空间
  57. void InitializeApplication(NET* Net);//将学习样本转换成为输入模式，并创建一个文件以保存显示结果
  58. void SimulateNet(NET* Net, REAL* Input, REAL* Target, BOOL Training,BOOL Protocoling);//将每个样本投入网络运作
  59. void SetInput(NET* Net, REAL* Input,BOOL Protocoling);// 获得输入层的输出      
  60. void PropagateLayer(NET* Net, LAYER* Lower, LAYER* Upper);//计算当前层的网络输出，upper 为当前层，LOWER为前一层
  61. void PropagateNet(NET* Net);//计算整个网络各层的输出
  62. void GetOutput(NET* Net, REAL* Output,BOOL Protocoling);//获得输出层的输出
  63. void ComputeOutputError(NET* Net, REAL* Target);//计算网络输出层的输出误差
  64. void BackpropagateLayer(NET* Net, LAYER* Upper, LAYER* Lower);//当前层误差反向传播
  65. void BackpropagateNet(NET* Net);////整个网络误差的后传
  66. void AdjustWeights(NET* Net); //调整网络各层联接权，提取样本特征
  67. void WriteInput(NET* Net, REAL* Input);//显示输入模式   
  68. void WriteOutput(NET* Net, REAL* Output);//显示输出模式  
  69. void Initializetest();//将测试样本转换成为输入模式
复制代码
回复
分享到：

使用道具 举报

frogfish
 楼主| 发表于 2007-7-5 15:01 | 显示全部楼层
  1. /***********************
  2.     学习样本   
  3. ************************/
  4. CHAR Pattern[NUM_DATA][Y][X]={
  5. {" OOO ",
  6. "O   O",
  7. "O   O",
  8. "O   O",
  9. "O   O",
  10. "O   O",
  11. " OOO "  },

  13. {"  O  ",
  14. " OO  ",
  15. "O O  ",
  16. "  O  ",
  17. "  O  ",
  18. "  O  ",
  19. "  O  "  },

  21. {" OOO ",
  22. "O   O",
  23. "    O",
  24. "  O ",
  25. "  O  ",
  26. " O  ",
  27. "OOOOO"  },

  29. {" OOO ",
  30. "O   O",
  31. "    O",
  32. " OOO ",
  33. "    O",
  34. "O   O",
  35. " OOO "  },

  37. {"   O ",
  38. "  OO ",
  39. " O O ",
  40. "O  O ",
  41. "OOOOO",
  42. "   O ",
  43. "   O "  },

  45. {"OOOOO",
  46. "O    ",
  47. "O    ",
  48. "OOOO ",
  49. "    O",
  50. "O   O",
  51. " OOO "  },

  53. {" OOO ",
  54. "O   O",
  55. "O    ",
  56. "OOOO ",
  57. "O   O",
  58. "O   O",
  59. " OOO "  },

  61. {"OOOOO",
  62. "    O",
  63. "    O",
  64. "   O ",
  65. "  O  ",
  66. " O   ",
  67. "O    "  },

  69. {" OOO ",
  70. "O   O",
  71. "O   O",
  72. " OOO ",
  73. "O   O",
  74. "O   O",
  75. " OOO "  },

  77. {" OOO ",
  78. "O   O",
  79. "O   O",
  80. " OOOO",
  81. "    O",
  82. "O   O",
  83. " OOO "  } };

  85. /***********************
  86.      测试样本
  87. ************************/
  88. CHAR   testPattern[NUM_DATA][Y][X] = {   
  89. {" OO ",
  90. "O   O",
  91. "O   O",
  92. "O   O",
  93. "     ",
  94. "O   O",
  95. " OOO "  },

  97. {"  O O",
  98. "  O O",
  99. "  O  ",
  100. "     ",
  101. "  O  ",
  102. "  O  ",
  103. "  O  "  },

  105. {" OOO ",
  106. "O   O",
  107. "O   O",
  108. "   O ",
  109. "  O  ",
  110. " O  ",
  111. "OOOOO"  },

  113. {" OOO ",
  114. "O   O",
  115. "    O",
  116. "OOOO ",
  117. "    O",
  118. "O   O",
  119. " OOO "  },

  121. {"   O ",
  122. "  OO ",
  123. " O O ",
  124. "O  O ",
  125. "  OO ",
  126. "   O ",
  127. "   O "  },

  129. {"OOOOO",
  130. "O    ",
  131. "O    ",
  132. "O    ",
  133. "    O",
  134. "O   O",
  135. " OOO "  },

  137. {" OOO ",
  138. "O   O",
  139. "O   O",
  140. "O    ",
  141. "O   O",
  142. "O   O",
  143. " O O "  },

  145. {"  O  ",
  146. " OO  ",
  147. "O O  ",
  148. "  O  ",
  149. "  O  ",
  150. "  O  ",
  151. "  O  "  },

  153. {" OOO ",
  154. "O   O",
  155. "O   O",
  156. " OOO ",
  157. "O   O",
  158. "O   O",
  159. " OOO "  },

  161. {" OOO ",
  162. "O O O",
  163. "O O O",
  164. " OOOO",
  165. "    O",
  166. "O   O",
  167. " OOO "  } };

  169. /***********************
  170. //导师信号，按从上到下的顺序分别表示0～9
  171. ************************/  REAL Target[NUM_DATA][M] =   
  172.   { {HI, LO, LO, LO, LO, LO, LO, LO, LO, LO},
  173.   {LO, HI, LO, LO, LO, LO, LO, LO, LO, LO},
  174.   {LO, LO, HI, LO, LO, LO, LO, LO, LO, LO},
  175.   {LO, LO, LO, HI, LO, LO, LO, LO, LO, LO},
  176.   {LO, LO, LO, LO, HI, LO, LO, LO, LO, LO},
  177.   {LO, LO, LO, LO, LO, HI, LO, LO, LO, LO},
  178.   {LO, LO, LO, LO, LO, LO, HI, LO, LO, LO},
  179.   {LO, LO, LO, LO, LO, LO, LO, HI, LO, LO},
  180.   {LO, LO, LO, LO, LO, LO, LO, LO, HI, LO},
  181.   {LO, LO, LO, LO, LO, LO, LO, LO, LO, HI}  };
复制代码
回复 支持 反对

使用道具 举报

frogfish
 楼主| 发表于 2007-7-5 15:03 | 显示全部楼层
  1. /***********************
  2.   主程序
  3. ************************/
  4. void main()
  5. {
  6.   INT  m,n,count;//循环变量
  7.   NET  Net;//网络变量声明
  8.   BOOL Stop;//学习是否结束的控制变量    REAL Error;//记录当前所有样本的最大误差
  9.   InitializeRandoms();//生成随机数
  10.   GenerateNetwork(&Net);//创建网络并初始化网络，分配空间
  11.   RandomWeights(&Net);//初始化网络联接权
  12.   InitializeApplication(&Net);//初始化输入层，将学习样本转换成输入模式
  13.   
  14.   count=0;//显示学习进度的控制变量
  15.   do {
  16.     Error = 0;//误差
  17.     Stop = TRUE;//初始化
  18.     for (n=0; n<NUM_DATA; n++) {    //对每个模式计算模拟神经网络误差
  19.       SimulateNet(&Net, Input[n],Target[n], FALSE, FALSE);  //计算模拟神经网络误差
  20.       Error = MAX(Error, Net.Error);//巧妙的做法，获取结构的值,获取误差最大值
  21.       Stop = Stop AND (Net.Error < Net.Epsilon);
  22.       count++;
  23.     }
  24.     Error = MAX(Error, Net.Epsilon);//作用:防止溢出,保证到100%的时候停止训练，获取误差最大值
  25.     if (count%300==0){
  26. printf("Training %0.0f%% completed ...\\n", (Net.Epsilon / Error) * 100);
  27.     }//只能做一个参考，并非单调上升的值
  28.     if (NOT Stop) {
  29. for (m=0; m<10*NUM_DATA; m++) { //对各模式进行训练
  30. n = RandomEqualINT(0,NUM_DATA-1); //随机选择训练模式   
  31. SimulateNet(&Net, Input[n],Target[n], TRUE,FALSE );
  32.       }
  33.     }   
  34.   } while (NOT Stop);
  35.   printf("Network learning is Over!\\n Please put any key to work.\\n");
  36.   getch();
  37.   SaveWeights(&Net);//学习结束后保存宝贵的联接权
  38.   //网络开始工作  
  39.   Initializetest();//初始化测试样本，将其转化成输入模式
  40.   
  41.   for (n=0; n<NUM_DATA; n++) {
  42.     SimulateNet(&Net, Inputtest[n],Target[n], FALSE, TRUE);   
  43.   }
  44.   FinalizeApplication(&Net);//关闭文件    printf("Network finish it’s work .\\nPlease check the rusult in the file:result.txt.\\n");
  45.   printf("Please put any key to over this program.\\n");
  46.   getch();
  47.   getch();
  48. }  /***********************
  49. 产生随机数
  50. ************************/  //设置伪随机数种子
  51. void InitializeRandoms()  
  52. {
  53.   srand(4711);
  54. }
  55. //产生一个LOW - TOP之间的伪随机整数
  56. INT RandomEqualINT(INT Low, INT High)  
  57. {
  58.   return rand() % (High-Low+1) + Low;
  59. }      
  60. //产生一个LOW - TOP之间的伪随机浮点数
  61. REAL RandomEqualREAL(REAL Low, REAL High)
  62. {
  63.   return ((REAL) rand() / RAND_MAX) * (High-Low) + Low;
  64. }
  65. /***********************
  66.   //关闭文件
  67. ************************/
  68. void FinalizeApplication(NET* Net)
  69. {
  70.   fclose(f);
  71. }      
  72. /***********************
  73. //随机生成联接权   
  74. ************************/
  75. void RandomWeights(NET* Net)  
  76. {
  77.   INT l,i,j;
  78.   
  79.   for (l=1; l<NUM_LAYERS; l++) {  //每层
  80.     for (i=1; i<=Net->Layer[l]->Units; i++) {
  81.       for (j=0; j<=Net->Layer[l-1]->Units; j++) {
  82. Net->Layer[l]->Weight[i][j] = RandomEqualREAL(-0.5, 0.5);//随机值
  83.       }
  84.     }
  85.   }
  86. }
复制代码
回复 支持 反对

使用道具 举报

frogfish
 楼主| 发表于 2007-7-5 15:03 | 显示全部楼层
  1. /***********************
  2. //保存连接权，防止丢失宝贵的联接权  
  3. ************************/
  4. void SaveWeights(NET* Net)
  5. {
  6.   INT l,i,j;    for (l=1; l<NUM_LAYERS; l++) {
  7.     for (i=1; i<=Net->Layer[l]->Units; i++) {
  8.       for (j=0; j<=Net->Layer[l-1]->Units; j++) {
  9. Net->Layer[l]->WeightSave[i][j] = Net->Layer[l]->Weight[i][j];
  10.       }
  11.     }
  12.   }
  13. }
  14. /***********************
  15. //恢复连接权，以便需要的时候可以重新调用，重组网络      
  16. ************************/
  17. void RestoreWeights(NET* Net)
  18. {
  19.   INT l,i,j;    for (l=1; l<NUM_LAYERS; l++) {
  20.     for (i=1; i<=Net->Layer[l]->Units; i++) {
  21.       for (j=0; j<=Net->Layer[l-1]->Units; j++) {
  22. Net->Layer[l]->Weight[i][j] = Net->Layer[l]->WeightSave[i][j];   
  23.       }
  24.     }
  25.   }
  26. }
  27. /***********************
  28. //创建网络，为网络分配空间      
  29. ************************/
  30. void GenerateNetwork(NET* Net)
  31. {
  32.   INT l,i;    Net->Layer = (LAYER**) calloc(NUM_LAYERS, sizeof(LAYER*));
  33.   
  34.   for (l=0; l<NUM_LAYERS; l++) {
  35.     Net->Layer[l] = (LAYER*) malloc(sizeof(LAYER));
  36.       
  37.     Net->Layer[l]->Units      = Units[l];
  38.     Net->Layer[l]->Output    = (REAL*)  calloc(Units[l]+1, sizeof(REAL));
  39.     Net->Layer[l]->Activation = (REAL*)  calloc(Units[l]+1, sizeof(REAL));
  40.     Net->Layer[l]->Error      = (REAL*)  calloc(Units[l]+1, sizeof(REAL));
  41.     Net->Layer[l]->Weight    = (REAL**) calloc(Units[l]+1, sizeof(REAL*));
  42.     Net->Layer[l]->WeightSave = (REAL**) calloc(Units[l]+1, sizeof(REAL*));
  43.     Net->Layer[l]->dWeight    = (REAL**) calloc(Units[l]+1, sizeof(REAL*));
  44.     Net->Layer[l]->Output[0]  = BIAS;
  45.       
  46.     if (l != 0) {
  47.       for (i=1; i<=Units[l]; i++) {
  48. Net->Layer[l]->Weight[i]    = (REAL*) calloc(Units[l-1]+1, sizeof(REAL));
  49. Net->Layer[l]->WeightSave[i] = (REAL*) calloc(Units[l-1]+1, sizeof(REAL));
  50. Net->Layer[l]->dWeight[i]    = (REAL*) calloc(Units[l-1]+1, sizeof(REAL));
  51.       }
  52.     }
  53.   }
  54.   Net->InputLayer  = Net->Layer[0];//为输入层分配指针
  55.   Net->OutputLayer = Net->Layer[NUM_LAYERS-1];//为输出层分配指针
  56.   Net->Alpha      = 0.8;//冲量参数
  57.   Net->Eta = 0.5;//学习率
  58.   Net->Epsilon    =0.005;//控制精度
  59. }
  60. /***********************
  61. 将输入样本转换成为输入模式，并创建一个文件以保存显示结果
  62. ************************/
  63. void InitializeApplication(NET* Net)  
  64. {
  65.   INT  n, i,j;      
  66.   
  67.   for (n=0; n<NUM_DATA; n++) {
  68.       for (i=0; i<Y; i++) {
  69. for (j=0; j<X; j++) {
  70.       if ( Pattern[n][i][j] == ’O’ )
  71.    Input[n][i*X+j]  = HI ;
  72. else Input[n][i*X+j]  =LO ;  
  73.       //NUM_DATA输入模式，输入层X*Y个神经元
  74. }
  75.       }
  76.   }
  77.   f = fopen("result.txt", "w");
  78. }
复制代码
回复 支持 反对

使用道具 举报

frogfish
 楼主| 发表于 2007-7-5 15:04 | 显示全部楼层
  1. /***********************
  2.      训练网络
  3. //将每个样本投入网络运作，Input是转换后的输入模式，Target为导师信号，通过布尔型
  4. //的Training和Ptotocoling值控制是否训练和打印输入/输出模式
  5. ************************/
  6. void SimulateNet(NET* Net, REAL* Input, REAL* Target, BOOL Training,BOOL Protocoling)
  7. {
  8.   REAL Output[M]; //用来记录输出层输出
  9.   SetInput(Net, Input,Protocoling);//设置输入层，获得输入层的输出
  10.   PropagateNet(Net);//计算网络各层的输出
  11.   GetOutput(Net, Output,Protocoling);//获得输出层的输出
  12.   
  13.   ComputeOutputError(Net, Target);//计算输出层误差
  14.   if (Training) {
  15.     BackpropagateNet(Net);//误差反向传播
  16.     AdjustWeights(Net);//调整联接权
  17.   }
  18. }
  19. /***********************
  20.     获得输入层的输出
  21. ************************/
  22. void SetInput(NET* Net, REAL* Input,BOOL Protocoling)
  23. {
  24.   INT i;
  25.   
  26.   for (i=1; i<=Net->InputLayer->Units; i++) {
  27.     Net->InputLayer->Output[i] = Input[i-1];      //输入层输入
  28.   }
  29.   if (Protocoling) {
  30.     WriteInput(Net, Input);//根据Protocoling值输出输入模式
  31.   }
  32. }
  33. /***********************
  34. //计算当前层的网络输出，upper 为当前层，LOWER为前一层   
  35. ************************/
  36. void PropagateLayer(NET* Net, LAYER* Lower, LAYER* Upper)  
  37. {
  38.   INT  i,j;
  39.   REAL Sum;    for (i=1; i<=Upper->Units; i++) {
  40.     Sum = 0;
  41.     for (j=0; j<=Lower->Units; j++) {
  42.       Sum += Upper->Weight[i][j] * Lower->Output[j];  //计算本层的净输入
  43.     }  
  44.   Upper->Activation[i] = Sum;//保留激活值
  45.   //计算本层的输出,激活函数必须是S形函数，这样才可导，这是BP网络的理论前提
  46.   Upper->Output[i]=1/(1+exp(-Sum));
  47.   }
  48. }
  49. /***********************
  50.       //计算整个网络各层的输出
  51. ************************/
  52. void PropagateNet(NET* Net)
  53. {
  54.   INT l;
  55.   
  56.   for (l=0; l<NUM_LAYERS-1; l++) {
  57.     PropagateLayer(Net, Net->Layer[l], Net->Layer[l+1]);
  58.   }
  59. }
  60. /***********************
  61. //获得输出层的输出      
  62. ************************/
  63. void GetOutput(NET* Net, REAL* Output,BOOL Protocoling)
  64. {
  65.   INT i;
  66.   
  67.   for (i=1; i<=Net->OutputLayer->Units; i++) {  
  68.     Output[i-1] = Net->OutputLayer->Output[i];//输出层输出
  69.   }
  70.   if (Protocoling) {
  71.     WriteOutput(Net, Output);//根据Protocoling值输出输出模式
  72.   }
  73. }
复制代码
回复 支持 反对

使用道具 举报

frogfish
 楼主| 发表于 2007-7-5 15:04 | 显示全部楼层
  1. /***********************
  2. //计算输出层误差，* Target是导师信号
  3. ************************/
  4. void ComputeOutputError(NET* Net, REAL* Target)  
  5. {
  6.   INT  i;
  7.   REAL  Err,Out;
  8.   
  9.   Net->Error = 0;
  10.   for (i=1; i<=Net->OutputLayer->Units; i++) {
  11.     Out = Net->OutputLayer->Output[i];//输出层的输出
  12.     Err = Target[i-1]-Out;//误差计算
  13.     Net->OutputLayer->Error[i] = Out * (1-Out) * Err;
  14. //用delta规则计算误差，因为用了可导的s形函数
  15.     Net->Error += 0.5 * sqr(Err);//平方差公式
  16.   }
  17. }
  18. /***********************
  19.   //误差反向传播 Upper 为前层，Lower为后层 ，层数值大的为前层   
  20. ************************/
  21. void BackpropagateLayer(NET* Net, LAYER* Upper, LAYER* Lower)  
  22. {  
  23.   INT  i,j;//循环变量
  24.   REAL Out, Err;
  25.   
  26.   for (i=1; i<=Lower->Units; i++) {
  27.     Out = Lower->Output[i];//后层的输出
  28.     Err = 0;//用来记录隐含层输出的误差的估计值
  29.     for (j=1; j<=Upper->Units; j++) {
  30.       Err += Upper->Weight[j][i] * Upper->Error[j];
  31.     //误差的反馈，通过已经处理的前层的delta值和联接权去估计，有理论基础
  32.     }
  33.     Lower->Error[i] =Out * (1-Out) * Err;  //delta规则
  34.   }
  35. }
  36. /***********************
  37.       //整个网络误差的后传
  38. ************************/
  39. void BackpropagateNet(NET* Net)
  40. {
  41.   INT l;//循环变量
  42.   
  43.   for (l=NUM_LAYERS-1; l>1; l--) {
  44.     BackpropagateLayer(Net, Net->Layer[l], Net->Layer[l-1]);//对每层处理
  45.   }
  46. }
  47. /***********************
  48.       //调整网络每一层的联接权
  49. ************************/
  50. void AdjustWeights(NET* Net)   
  51. {
  52.   INT  l,i,j;//循环变量
  53.   REAL Out, Err, dWeight;
  54.   //记录后层的输出、当前层的输出误差、当前神经元联接权上次的调整量
  55.   
  56.   for (l=1; l<NUM_LAYERS; l++) {
  57.     for (i=1; i<=Net->Layer[l]->Units; i++) {
  58.       for (j=0; j<=Net->Layer[l-1]->Units; j++) {
  59. Out = Net->Layer[l-1]->Output[j];//后层的输出
  60. Err = Net->Layer[l]->Error[i];//当前层的输出误差
  61. dWeight = Net->Layer[l]->dWeight[i][j];
  62. //将本神经元联接权上次的调整量取出，初始值为0，初始化网络时赋值的
  63. Net->Layer[l]->Weight[i][j] += Net->Eta * Err * Out + Net->Alpha * dWeight;
  64. //Alpha为冲量参数，加快网络的收敛速度
  65. Net->Layer[l]->dWeight[i][j] = Net->Eta * Err * Out;
  66. //记录本次神经元联接权的调整量
  67.       }
  68.     }
  69.   }
  70. }
复制代码
回复 支持 反对

使用道具 举报

frogfish
 楼主| 发表于 2007-7-5 15:05 | 显示全部楼层
  1. /***********************
  2. //显示输入模式      
  3. ************************/
  4. void WriteInput(NET* Net, REAL* Input)  
  5. {
  6.   INT i;
  7.   
  8.   for (i=0; i<N; i++) {
  9.     if (i%X == 0) {
  10.       fprintf(f, "\\n");
  11.     }
  12.     fprintf(f, "%c", (Input[i] == HI) ? ’0’ : ’ ’);
  13.   }
  14.   fprintf(f, " -> ");  
  15. }
  16. /***********************
  17. //显示输出模式      
  18. ************************/
  19. void WriteOutput(NET* Net, REAL* Output)
  20. {
  21.   INT  i;//循环变量
  22.   INT  Index;//用来记录最大输出值的下标，也就是最后识别的结果
  23.   REAL  MaxOutput;//用来记录最大的输出值
  24.    
  25.   MaxOutput=0;//初始化
  26.   for (i=0; i<M; i++)
  27.   {   
  28.       if(MaxOutput<Output[i]){
  29. MaxOutput=MAX(MaxOutput,Output[i]);//保存最大值
  30. Index=i;
  31.       }
  32.   }
  33.       
  34.   fprintf(f, "%i\\n", Index);//写进文件
  35.   
  36. }
  37. /***********************
  38.       初始化测试样本
  39. ************************/
  40. void Initializetest()
  41. {
  42.     INT n,i,j;//循环变量
  43.    
  44.     for (n=0; n<NUM_DATA; n++) {
  45. for (i=0; i<Y; i++) {
  46.    for (j=0; j<X; j++)      
  47. if (testPattern[n][i][j]==’O’)
  48.    Inputtest[n][i*X+j] = HI;
  49. else Inputtest[n][i*X+j] =LO;  //NUM_DATA输入模式，输入层X*Y个神经元  
  50. }
  51.     }
  52. }
复制代码
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 我要加入

本版积分规则

QQ|小黑屋|Archiver|手机版|联系我们|声振论坛

GMT+8, 2024-11-17 19:37 , Processed in 0.092616 second(s), 17 queries , Gzip On.

Powered by Discuz! X3.4

Copyright © 2001-2021, Tencent Cloud.

快速回复 返回顶部 返回列表