开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形/文字识别 > 查看源码
Bp.h
资源名称：getchar.rar　[点击查看]
上传用户：kennygump
上传日期：2022-07-22
资源大小：347k
文件大小：19k
源码类别：

图形/文字识别

开发平台：

Visual C++

Bp.h：源码内容
  2. #include <stdio.h>
  3. #include <math.h> 
  4. #include <time.h>
  5. #include <stdlib.h>
  6. #define BIGRND 32767
  8. double drnd();
  9. double dpn1();
  10. double squash(double x);
  11. double *alloc_1d_dbl(int n);
  12. double *alloc_1d_dbl(int n);
  13. double **alloc_2d_dbl(int m, int n);
  14. void bpnn_initialize(int seed);
  15. void bpnn_randomize_weights(double **w, int m, int n);
  16. void bpnn_zero_weights(double **w, int m, int n);
  17. void bpnn_layerforward(double *l1, double *l2, double **conn, int n1, int n2);
  18. void bpnn_output_error(double *delta, double *target, double *output, int nj);
  19. void bpnn_hidden_error(double* delta_h, int nh, double *delta_o, int no, double **who, double *hidden);
  20. void bpnn_adjust_weights(double *delta, int ndelta, double *ly, int nly, double** w, double **oldw, double eta, double momentum);
  21. void w_weight(double **w,int n1,int n2,char*name);
  22. bool r_weight(double **w,int n1,int n2,char *name);
  23. void w_num(int n1,int n2,int n3,char*name);
  24. bool r_num(int *n,char *name);
  26. void code(BYTE*image ,int *p,int w,int h,int dw);
  27. void BpTrain(HDIB hDIB,int n_hidden,double min_ex,double momentum,double eta ,int width,int height);
  28. void CodeRecognize(HDIB hDIB,int width ,int height ,int n_in ,int n_hidden,int n_out);
  31. /*** 返回0－1的双精度随机数 ***/
  32. double drnd()
  33. {
  34. return ((double) rand() / (double) BIGRND);
  35. }
  37. /*** 返回-1.0到1.0之间的双精度随机数 ***/
  38. double dpn1()
  39. {
  40. return ((drnd() * 2.0) - 1.0);
  41. }
  43. double squash(double x)
  44. {
  45. return (1.0 / (1.0 + exp(-x)));
  46. }
  47. /*** 申请1维双精度实数数组 ***/
  49. double *alloc_1d_dbl(int n)
  50. {
  51. double *new1;
  53. new1 = (double *) malloc ((unsigned) (n * sizeof (double)));
  54. if (new1 == NULL) {
  55. printf("ALLOC_1D_DBL: Couldn't allocate array of doublesn");
  56. return (NULL);
  57. }
  58. return (new1);
  59. }
  61. /*** 申请2维双精度实数数组 ***/
  63. double **alloc_2d_dbl(int m, int n)
  64. {
  65. int i;
  66. double **new1;
  68. new1 = (double **) malloc ((unsigned) (m * sizeof (double *)));
  69. if (new1 == NULL) {
  70. // printf("ALLOC_2D_DBL: Couldn't allocate array of dbl ptrsn");
  71. return (NULL);
  72. }
  74. for (i = 0; i < m; i++) {
  75. new1[i] = alloc_1d_dbl(n);
  76. }
  78. return (new1);
  79. }
  81. /*** 设置随机数种子 ***/
  82. void bpnn_initialize(int seed)
  83. {
  84. //printf("Random number generator seed: %dn", seed);
  85. srand(seed);
  86. }
  88. /*** 随机初始化权值 ***/
  89. void bpnn_randomize_weights(double **w, int m, int n)
  90. {
  91. int i, j;
  93. for (i = 0; i <= m; i++) {
  94. for (j = 0; j <= n; j++) {
  96. w[i][j] = dpn1();
  97. }
  98. }
  99. }
  100. /*** 0初始化权值 ***/
  101. void bpnn_zero_weights(double **w, int m, int n)
  102. {
  103. int i, j;
  105. for (i = 0; i <= m; i++) {
  106. for (j = 0; j <= n; j++) {
  107. w[i][j] = 0.0;
  108. }
  109. }
  110. }
  112. /*********前向传输*********/
  113. void bpnn_layerforward(double *l1, double *l2, double **conn, int n1, int n2)
  114. {
  115. double sum;
  116. int j, k;
  118. /*** 设置阈值 ***/
  119. l1[0] = 1.0;
  121. /*** 对于第二层的每个神经元 ***/
  122. for (j = 1; j <= n2; j++) {
  124. /*** 计算输入的加权总和 ***/
  125. sum = 0.0;
  126. for (k = 0; k <= n1; k++) {
  127. sum += conn[k][j] * l1[k];
  128. }
  129. l2[j] = squash(sum);
  130. }
  131. }
  133. /* 输出误差 */
  135. void bpnn_output_error(double *delta, double *target, double *output, int nj)
  136. {
  137. int j;
  138. double o, t, errsum;
  140. errsum = 0.0;
  141. for (j = 1; j <= nj; j++) {
  142. o = output[j];
  143. t = target[j];
  144. delta[j] = o * (1.0 - o) * (t - o);
  146. }
  148. }
  150. /* 隐含层误差 */
  152. void bpnn_hidden_error(double* delta_h, int nh, double *delta_o, int no, double **who, double *hidden)
  153. {
  154. int j, k;
  155. double h, sum, errsum;
  157. errsum = 0.0;
  158. for (j = 1; j <= nh; j++) {
  159. h = hidden[j];
  160. sum = 0.0;
  161. for (k = 1; k <= no; k++) {
  162. sum += delta_o[k] * who[j][k];
  163. }
  164. delta_h[j] = h * (1.0 - h) * sum;
  166. }
  168. }
  170. /* 调整权值 */
  171. void bpnn_adjust_weights(double *delta, int ndelta, double *ly, int nly, double** w, double **oldw, double eta, double momentum)
  172. {
  173. double new_dw;
  174. int k, j;
  176. ly[0] = 1.0;
  177. for (j = 1; j <= ndelta; j++) {
  178. for (k = 0; k <= nly; k++) {
  179. new_dw = ((eta * delta[j] * ly[k]) + (momentum * oldw[k][j]));
  180. w[k][j] += new_dw;
  181. oldw[k][j] = new_dw;
  182. }
  183. }
  184. }
  185. /*******保存权值**********/
  186. void w_weight(double **w,int n1,int n2,char*name)
  187. {
  188. int i,j;
  189. double *buffer;
  190. FILE *fp;
  191. fp=fopen(name,"wb+");
  192. buffer=(double*)malloc((n1+1)*(n2+1)*sizeof(double));
  193. for(i=0;i<=n1;i++)
  194. {
  195. for(j=0;j<=n2;j++)
  196. buffer[i*(n2+1)+j]=w[i][j];
  197. }
  198. fwrite((char*)buffer,sizeof(double),(n1+1)*(n2+1),fp);
  199. fclose(fp);
  200. free(buffer);
  201. }
  205. /************读取权值*************/
  206. bool  r_weight(double **w,int n1,int n2,char *name)
  207. {
  208. int i,j;
  209. double *buffer;
  210. FILE *fp;
  211. if((fp=fopen(name,"rb"))==NULL)
  212. {
  213. ::MessageBox(NULL,"无法读取权值信息",NULL,MB_ICONSTOP);
  214. return (false);
  215. }
  216. buffer=(double*)malloc((n1+1)*(n2+1)*sizeof(double));
  217. fread((char*)buffer,sizeof(double),(n1+1)*(n2+1),fp);
  219. for(i=0;i<=n1;i++)
  220. {
  221. for(j=0;j<=n2;j++)
  222. w[i][j]=buffer[i*(n2+1)+j];
  223. }
  224. fclose(fp);
  225. free(buffer);
  226. return(true);
  227. }
  229. /*****保存各层结点的数目******/
  230. void w_num(int n1,int n2,int n3,char*name)
  231. {
  232. FILE *fp;
  233. fp=fopen(name,"wb+");
  234. int *buffer;
  235. buffer=(int*)malloc(3*sizeof(int));
  236. buffer[0]=n1;
  237. buffer[1]=n2;
  238. buffer[2]=n3;
  239. fwrite((char*)buffer,sizeof(int),3,fp);
  240. fclose(fp);
  241. free(buffer);
  242. }
  244. /********读取各层结点数目*********/
  246. bool r_num(int *n,char *name)
  247. {
  248. int *buffer;
  249. FILE *fp;
  250. buffer=(int *)malloc(3*sizeof(int));
  251. if((fp=fopen(name,"rb"))==NULL)
  252. {
  253. ::MessageBox(NULL,"结点参数",NULL,MB_ICONSTOP);
  254. return (false);
  255. }
  256. fread((char*)buffer,sizeof(int),3,fp);
  257. n[0]=buffer[0];
  258. n[1]=buffer[1];
  259. n[2]=buffer[2];
  260. fclose(fp);
  261. free(buffer);
  262. return(true);
  263. }
  264. /********************************************************
  265. * 函数名称 VerticalCode()
  266. *
  267. * 参量：
  268. *   BYTE* lpDIBBits   －指向输入图像的象素其实位置的指针 
  269. *   int  num          －图片中样本的个数
  270. *   LONG lLineByte    －输入图片每行的字节数
  271. *   LONG lSwidth      －预处理时归一化的宽度
  272. *   LONG lSheight     －预处理时归一化的长度
  273. *
  274. * 返回值：
  275. *   double**           －特征向量矩阵
  276. *
  277. *  函数功能 ：
  278. *      对于输入样本提取特征向量，在这里把归一化样本的
  279. *    水平和竖直方向的统计特征作为特征提取出来
  280. ***************************************************************/
  282. double** VerticalCode(BYTE* lpDIBBits,int num, LONG lLineByte,LONG lSwidth,LONG lSheight)
  283. {   
  284.    //循环变量
  285.     int i,j,k;
  286.     BYTE* lpSrc; 
  287.     
  288. //统计变量
  289. int sum;
  291.     //  建立保存特征向量的二维数组
  292.    double **data;
  293.    
  294.    // 为这个数组申请二维存储空间
  295.    data = alloc_2d_dbl(num,lSwidth+lSheight);
  296.  
  297.    // 将归一化的样本的每个象素作为一个特征点提取出来
  299.    //逐个数据扫描
  300.    for(k=0;k<num;k++)  
  301.    { 
  302.      //统计每行的象素点个数
  303.       for(i=0;i<lSheight;i++)
  304.   {    
  305.         //对统计变量初始化
  306.     sum=0;
  308.           //对每个数据逐列扫描
  309.           for(j=k*lSwidth;j<(k+1)*lSwidth;j++)
  310.   {
  311.             // 指向图像第i行第j列个象素的指针
  312.             lpSrc = lpDIBBits + i*lLineByte + j;
  314.              //如果这个象素是黑色的
  315.              if(*(lpSrc)==0)
  317.              //统计变量加1
  318.                 sum++;
  319.   }
  320.          data[k][i]=sum;
  321.   }
  323.     //统计每列的象素点个数
  324.     for(j=k*lSwidth;j<(k+1)*lSwidth;j++)
  325. {    
  326.         //对统计变量初始化
  327.     sum=0;
  329.           //对每个数据逐行扫描
  330.          for(i=0;i<lSheight;i++)
  331.           {
  332.             // 指向图像第i行第j列个象素的指针
  333.             lpSrc = lpDIBBits + i*lLineByte + j;
  335.              //如果这个象素是黑色的
  336.              if(*(lpSrc)==0)
  338.              //统计变量加1
  339.                 sum++;
  340.   }
  341.          data[k][j-k*lSwidth+lSheight]=sum;
  342.   }
  344.    }
  345.  
  346. //返回特征向量矩阵
  347.    return(data);  
  348. }
  350. /*******************************************************************
  351. *
  352. *函数名称：
  353. * TZTQ_13
  354. *参数：
  355. * HDIB hDIB -待提取特征的位图的句柄
  356. * int num -字符的数目
  357. * int dim -提取特征的维数。这里固定为13
  358. *说明：
  359. * 图像分为8块，作为8个特征；象素总数作为一个特征；水平切割过去两条线，得*到两个特征；垂直的两个，总共得到13个特征
  360. *
  361. *********************************************************************/
  362. double * * TZTQ_13(HDIB hDIB,int num,int dim)
  363. {
  364. int i,j,k,m;
  366. //分配一个内存空间并得到二维指针
  367. double * * tezheng=alloc_2d_dbl(num,dim);
  369. //锁定图像句柄并获取其指针
  370. BYTE* lpDIB=(BYTE*)::GlobalLock ((HGLOBAL)hDIB);
  372. //取得图像象素数据区的起始地址
  373. BYTE* lpDIBBits=(BYTE*)::FindDIBBits((char*)lpDIB);
  374. BYTE* lpSrc;
  376. //获取图像高度
  377. LONG lHeight=::DIBHeight ((char*)lpDIB);
  379. //获取图像宽度
  380. LONG lWidth=::DIBWidth ((char*)lpDIB);
  382. LONG width=lWidth/num;
  383. //每行的字节数
  384. LONG lLineBytes = WIDTHBYTES(lWidth * 8);
  386. int b;
  388. //存储临时的特征
  389. double * tz=new double[dim];
  391. for(k=0;k<num;k++)
  392. {
  393. for(i=0;i<dim;i++) tz[i]=0;
  395. //提取前8个特征
  396. for(m=0;m<8;m++)
  397. { for(i=int(m/2)*8;i<(int(m/2)+1)*8;i++)
  398. for(j=m%2*8+k*width;j<(m%2+1)*8+k*width;j++)
  399. { lpSrc=(unsigned char*)lpDIBBits + lLineBytes *  i + j;
  400. b=(*lpSrc==255)?0:1;
  401.     tz[m]+=b;
  402. }
  403. }
  405. //提取第9个特征-总象素值
  406. for(i=0;i<lHeight;i++)
  407. for(j=k*width;j<(k+1)*width;j++)
  408. { lpSrc=(unsigned char*)lpDIBBits + lLineBytes *  i + j;
  409. b=(*lpSrc==255)?0:1;
  410.     tz[8]+=b;
  411. }
  413. //提取第10、11个特征-水平扫描切割
  414. i=int(lHeight*1/3);
  415. for(j=k*width;j<(k+1)*width;j++)
  416. { lpSrc=(unsigned char*)lpDIBBits + lLineBytes *  i + j;
  417. b=(*lpSrc==255)?0:1;
  418.     tz[9]+=b;
  419. }
  420. //
  421. i=int(lHeight*2/3);
  422. for(j=k*width;j<(k+1)*width;j++)
  423. { lpSrc=(unsigned char*)lpDIBBits + lLineBytes *  i + j;
  424. b=(*lpSrc==255)?0:1;
  425.     tz[10]+=b;
  426. }
  428. //提取第12、13个特征-垂直扫描切割
  429. j=int(k*width+width*1/3);
  430. for(i=0;i<lHeight;i++)
  431. { lpSrc=(unsigned char*)lpDIBBits + lLineBytes *  i + j;
  432. b=(*lpSrc==255)?0:1;
  433.     tz[11]+=b;
  434. }
  436. j=int(k*width+width*2/3);
  437. for(i=0;i<lHeight;i++)
  438. { lpSrc=(unsigned char*)lpDIBBits + lLineBytes *  i + j;
  439. b=(*lpSrc==255)?0:1;
  440.     tz[12]+=b;
  441. }
  443. //存储特征
  444. for(i=0;i<dim;i++)
  445. tezheng[k][i]=tz[i];
  446. }
  448. ::GlobalUnlock ((HGLOBAL)hDIB);
  449. //返回特征向量矩阵的指针
  450. return tezheng;
  451. }
  453. /**********************************
  454. * 函数名称 code()
  455. *
  456. * 参量：
  457. *   BYTE* lpDIBBits   -指向输入图像的象素其实位置的指针 
  458. *   int num           -图片中样本的个数
  459. *   LONG lLineByte    -输入图片每行的字节数
  460. *   LONG lSwidth      -预处理时归一化的宽度
  461. *   LONG lSheight     -预处理时归一化的长度
  462. *
  463. *  函数功能 ：
  464. *      对于输入样本提取特征向量，在这里把归一化样本的
  465. *    每一个象素都作为特征提取出来
  466. **************************************/
  468. double** code (BYTE* lpDIBBits,int num, LONG lLineByte,LONG lSwidth,LONG lSheight)
  469. {   
  470. //循环变量
  471.     int i,j,k;
  472.     BYTE* lpSrc; 
  474.     //  建立保存特征向量的二维数组
  475. double **data;
  477. // 为这个数组申请二维存储空间
  478. data = alloc_2d_dbl(num,lSwidth*lSheight);
  480. // 将归一化的样本的每个象素作为一个特征点提取出来
  482. //逐个数据扫描
  483. for(k=0;k<num;k++)  
  484. { 
  485. //对每个数据逐行扫描
  486. for(i=0;i<lSheight;i++)
  487. {  
  488. //对每个数据逐列扫描
  489. for(j=k*lSwidth;j<(k+1)*lSwidth;j++)
  490. {
  492. // 指向图像第i行第j列个象素的指针
  493. lpSrc = lpDIBBits + i*lLineByte + j;
  495. //如果这个象素是黑色的
  496. if(*(lpSrc)==0)
  497. //将特征向量的相应位置填1
  498. data[k][i*lSwidth+j-k*lSwidth]=1;
  499. //如果这个象素是其他的   
  500. if(*(lpSrc)!=0)
  501. //将特征向量的相应位置填0
  502. data[k][i*lSwidth+j-k*lSwidth]=0;
  505. }
  506. }
  507. }
  509. return(data);  
  510. }
  512. /****************************************************
  513. * 函数名称 BpTrain()
  514. * 
  515. * 参数：
  516. *   double **data_in    -指向输入的特征向量数组的指针    
  517. * double **data_out   -指向理想输出数组的指针
  518. int n_in            -输入层结点的个数 
  519. *   int n_hidden        -BP网络隐层结点的数目
  520. *   double min_ex       -训练时允许的最大均方误差
  521. *   double momentum     -BP网络的相关系数
  522. *   double eta          -BP网络的训练步长
  523. *   int num             -输入样本的个数
  524. *
  525. * 函数功能：
  526. *     根据输入的特征向量和期望的理想输出对BP网络尽行训练
  527. *     训练结束后将权值保存并将训练的结果显示出来
  528. ********************************************************/
  529. void BpTrain(double ** data_in, double** data_out,int n_in,int n_hidden,double min_ex,double momentum,double eta ,int num)
  530. {
  534. //循环变量   
  535. int i,k,l;
  537. //输出层结点数目
  538. int  n_out=4;   
  539. //指向输入层数据的指针
  540. double* input_unites; 
  541. //指向隐层数据的指针
  542. double* hidden_unites;
  543. //指向输出层数据的指针
  544. double* output_unites; 
  545. //指向隐层误差数据的指针
  546. double* hidden_deltas;
  547. //指向输出层误差数剧的指针
  548. double* output_deltas;  
  549. //指向理想目标输出的指针
  550. double* target;    
  551. //指向输入层于隐层之间权值的指针
  552. double** input_weights;
  553. //指向隐层与输出层之间的权值的指针
  554. double** hidden_weights;
  555. //指向上一此输入层于隐层之间权值的指针
  556. double** input_prev_weights ;
  557. //指向上一此隐层与输出层之间的权值的指针
  558. double** hidden_prev_weights;
  559. //每次循环后的均方误差误差值 
  560. double ex;
  562. //为各个数据结构申请内存空间
  563. input_unites= alloc_1d_dbl(n_in + 1);
  564. hidden_unites=alloc_1d_dbl(n_hidden + 1);
  565. output_unites=alloc_1d_dbl(n_out + 1);
  566. hidden_deltas = alloc_1d_dbl(n_hidden + 1);
  567. output_deltas = alloc_1d_dbl(n_out + 1);
  568. target = alloc_1d_dbl(n_out + 1);
  569. input_weights=alloc_2d_dbl(n_in + 1, n_hidden + 1);
  570. input_prev_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
  571. hidden_prev_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);
  572. hidden_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);
  574. //为产生随机序列撒种
  575. time_t t; 
  576. bpnn_initialize((unsigned)time(&t));
  578. //对各种权值进行初始化初始化
  579. bpnn_randomize_weights( input_weights,n_in,n_hidden);
  580. bpnn_randomize_weights( hidden_weights,n_hidden,n_out);
  581. bpnn_zero_weights(input_prev_weights, n_in,n_hidden );
  582. bpnn_zero_weights(hidden_prev_weights,n_hidden,n_out );
  584. //开始进行BP网络训练
  585. //这里设定最大的迭代次数为15000次
  586. for(l=0;l<15000;l++)  
  587. { 
  588. //对均方误差置零
  589. ex=0;
  590. //对样本进行逐个的扫描
  591. for(k=0;k<num;k++)  
  592. { 
  593. //将提取的样本的特征向量输送到输入层上
  594. for(i=1;i<=n_in;i++)
  595. input_unites[i] = data_in[k][i-1];
  597. //将预定的理想输出输送到BP网络的理想输出单元
  598. for(i=1;i<=n_out;i++)
  599. target[i]=data_out[k][i-1];
  601. //前向传输激活
  603. //将数据由输入层传到隐层 
  604. bpnn_layerforward(input_unites,hidden_unites,
  605. input_weights, n_in,n_hidden);
  606. //将隐层的输出传到输出层
  607. bpnn_layerforward(hidden_unites, output_unites,
  608. hidden_weights,n_hidden,n_out);
  610. //误差计算
  612. //将输出层的输出与理想输出比较计算输出层每个结点上的误差
  613. bpnn_output_error(output_deltas,target,output_unites,n_out);
  614. //根据输出层结点上的误差计算隐层每个节点上的误差
  615. bpnn_hidden_error(hidden_deltas,n_hidden, output_deltas, n_out,hidden_weights, hidden_unites);
  617. //权值调整
  618. //根据输出层每个节点上的误差来调整隐层与输出层之间的权值    
  619. bpnn_adjust_weights(output_deltas,n_out, hidden_unites,n_hidden,
  620. hidden_weights, hidden_prev_weights, eta, momentum); 
  621. //根据隐层每个节点上的误差来调整隐层与输入层之间的权值    
  622. bpnn_adjust_weights(hidden_deltas, n_hidden, input_unites, n_in,
  623. input_weights, input_prev_weights, eta, momentum);  
  625. //误差统计
  626. for(i=1;i<=n_out;i++)
  627. ex+=(output_unites[i]-data_out[k][i-1])*(output_unites[i]-data_out[k][i-1]);
  628. }
  629. //计算均方误差
  630. ex=ex/double(num*n_out);
  631. //如果均方误差已经足够的小，跳出循环，训练完毕  
  632. if(ex<min_ex)break;
  633. }
  635. //相关保存
  637. //保存输入层与隐层之间的权值
  638. w_weight(input_weights,n_in,n_hidden,"win.dat");
  639. //保存隐层与输出层之间的权值
  640. w_weight(hidden_weights,n_hidden,n_out,"whi.dat");
  642. //保存各层结点的个数
  643. w_num(n_in,n_hidden,n_out,"num");
  645. //显示训练结果
  647. CString str;
  648. if(ex<=min_ex)
  649. {
  650. str.Format ("迭代%d次，n平均误差%.4f",l,ex);
  652. ::MessageBox(NULL,str,"训练结果",NULL);
  653. }
  655. if(ex>min_ex)
  656. {
  658. str.Format("迭代%d次，平均误差%.4fn我已经尽了最大努力了还是达不到您的要求n请调整参数重新训练吧！",l,ex);
  659. ::MessageBox(NULL,str,"训练结果",NULL);
  660. }
  662. //释放内存空间
  664. free(input_unites);
  665. free(hidden_unites);
  666. free(output_unites);
  667. free(hidden_deltas);
  668. free(output_deltas);
  669. free(target);
  670. free(input_weights);
  671. free(hidden_weights);
  672. free(input_prev_weights);
  673. free(hidden_prev_weights);
  674. }
  676. /*******************************************
  677. * 函数名称
  678. * CodeRecognize()
  679. * 参量
  680. *  double **data_in     -指向待识别样本特征向量的指针
  681. *  int num              -待识别的样本的个数 
  682. *  int n_in             -Bp网络输入层结点的个数              
  683. *  int n_hidden         -Bp网络隐层结点的个数
  684. *  int n_out            -Bp网络输出层结点的个数
  685. * 函数功能：  
  686. *    读入输入样本的特征相量并根据训练所得的权值 
  687. *    进行识别，将识别的结果写入result.txt 
  688. ****************************************/
  690. void CodeRecognize(double **data_in, int num ,int n_in,int n_hidden,int n_out)
  691. {
  692. //循环变量
  693. int i,k;
  694. // 指向识别结果的指针 
  695. int *recognize;
  696. //为存放识别的结果申请存储空间
  697. recognize=(int*)malloc(num*sizeof(int));
  699. //指向输入层数据的指针
  700. double* input_unites; 
  701. //指向隐层数据的指针
  702. double* hidden_unites;
  703. //指向输出层数据的指针
  704. double* output_unites; 
  705. //指向输入层于隐层之间权值的指针
  706. double** input_weights;
  707. //指向隐层与输出层之间的权值的指针
  708. double** hidden_weights;
  709. //为各个数据结构申请内存空间
  710. input_unites= alloc_1d_dbl(n_in + 1);
  711. hidden_unites=alloc_1d_dbl(n_hidden + 1);
  712. output_unites=alloc_1d_dbl(n_out + 1);
  713. input_weights=alloc_2d_dbl(n_in + 1, n_hidden + 1);
  714. hidden_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);
  717. //读取权值
  718. if( r_weight(input_weights,n_in,n_hidden,"win.dat")==false)
  719. return;
  720. if(r_weight(hidden_weights,n_hidden,n_out,"whi.dat")==false)
  721. return;
  724. //逐个样本扫描
  725. for(k=0;k<num;k++)
  726. { 
  727. //将提取的样本的特征向量输送到输入层上
  728. for(i=1;i<=n_in;i++)
  729. input_unites[i]=data_in[k][i-1];
  731. //前向输入激活
  732.         bpnn_layerforward(input_unites,hidden_unites,
  733. input_weights, n_in,n_hidden);
  734.         bpnn_layerforward(hidden_unites, output_unites,
  735. hidden_weights,n_hidden,n_out);
  737. //根据输出结果进行识别
  738. int result=0 ;
  739. //考察每一位的输出
  740. for(i=1;i<=n_out;i++)
  741. {
  742. //如果大于0.5判为1
  743. if(output_unites[i]>0.5)
  745. result+=(int)pow(2,double(4-i));
  746. }
  748. //如果判定的结果小于等于9，认为合理
  749. if(result<=9)
  750. recognize[k]=result;
  751. //如果判定的结果大于9，认为不合理将结果定位为一个特殊值20
  752. if(result>9)
  753. recognize[k]=20;
  754. }
  757. //将识别结果写到文本中
  758. FILE *fp;
  759. fp=fopen("result.txt","w+");
  761. for(i=0;i<num;i++)
  762. {  
  763. if(recognize[i]==20)
  764. fprintf(fp,"无法识别，");
  765. else
  766. fprintf(fp,"%d,",recognize[i]);
  768. }
  769. fclose(fp);
  771. //将识别的结果显示出来
  772. CString str,str1;
  773. for(i=0;i<num;i++)
  774. {
  775. if(recognize[i]!=20)
  776. str.Format("%d ",recognize[i]);
  778. if(recognize[i]==20)
  779. str.Format("无法识别 ");
  781. str1+=str;
  782. }
  784. //通知用户训练完成
  787. ::MessageBox(NULL,str1,"识别结果",NULL);
  789. //释放存储空间
  790. free(input_unites);
  791. free(hidden_unites);
  792. free(output_unites);
  793. free(input_weights);
  794. free(hidden_weights);
  795. }