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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 控制台编程 > 查看源码
HMM.cpp
资源名称：hmmPlatform.rar　[点击查看]
上传用户：goak128
上传日期：2013-07-17
资源大小：155k
文件大小：21k
源码类别：

控制台编程

开发平台：

C/C++

HMM.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include ".hmm.h"
  3. #include <complex>
  5. //////////////////////////////////////////////////////////////////////////
  6. // 构造函数
  7. // 
  8. // 创建人: 陈文凯
  9. // 创建日期: 2005-06-05
  10. // 修改人:
  11. // 修改日期:
  12. CHMM::CHMM()
  13. {
  14. // 设定数据
  15. this->m_pPi = NULL;
  16. this->m_pA = NULL; 
  17. this->m_pB = NULL;
  18. this->m_pCodeBook = NULL;
  19. }
  21. //////////////////////////////////////////////////////////////////////////
  22. // 析构函数
  23. // 
  24. // 创建人: 陈文凯
  25. // 创建日期: 2005-06-05
  26. // 修改人:
  27. // 修改日期:
  28. CHMM::~CHMM(void)
  29. {
  30. this->Dispose();
  31. }
  33. //////////////////////////////////////////////////////////////////////////
  34. // 释放模型占用资源
  35. // 
  36. // 创建人: 陈文凯
  37. // 创建日期: 2005-06-09
  38. // 修改人:
  39. // 修改日期:
  40. void CHMM::Dispose()
  41. {
  42. if (this->m_pA != NULL)
  43. {
  44. delete[] this->m_pA;
  45. this->m_pA = NULL;
  46. }
  48. if (this->m_pB != NULL)
  49. {
  50. delete[] this->m_pB;
  51. this->m_pB = NULL;
  52. }
  54. if (this->m_pPi != NULL)
  55. {
  56. delete[] this->m_pPi;
  57. this->m_pPi = NULL;
  58. }
  60. if (this->m_pCodeBook != NULL)
  61. {
  62. delete[] this->m_pCodeBook;
  64. this->m_pCodeBook = NULL;
  65. }
  66. }
  68. //////////////////////////////////////////////////////////////////////////
  69. // 导出HMM模型信息
  70. // 
  71. // 创建人: 陈文凯
  72. // 创建日期: 2005-06-09
  73. // 修改人:
  74. // 修改日期:
  75. BOOL CHMM::SaveModel(CString strFileName)
  76. {
  77. CFile outFile(strFileName, CFile::modeCreate | CFile::modeWrite);
  78. // 操作是否成功
  79. BOOL bRet = FALSE;
  81. if (outFile.m_hFile != CFile::hFileNull)
  82. {
  83. // 写入数字
  84. outFile.Write((LPCTSTR)this->m_strWord, CHMM_WORD_LEN);
  85. // 写入HMM状态数
  86. outFile.Write(&this->m_nStatusNums, sizeof(unsigned int));
  87. // 写入短时点数
  88. outFile.Write(&this->m_nFrameSize, sizeof(unsigned int));
  89. // 写入训练码本长度
  90. outFile.Write(&this->m_nCodeNums, sizeof(unsigned int));
  92. // 写入Pi序列
  93. outFile.Write(this->m_pPi, sizeof(double) * this->m_nStatusNums);
  94. // 写入A序列
  95. outFile.Write(this->m_pA, 
  96. sizeof(double) * this->m_nStatusNums * this->m_nStatusNums);
  97. // 写入B序列
  98. outFile.Write(this->m_pB, 
  99. sizeof(double) * this->m_nStatusNums * this->m_nCodeNums);
  100. // 写入码本
  101. outFile.Write(this->m_pCodeBook, sizeof(double) * this->m_nCodeNums);
  103. // 关闭导出文件
  104. outFile.Close();
  105. bRet = TRUE;
  106. }
  108. return bRet;
  109. }
  111. //////////////////////////////////////////////////////////////////////////
  112. // 导入HMM模型信息
  113. // 
  114. // 创建人: 陈文凯
  115. // 创建日期: 2005-06-09
  116. // 修改人:
  117. // 修改日期:
  118. BOOL CHMM::LoadModel(CString strFileName)
  119. {
  120. CFile inFile(strFileName, CFile::modeRead | CFile::shareDenyNone);
  121. // 操作是否成功
  122. BOOL bRet = FALSE;
  123. // 保存读入数字
  124. char strWord[CHMM_WORD_LEN];
  126. if (inFile.m_hFile != CFile::hFileNull)
  127. {
  128. // 释放模型占用资源
  129. this->Dispose();
  131. // 读入数字
  132. inFile.Read(&strWord, CHMM_WORD_LEN);
  133. this->m_strWord.Empty();
  134. this->m_strWord.Append(strWord, CHMM_WORD_LEN);
  136. // 读入HMM状态数
  137. inFile.Read(&this->m_nStatusNums, sizeof(unsigned int));
  138. // 读入短时点数
  139. inFile.Read(&this->m_nFrameSize, sizeof(unsigned int));
  140. // 读入训练码本长度
  141. inFile.Read(&this->m_nCodeNums, sizeof(unsigned int));
  143. // 分配参数空间
  144. this->m_pPi = new double[this->m_nStatusNums];
  145. this->m_pA = new double[this->m_nStatusNums * this->m_nStatusNums];
  146. this->m_pB = new double[this->m_nStatusNums * this->m_nCodeNums];
  147. this->m_pCodeBook = new double[this->m_nCodeNums];
  149. // 读入Pi序列
  150. inFile.Read(this->m_pPi, sizeof(double) * this->m_nStatusNums);
  151. // 读入A序列
  152. inFile.Read(this->m_pA, 
  153. sizeof(double) * this->m_nStatusNums * this->m_nStatusNums);
  154. // 读入B序列
  155. inFile.Read(this->m_pB, 
  156. sizeof(double) * this->m_nStatusNums * this->m_nCodeNums);
  157. // 读入码本
  158. inFile.Read(this->m_pCodeBook, sizeof(double) * this->m_nCodeNums);
  160. // 关闭导入文件
  161. inFile.Close();
  162. bRet = TRUE;
  163. }
  165. return bRet;
  166. }
  168. //////////////////////////////////////////////////////////////////////////
  169. // 实现对HMM模型的迭代训练
  170. // 
  171. // 创建人: 陈文凯
  172. // 创建日期: 2005-06-09
  173. // 修改人:
  174. // 修改日期:
  175. void CHMM::Train(
  176.  const double* pDataIn, // 输入采样序列
  177.  unsigned int nInLen // 输入采样序列长度
  178.  )
  179. {
  180. // 前后向算法返回参数
  181. double fRate = 0;
  182. double* pa = NULL;
  183. double* pb = NULL;
  185. // 对输入采样序列进行矢量量化形成的码本
  186. double* pCodeBook = NULL;
  187. // 输入码本对应的HMM模型下标
  188. unsigned int* pCodeIndex = NULL;
  190. // 判断输入数据是否合法
  191. if (pDataIn != NULL && this->m_pA != NULL && 
  192. this->m_pB != NULL && this->m_pPi != NULL)
  193. {
  194. pa = new double[this->m_nCodeNums * this->m_nStatusNums];
  195. pb = new double[this->m_nCodeNums * this->m_nStatusNums];
  197. // 对输入采样序列进行矢量量化
  198. pCodeBook = new double[this->m_nCodeNums];
  199. CVQ::KMeansCluster(
  200. pDataIn, nInLen, pCodeBook, this->m_nCodeNums);
  202. // 获得输入码本对应的HMM模型码本下标
  203. pCodeIndex = new unsigned int[this->m_nCodeNums];
  204. CVQ::Classify(
  205. pCodeBook, this->m_nCodeNums, this->m_pCodeBook, this->m_nCodeNums, pCodeIndex);
  207. // 调用前后向算法， 计算概率, pa, pb
  208. fRate = this->ForwardBackward(
  209. pCodeIndex, this->m_nCodeNums, this->m_pPi, this->m_pA, 
  210. this->m_pB, this->m_nStatusNums, pa, pb);
  212. // 调用BW算法进行参数优化
  213. this->BaumWelch(
  214. pCodeIndex, this->m_nCodeNums, this->m_pPi, this->m_pA,
  215. this->m_pB, this->m_nStatusNums, pa, pb, fRate);
  217. // 更新码本
  218. for (unsigned int i = 0; i < this->m_nCodeNums; i++)
  219. {
  220. // this->m_pCodeBook[i] = (this->m_pCodeBook[i] + pCodeBook[i]) / 2;
  221. this->m_pCodeBook[i] = this->m_pCodeBook[i] * 0.7 + pCodeBook[i] * 0.3;
  222. }
  224. delete[] pa;
  225. delete[] pb;
  226. delete[] pCodeBook;
  227. delete[] pCodeIndex;
  228. }
  229. }
  231. //////////////////////////////////////////////////////////////////////////
  232. // 实现对HMM模型得初始化训练
  233. // 
  234. // 创建人: 陈文凯
  235. // 创建日期: 2005-06-09
  236. // 修改人:
  237. // 修改日期:
  238. void CHMM::PrepareTrain( 
  239. CString strWord, 
  240. const double* pDataIn, // 第一个输入采样序列
  241. unsigned int nInLen, // 输入采样序列长度
  242. unsigned int nFrameSize,// 分帧宽度
  243. unsigned int nStatusNums /* = 6 */,  
  244. unsigned int nCodeNums  /* = 4   */
  245. )
  246. {
  247. // 计算概率
  248. double fRate = 0;
  249. // 循环变量
  250. unsigned int i = 0;
  251. unsigned int j = 0;
  253. // 设置模型信息
  254. this->m_strWord = strWord;
  255. this->m_nStatusNums = nStatusNums;
  256. this->m_nCodeNums = nCodeNums;
  257. this->m_nFrameSize = nFrameSize;
  259. // 初始化pI/pA/pB/pCodeBook
  260. this->m_pPi = new double[this->m_nStatusNums];
  261. this->m_pA = new double[this->m_nStatusNums * this->m_nStatusNums];
  262. this->m_pB = new double[this->m_nStatusNums * this->m_nCodeNums];
  263. this->m_pCodeBook = new double[this->m_nCodeNums];
  265. memset(this->m_pPi, 0, sizeof(double) * this->m_nStatusNums);
  266. memset(this->m_pA, 0, sizeof(double) * this->m_nStatusNums * this->m_nStatusNums);
  267. memset(this->m_pB, 0, sizeof(double) * this->m_nStatusNums * this->m_nCodeNums);
  268. memset(this->m_pCodeBook, 0, sizeof(double) * this->m_nCodeNums);
  270. // 对pI进行均分
  271. fRate = (double) 1 / nStatusNums;
  272. for (i = 0; i < nStatusNums; i++)
  273. {
  274. this->m_pPi[i] = fRate;
  275. }
  277. // 对PA[i][j]进行均分
  278. for (i = 0; i < nStatusNums; i++)
  279. {
  280. for (j = 0; j < nStatusNums; j++)
  281. {
  282. this->m_pA[i * nStatusNums + j] = fRate;
  283. }
  284. }
  286. // 对pB[i][j]进行均分
  287. fRate = (double) 1 / nCodeNums;
  288. for (i = 0; i < nStatusNums; i++)
  289. {
  290. for (j = 0; j < nCodeNums; j++)
  291. {
  292. this->m_pB[i * nCodeNums + j] = fRate;
  293. }
  294. }
  296. // 形成初始码本
  297. CVQ::KMeansCluster(pDataIn, nInLen, this->m_pCodeBook, this->m_nCodeNums);
  299. // 进行参数优化
  300. this->Train(pDataIn, nInLen);
  301. }
  303. //////////////////////////////////////////////////////////////////////////
  304. // 实现前后向算法,对于给定的HMM参数和观察序列O，
  305. // 求能够产生观察序列O的概率
  306. // 
  307. // 创建人: 陈文凯
  308. // 创建日期: 2005-06-08
  309. // 修改人:
  310. // 修改日期:
  311. double CHMM::ForwardBackward(
  312.  const unsigned int* pCodeBook, // 输入观察码本序列对应的HMM码本的下标
  313.  unsigned int nCodeNums, // 输入观察序列长度
  314.  const double* pPi, // HMM的pi矢量
  315.  const double* pA, // HMM的A矩阵
  316.  const double* pB, // HMM的B矩阵
  317.  unsigned int nStatusNums, // HMM状态数
  318.  double* pa, // 前后向算法中的a
  319.  double* pb // 前后向算法中的b
  320.  )
  321. {
  322. // 能够产生观察序列O的概率
  323. double fRate = 0;
  324. // 递推时做累积
  325. double fSum = 0;
  327. // 循环变量，damn vc
  328. // 输入序列循环
  329. int t = 0;
  330. // 状态循环
  331. int i = 0;
  332. int j = 0;
  334. // 初始化pa, pb
  335. memset(pa, 0, sizeof(double) * (nCodeNums * nStatusNums));
  336. memset(pb, 0, sizeof(double) * (nCodeNums * nStatusNums));
  338. // 实现前后向算法
  339. // 初始化
  340. for (i = 0; i < nStatusNums; i++)
  341. {
  342. // 计算公式：pa[1][i] = pI[i] * pB[i][o1] 1 <= i <= N
  343. pa[0 * nStatusNums + i] = pPi[i] * pB[i * nCodeNums + pCodeBook[0]];
  345. // 计算公式：pb[nCodeNums - 1][i] = 1
  346. pb[(nCodeNums - 1) * nStatusNums + i] = 1;
  347. }
  349. // 前向递推
  350. for (t = 1; t < nCodeNums; t++)
  351. {
  352. for (j = 0; j < nStatusNums; j++)
  353. {
  354. fSum = 0;
  356. for (i = 0; i < nStatusNums; i++)
  357. {
  358. // 累积 fSum += pa[t-1][i] * pA[i][j]
  359. fSum += pa[(t - 1) * nStatusNums + i] * pA[i * nStatusNums + j];
  360. }
  362. // 计算公式：pa[t][j] = fSum * pB[j][ot]
  363. pa[t * nStatusNums + j] = fSum * pB[j * nCodeNums + pCodeBook[t]];
  364. TRACE("pa(%d, %d) : %fn", t, j, pa[t * nStatusNums + j]);
  365. }
  366. }
  368. // 后向递推
  369. for (t = nCodeNums - 2; t >= 0; t--)
  370. {
  371. for (i = 0; i < nStatusNums; i++)
  372. {
  373. fSum = 0;
  375. for (j = 0; j < nStatusNums; j++)
  376. {
  377. // 累积 fSum += pA[i][j] * pB[j][t + 1] * pb[t + 1][j]
  378. fSum += pA[i * nStatusNums + j] * 
  379. pB[j * nCodeNums + pCodeBook[t + 1]] * 
  380. pb[(t + 1) * nStatusNums + j];
  381. }
  383. pb[t * nStatusNums + i] = fSum;
  384. TRACE("pb(%d, %d): %lfn", t, i, pb[t * nStatusNums + i]);
  385. }
  386. }
  388. // 结束
  389. // 计算概率，令t=nCodeNums-1
  390. t = nCodeNums - 1;
  391. for (i = 0; i < nStatusNums; i++)
  392. {
  393. // 计算公式：fRate += pa[t][i] * pb[t][i];
  394. fRate += pa[t * nStatusNums + i] * pb[t * nStatusNums + i];
  395. }
  397. return fRate;
  398. }
  400. //////////////////////////////////////////////////////////////////////////
  401. // 实现Viterbi算法,对于给定的HMM参数和观察序列O，
  402. // 返回最大概率
  403. // 
  404. // 创建人: 陈文凯
  405. // 创建日期: 2005-06-08
  406. // 修改人:
  407. // 修改日期:
  408. double CHMM::Viterbi(
  409.  const unsigned int* pCodeBook, // 输入观察码本序列对应的HMM码本的下标
  410.  unsigned int nCodeNums, // 输入观察序列长度
  411.  const double* pPi, // HMM的pi矢量
  412.  const double* pA, // HMM的A矩阵
  413.  const double* pB, // HMM的B矩阵
  414.  unsigned int nStatusNums // HMM状态数
  415.  )
  416. {
  417. // pa[t][i]为t时刻沿着一条路径q1, q2, ..., qt，且qt = st
  418. // 产生出输入观察序列o1, o2, o3, ..., ot的最大概率
  419. // 1 <= t <= nInLen, 1 <= i <= nStatusNums
  420. double* pa = NULL;
  422. // 临时计算
  423. double fTemp = 0;
  424. double fMax = 0;
  426. // 最大概率
  427. double fMaxRate = 0;
  429. // 循环变量
  430. // 采样序列循环
  431. unsigned int t = 0;
  432. // 状态循环
  433. unsigned int j = 0;
  434. unsigned int i = 0;
  436. // 分配和初始化pa
  437. pa = new double[nCodeNums * nStatusNums];
  438. memset(pa, 0, sizeof(double) * (nCodeNums * nStatusNums));
  440. // 初始化
  441. for (i = 0; i < nStatusNums; i++)
  442. {
  443. // 计算公式：pa[1][i] = pi[i] * pB[i][1]
  444. pa[0 * nStatusNums + i] = pPi[i] * pB[i * nCodeNums + pCodeBook[0]];
  445. }
  447. // 递推
  448. for (t = 1; t < nCodeNums; t++)
  449. {
  450. for (j = 0; j < nStatusNums; j++)
  451. {
  452. // 求pa[t - 1][i] * pA[i][j]的最大值, 1 <= i <= N
  453. fMax = pa[(t - 1) * nStatusNums + 0] * pA[0 * nStatusNums + j];
  455. for (i = 0; i < nStatusNums; i++)
  456. {
  457. fTemp = pa[(t - 1) * nStatusNums + i] * pA[i * nStatusNums + j];
  458. fMax = (fMax < fTemp ? fTemp : fMax);
  459. }
  461. // 计算pa[t][j]和pb[t][j]
  462. // 计算公式：pa[t][j] = fMax * pB[j][t];
  463. pa[t * nStatusNums + j] = fMax * pB[j * nCodeNums + pCodeBook[t]];
  464. }
  465. }
  467. // 终结
  468. // 求最大概率, fMaxRate = max(pa[nCodeNums - 1][i]) 1 <= i <= nStatusNums
  469. fMaxRate = pa[(nCodeNums - 1) * nStatusNums + 0];
  470. for (i = 0; i < nStatusNums; i++)
  471. {
  472. fTemp = pa[(nCodeNums - 1) * nStatusNums + i];
  473. fMaxRate = (fMaxRate < fTemp ? fTemp : fMaxRate);
  474. }
  476. delete[] pa;
  478. return fMaxRate;
  479. }
  481. //////////////////////////////////////////////////////////////////////////
  482. // 实现Baum Welch算法,对于给定的观察序列O，
  483. // 求使P(O | HMM参数)最大的HMM参数pi, A, B
  484. // 
  485. // 创建人: 陈文凯
  486. // 创建日期: 2005-06-08
  487. // 修改人:
  488. // 修改日期:
  489. void CHMM::BaumWelch(
  490.  const unsigned int* pCodeBook, // 输入观察码本序列对应的HMM码本的下标
  491.  unsigned int nCodeNums, // 输入观察序列长度
  492.  double* pPi, // HMM的pi矢量
  493.  double* pA, // HMM的A矩阵
  494.  double* pB, // HMM的B矩阵
  495.  unsigned int nStatusNums, // HMM状态数
  496.  double* pa, // 前后向算法计算所得的pa
  497.  double* pb, // 前后向算法计算所得pb
  498.  double fRate // 前后向算法计算所得最大概率
  499.  )
  500. {
  501. // bw算法中概率矩阵
  502. // pRate[nCodeNums][nStatusNums][nStatusNums]
  503. double* pRate = NULL;
  504. // 最小概率
  505. double fMinRate = 0.0001;
  506. unsigned int nOffSet = nStatusNums * nStatusNums;
  508. // 循环变量
  509. unsigned int t = 0;
  510. unsigned int i = 0;
  511. unsigned int j = 0;
  512. unsigned int k = 0;
  514. // 求概率时的分子
  515. double fAvgUp = 0;
  516. // 求概率时的分母
  517. double fAvgDown = 0;
  518. // 数组元素下标
  519. unsigned int nIndex = 0;
  521. // 初始化概率矩阵
  522. pRate = new double[nCodeNums * nOffSet];
  523. memset(pRate, 0, sizeof(double) * nCodeNums * nOffSet);
  525. // 计算pRate[t][i][j]，即t时刻Markov链处于i状态, t+1时刻处于j状态的概率
  526. for (t = 0; t < (nCodeNums - 1); t++)
  527. {
  528. for (i = 0; i < nStatusNums; i++)
  529. {
  530. for (j = 0; j < nStatusNums; j++)
  531. {
  532. pRate[t * nOffSet + i * nStatusNums + j] = 
  533. (pa[t * nStatusNums + i] * pA[i * nStatusNums + j] * 
  534. pB[j* nCodeNums + pCodeBook[t + 1]] * pb[(t + 1) * nStatusNums + j]) / fRate;
  536. TRACE("pRate[%d, %d, %d]: %fn", 
  537. t, i, j, pRate[t * nOffSet + i * nStatusNums + j]);
  539. TRACE("pa: %f, pb: %f, pA: %f, pB: %fn", 
  540. pa[t * nStatusNums + i],
  541. pA[i * nStatusNums + j],
  542. pB[j* nCodeNums + pCodeBook[t + 1]],
  543. pb[(t + 1) * nStatusNums + j]
  544. );
  545. }
  546. }
  547. }
  549. // 使用重估公式计算HMM参数
  550. // 计算Pi矢量, 即0时刻时Markov链处于i状态, t+1时刻处于其他任何状态的概率
  551. for (i = 0; i < nStatusNums; i++)
  552. {
  553. pPi[i] = 0;
  555. for (j = 0; j < nStatusNums; j++)
  556. {
  557. pPi[i] += pRate[0 * nOffSet + i * nStatusNums + j];
  558. }
  560. pPi[i] = (pPi[i] > 0.0 ? pPi[i] : fMinRate);
  561. TRACE("pi[%d]: %fn", i, pPi[i]);
  562. }
  564. // 计算A矩阵 
  565. // pA[i][j] = (从状态Si过渡到Sj的平均次数) / (从状态Si向其他状态转移的平均次数）
  566. for (i = 0; i < nStatusNums; i++)
  567. {
  568. for (j = 0; j < nStatusNums; j++)
  569. {
  570. // 计算状态Si过渡到Sj的平均次数
  571. fAvgUp = 0;
  572. // 从状态Si向其他状态转移的平均次数
  573. fAvgDown = 0;
  575. for (t = 0; t < nCodeNums; t++)
  576. {
  577. fAvgUp += pRate[t * nOffSet + i * nStatusNums + j];
  579. for (k = 0; k < nStatusNums; k++)
  580. {
  581. fAvgDown += pRate[t * nOffSet + i * nStatusNums + k];
  582. }
  583. }
  585. nIndex = i * nStatusNums + j;
  586. pA[nIndex] = fAvgUp / fAvgDown;
  587. pA[nIndex] = (pA[nIndex] > 0.0 ? pA[nIndex] : fMinRate);
  588. TRACE("pA[%d,%d]: %fn", i, j, pA[nIndex]);
  589. }
  590. }
  592. // 计算B矩阵
  593. // pB[i][k] = (出现状态i和观察值Ot=Vk的平均次数) / (处于状态i的次数)
  594. for (i = 0; i < nStatusNums; i++)
  595. {
  596. for (k = 0; k < nCodeNums; k++)
  597. {
  598. // 计算出现状态i和观察值Ot=Vk的平均次数
  599. fAvgUp = 0;
  601. for (t = 0; t < nCodeNums; t++)
  602. {
  603. if (pCodeBook[t] == pCodeBook[k])
  604. {
  605. for (j = 0; j < nStatusNums;j ++)
  606. {
  607. fAvgUp += pRate[t * nOffSet + i * nStatusNums + j];
  608. }
  609. }
  610. }
  612. // 处于状态i的次数
  613. fAvgDown = 0;
  614. for (t = 0; t < nCodeNums; t++)
  615. {
  616. for (j = 0; j < nStatusNums; j++)
  617. {
  618. fAvgDown += pRate[t * nOffSet + i * nStatusNums + j];
  619. }
  620. }
  622. // 计算pB[i][k]
  623. nIndex = i * nCodeNums + pCodeBook[k];
  624. pB[nIndex] = fAvgUp / fAvgDown;
  625. pB[nIndex] = (pB[nIndex] > 0.0 ? pB[nIndex] : fMinRate);
  626. TRACE("pB[%d, %d]: %fn", i, j, pB[nIndex]);
  627. }
  628. }
  630. // 释放资源
  631. if (pRate != NULL)
  632. {
  633. delete[] pRate;
  634. }
  635. }
  637. //////////////////////////////////////////////////////////////////////////
  638. // 基于Vertibi算法实现对HMM模型的识别
  639. CString CHMM::RecogonizeByViterbi(
  640.   const double* pCodeBook, // 输入码本
  641.   unsigned int nCodeNums, // 输入码本长度
  642.   CString* strModelList, // 模型文件路径
  643.   unsigned int nModelCount // 模型数量
  644.   )
  645. {
  646. CString strWord;
  647. // 最大概率
  648. double fMaxRate = 0;
  649. // 识别概率
  650. double fRate = 0;
  651. // 模型
  652. CHMM hmmModel;
  653. // 输入码本对应的HMM码本下标
  654. unsigned int* pCodeIndex = NULL;
  656. if (pCodeBook != NULL && strModelList != NULL)
  657. {
  658. // 初始化输入码本对应的HMM码本下标
  659. pCodeIndex = new unsigned int[nCodeNums];
  661. for (unsigned int i = 0; i < nModelCount; i++)
  662. {
  663. if (hmmModel.LoadModel(strModelList[i]))
  664. {
  665. // 获取输入码本对应的HMM码本下标
  666. CVQ::Classify(
  667. pCodeBook, nCodeNums, hmmModel.m_pCodeBook, hmmModel.m_nCodeNums, pCodeIndex);
  669. fRate = hmmModel.Viterbi(
  670. pCodeIndex, nCodeNums, hmmModel.m_pPi,
  671. hmmModel.m_pA, hmmModel.m_pB, hmmModel.m_nStatusNums);
  673. // 保存最大概率
  674. if (fMaxRate < fRate)
  675. {
  676. fMaxRate = fRate;
  678. // 保存最大概率模型对应单词
  679. strWord = hmmModel.GetWord();
  680. }
  681. }
  682. }
  684. delete[] pCodeIndex;
  685. }
  687. return strWord;
  688. }
  690. //////////////////////////////////////////////////////////////////////////
  691. // 基于DTW的Vertibi实现对HMM模型的识别
  692. CString CHMM::RecogonizeByDTW(
  693.   const double* pCodeBook, // 输入码本
  694.   unsigned int nCodeNums, // 输入码本长度
  695.   CString* strModelList, // 模型文件路径
  696.   unsigned int nModelCount // 模型数量
  697.    )
  698. {
  699. CString strWord;
  700. // 最大概率
  701. double fMaxRate = 0;
  702. // 识别概率
  703. double fRate = 0;
  704. // 模型
  705. CHMM hmmModel;
  706. // 输入码本对应的HMM码本下标
  707. unsigned int* pCodeIndex = NULL;
  709. if (pCodeBook != NULL && strModelList != NULL)
  710. {
  711. // 初始化输入码本对应的HMM码本下标
  712. pCodeIndex = new unsigned int[nCodeNums];
  714. for (unsigned int i = 0; i < nModelCount; i++)
  715. {
  716. if (hmmModel.LoadModel(strModelList[i]))
  717. {
  718. // 获取输入码本对应的HMM码本下标
  719. CVQ::Classify(
  720. pCodeBook, nCodeNums, hmmModel.m_pCodeBook, hmmModel.m_nCodeNums, pCodeIndex);
  722. fRate = hmmModel.DTW(
  723. pCodeIndex, nCodeNums,
  724. hmmModel.m_pA, hmmModel.m_pB, hmmModel.m_nStatusNums);
  726. // 保存最大概率
  727. if (fMaxRate < fRate)
  728. {
  729. fMaxRate = fRate;
  731. // 保存最大概率模型对应单词
  732. strWord = hmmModel.GetWord();
  733. }
  734. }
  735. }
  737. delete[] pCodeIndex;
  738. }
  740. return strWord;
  741. }
  743. //////////////////////////////////////////////////////////////////////////
  744. // 实现基于VQ的HMM模型识别
  745. CString CHMM::RecogonizeByVQ(
  746.  const double* pCodeBook, // 输入码本
  747.  unsigned int nCodeNums, // 输入码本长度
  748.  CString* strModelList, // 模型文件路径
  749.  unsigned int nModelCount // 模型数量
  750.  )
  751. {
  752. CString strWord;
  753. // 最小距离
  754. double fMinDis = 30000;
  755. // 码本距离
  756. double fDis = 0;
  757. // 最小距离模型下标
  758. unsigned int nMinModel = 0;
  759. // 模型
  760. CHMM hmmModel;
  762. if (pCodeBook != NULL && strModelList != NULL)
  763. {
  764. for (unsigned int i = 0; i < nModelCount; i++)
  765. {
  766. if (hmmModel.LoadModel(strModelList[i]))
  767. {
  768. fDis = CVQ::GetDistance(pCodeBook, hmmModel.m_pCodeBook, nCodeNums);
  770. // 保存最小距离
  771. if (fDis < fMinDis)
  772. {
  773. fMinDis = fDis;
  775. // 保存最小距离模型对应单词
  776. strWord = hmmModel.GetWord();
  777. TRACE("%d, %fn", i, fMinDis);
  778. }
  779. }
  780. }
  781. }
  783. return strWord;
  784. }
  786. //////////////////////////////////////////////////////////////////////////
  787. // 实现基于DTW的Viterbi算法
  788. double CHMM::DTW(
  789.  const unsigned int* pCodeBook, // 输入观察码本序列对应的HMM码本的下标
  790.  unsigned int nCodeNums, // 输入观察序列长度
  791.  double* pA, // HMM的A矩阵
  792.  double* pB, // HMM的B矩阵
  793.  unsigned int nStatusNums // HMM状态数
  794.  )
  795. {
  796. double* pRate = NULL;
  797. // 返回的D(nStatusNums, nInLen)
  798. double fRetRate = 0;
  799. // 计算最大D + A
  800. double fMaxD = 0;
  801. double fTemp1 = 0;
  802. double fTemp2 = 0;
  804. if (pCodeBook != NULL)
  805. {
  806. // 初始话概率矩阵
  807. pRate = new double[nCodeNums * nStatusNums];
  808. memset(pRate, 0, sizeof(double) * nCodeNums * nStatusNums);
  810. for (unsigned int i = 0; i < nStatusNums; i++)
  811. {
  812. for (unsigned int j = 1; j < nCodeNums; j++)
  813. {
  814. // 计算D(i-1, j) + A(j, j)
  815. fTemp1 = ((i - 1) >= 0 ? pRate[(i - 1) * nStatusNums + j] : 0);
  816. fTemp1 += pA[j * nStatusNums + j];
  818. // 计算D(i-1, j-1) + A(j-1, j);
  819. fTemp2 = ((i - 1) >= 0 && (j - 1) >= 0 ? 
  820. pRate[(i - 1) * nStatusNums + (j - 1)] : 0);
  821. fTemp2 += ((j - 1) >= 0 ? pA[(j - 1) * nStatusNums + j] : 0);
  823. // 取D(i, j) = B(i, j) + max(fTemp1, fTemp2);
  824. fMaxD = (fTemp1 > fTemp2 ? fTemp1 : fTemp2);
  825. pRate[i * nCodeNums + j] = pB[i * nCodeNums + pCodeBook[j]] + fMaxD;
  826. }
  827. }
  829. fRetRate = pRate[(nCodeNums - 1) * nStatusNums + (nStatusNums - 1)];
  831. // 释放所占用资源
  832. delete[] pRate;
  833. }
  835. return fRetRate;
  836. }