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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
DHMM_HQ.cpp
资源名称：VQ-DHMM.rar　[点击查看]
上传用户：avbj512
上传日期：2013-09-18
资源大小：6239k
文件大小：19k
源码类别：

DSP编程

开发平台：

Visual C++

DHMM_HQ.cpp：源码内容
  1. // DHMM_HQ.cpp:
  2. // Implementation of the DHMM_HQ Module.
  3. // That is the C rewritten
  4. // of previous Matlab DHMM program by HeQiang.
  5. //
  6. // Created 2001/08, By DongMing, MDSR.
  7. //
  8. //////////////////////////////////////////////////////////////////////
  10. #include "stdafx.h"
  11. #include "DHMM_HQ.h"
  12. #include "kwspot.h"
  13. #include <math.h>
  15. #include "DHMM_GL.h"
  16. extern PRO_CONFIG u_Pro_Config;
  18. #define VQ_TRAIN_CODE_BOOK_LOOP_TIME 40 // 设置VQ中K-mean的最大迭代次数
  19. // The best loop: 100, better than 80
  20. #define MODEL_TRAIN_CODE_BOOK_LOOP_TIME 32 // 设置模型训练时的最大迭代次数
  21. // 20, 40 are better
  23. //////////////////////////////////////////////////////////////////////
  24. // Private Function Head
  25. int DHMM_Model_Calculate_Gamma(WORD_SAMPLE * pu_Word_Sample, DHMM_MODEL * pu_DHMM_Model);
  27. //////////////////////////////////////////////////////////////////////
  28. // API functions
  29. int DHMM_VQ_Train_Code_Book_HQ(DYNA_2DIM_DOUBLE_ARRAY d2dda_Code_Word, int n_Code_Word_Num, int n_Code_Word_Dim,
  30.    DYNA_2DIM_DOUBLE_ARRAY d2dda_Initial_Code_Book, DYNA_2DIM_DOUBLE_ARRAY d2dda_Code_Book, int n_Code_Book_Size)
  31. {
  32. int * pn_Initial_Code_Book_Index;
  33. int * pn_Code_Word_Min_Index; // 存储每个特征的最近类中心
  34. double * pd_Code_Word_Min_Distance; // 存储每个特征到最近类中心的距离
  35. int n_Loop_Index, n_Feature_Index, n_Code_Word_Index, n_Dim_Index;
  36. double dTmp;
  37. double d_Old_Distance, d_Distance; // 上次与此次的类内平均距离
  38. int nTmp;
  39. BOOL boolTmp;
  41. PRO_LOG("tVQ = HQ, loop = %4d.n", VQ_TRAIN_CODE_BOOK_LOOP_TIME);
  43. // 若设置初始码本，拷贝之
  44. if (d2dda_Initial_Code_Book != NULL)
  45. {
  46. for (n_Code_Word_Index = 0; n_Code_Word_Index < n_Code_Book_Size; n_Code_Word_Index++)
  47. {
  48. memcpy(d2dda_Code_Book[n_Code_Word_Index], d2dda_Initial_Code_Book[n_Code_Word_Index], sizeof(double) * n_Code_Word_Dim);
  49. }
  50. }
  51. // 若没有设置初始码本，则随机生成
  52. else
  53. {
  54. pn_Initial_Code_Book_Index = new int[n_Code_Book_Size];
  55. ASSERT(pn_Initial_Code_Book_Index);
  57. for (n_Code_Word_Index = 0; n_Code_Word_Index < n_Code_Book_Size; n_Code_Word_Index++)
  58. {
  59. do {
  60. pn_Initial_Code_Book_Index[n_Code_Word_Index] = int((double(rand()) / (double(RAND_MAX) + 1)) * n_Code_Word_Num);
  61. boolTmp = FALSE;
  62. for (nTmp = 0; nTmp < n_Code_Word_Index; nTmp++)
  63. {
  64. if (pn_Initial_Code_Book_Index[n_Code_Word_Index] == pn_Initial_Code_Book_Index[nTmp]) boolTmp = TRUE;
  65. }
  66. } while (boolTmp);
  67. }
  69. for (n_Code_Word_Index = 0; n_Code_Word_Index < n_Code_Book_Size; n_Code_Word_Index++)
  70. {
  71. memcpy(d2dda_Code_Book[n_Code_Word_Index], d2dda_Code_Word[pn_Initial_Code_Book_Index[n_Code_Word_Index]], sizeof(double) * n_Code_Word_Dim);
  72. }
  74. delete[] pn_Initial_Code_Book_Index;
  75. }
  77. pn_Code_Word_Min_Index = new int[n_Code_Word_Num];
  78. pd_Code_Word_Min_Distance = new double[n_Code_Word_Num];
  79. ASSERT((pn_Code_Word_Min_Index != NULL) && (pd_Code_Word_Min_Distance != NULL));
  81. d_Distance = MAX_DOUBLE_VALUE;
  82. for (n_Loop_Index = 0; n_Loop_Index < VQ_TRAIN_CODE_BOOK_LOOP_TIME; n_Loop_Index++)
  83. {
  84. DEBUG_PRINTF("VQ:tLoop = %4d of %d.n", n_Loop_Index, VQ_TRAIN_CODE_BOOK_LOOP_TIME);
  86. // 计算每个特征的最近类中心及距离
  87. for (n_Feature_Index = 0; n_Feature_Index < n_Code_Word_Num; n_Feature_Index++)
  88. {
  89. pn_Code_Word_Min_Index[n_Feature_Index] = -1;
  90. pd_Code_Word_Min_Distance[n_Feature_Index] = MAX_DOUBLE_VALUE;
  92. for (n_Code_Word_Index = 0; n_Code_Word_Index < n_Code_Book_Size; n_Code_Word_Index++)
  93. {
  94. dTmp = 0.0F;
  95. for (n_Dim_Index = 0; n_Dim_Index < n_Code_Word_Dim; n_Dim_Index++)
  96. {
  97. dTmp += (d2dda_Code_Word[n_Feature_Index][n_Dim_Index] - d2dda_Code_Book[n_Code_Word_Index][n_Dim_Index])
  98. * (d2dda_Code_Word[n_Feature_Index][n_Dim_Index] - d2dda_Code_Book[n_Code_Word_Index][n_Dim_Index]);
  99. }
  101. if (dTmp < pd_Code_Word_Min_Distance[n_Feature_Index])
  102. {
  103. pn_Code_Word_Min_Index[n_Feature_Index] = n_Code_Word_Index;
  104. pd_Code_Word_Min_Distance[n_Feature_Index] = dTmp;
  105. }
  106. }
  107. }
  109. // 计算类内平均距离
  110. d_Old_Distance = d_Distance;
  111. d_Distance = 0.0F;
  112. for (n_Feature_Index = 0; n_Feature_Index < n_Code_Word_Num; n_Feature_Index++)
  113. {
  114. d_Distance += pd_Code_Word_Min_Distance[n_Feature_Index];
  115. }
  116. d_Distance /= n_Code_Word_Num;
  118. DEBUG_PRINTF("tAverage Distance = %10.4f, Changed %15.4E.n", d_Distance, ((d_Old_Distance - d_Distance) / d_Old_Distance));
  120. // 按最近距离原则给每类分派样点，并用该类样点的平均值更新类中心
  121. for (n_Code_Word_Index = 0; n_Code_Word_Index < n_Code_Book_Size; n_Code_Word_Index++)
  122. {
  123. nTmp = 0;
  124. for (n_Dim_Index = 0; n_Dim_Index < n_Code_Word_Dim; n_Dim_Index++)
  125. {
  126. d2dda_Code_Book[n_Code_Word_Index][n_Dim_Index] = 0.0F;
  127. }
  128. for (n_Feature_Index = 0; n_Feature_Index < n_Code_Word_Num; n_Feature_Index++)
  129. {
  130. if (pn_Code_Word_Min_Index[n_Feature_Index] == n_Code_Word_Index)
  131. {
  132. nTmp++;
  133. for (n_Dim_Index = 0; n_Dim_Index < n_Code_Word_Dim; n_Dim_Index++)
  134. {
  135. d2dda_Code_Book[n_Code_Word_Index][n_Dim_Index] += d2dda_Code_Word[n_Feature_Index][n_Dim_Index];
  136. }
  137. }
  138. }
  140. // 该类分到了样点，直接计算
  141. if (nTmp != 0)
  142. {
  143. for (n_Dim_Index = 0; n_Dim_Index < n_Code_Word_Dim; n_Dim_Index++)
  144. {
  145. d2dda_Code_Book[n_Code_Word_Index][n_Dim_Index] /= nTmp;
  146. }
  147. }
  148. // 该类没有分到样点，则丢弃原类中心，随机选中一个样点作为该类中心
  149. else
  150. {
  151. do {
  152. nTmp = int((double(rand()) / (double(RAND_MAX) + 1)) * n_Code_Word_Num);
  153. boolTmp = FALSE;
  154. if (pd_Code_Word_Min_Distance[nTmp] < EPSILON_DOUBLE_VALUE) boolTmp = TRUE;
  155. } while (boolTmp);
  157. memcpy(d2dda_Code_Book[n_Code_Word_Index], d2dda_Code_Word[nTmp], sizeof(double) * n_Code_Word_Dim);
  158. }
  159. }
  161. }
  162. PRO_LOG("VQ:tLoop = %4d, Average Distance = %10.4f, Changed %15.4E.n", n_Loop_Index, d_Distance, ((d_Old_Distance - d_Distance) / d_Old_Distance));
  164. delete[] pn_Code_Word_Min_Index;
  165. delete[] pd_Code_Word_Min_Distance;
  167. return 0;
  168. }
  170. int DHMM_Model_Train_DHMM_Model_HQ(WORD_SAMPLE * pu_Word_Sample, int n_Word_Sample_Num,
  171.    DHMM_MODEL * pu_DHMM_Model)
  172. {
  173. DYNA_2DIM_DOUBLE_ARRAY d2dda_Nom; // 状态数 * 输出个数
  174. double * pd_Denom; // 状态数
  175. int n_Loop_Index, n_State_Index, n_Code_Word_Index, n_Word_Sample_Index, n_Frame_Index;
  176. int nTmp;
  177. double d_Old_Total_Likelihood, d_Total_Likelihood; // 上次与此次迭代的模型对所有词条匹配分数的加和
  178. double dTmp;
  180. PRO_LOG("tModel = HQ, loop = %4d.n", MODEL_TRAIN_CODE_BOOK_LOOP_TIME);
  182. // 初始化Pi，初始状态为状态0
  183. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  184. {
  185. pu_DHMM_Model->pdPi[n_State_Index] = 0.0F;
  186. }
  187. pu_DHMM_Model->pdPi[0] = 1.0F;
  189. // 初始化A，只能停留或跳向下一个状态，并且等概0.5，最后一个状态只能停留
  190. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  191. {
  192. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  193. {
  194. pu_DHMM_Model->d2dda_A[n_State_Index][nTmp] = 0.0F;
  195. }
  196. }
  197. for (n_State_Index = 0; n_State_Index < (pu_DHMM_Model->n_State_Num - 1); n_State_Index++)
  198. {
  199. pu_DHMM_Model->d2dda_A[n_State_Index][n_State_Index] = 0.5F;
  200. pu_DHMM_Model->d2dda_A[n_State_Index][n_State_Index + 1] = 0.5F;
  201. }
  202. pu_DHMM_Model->d2dda_A[pu_DHMM_Model->n_State_Num - 1][pu_DHMM_Model->n_State_Num - 1] = 1.0F;
  204. // 初始化B，均匀初始化，每个状态输出各个输出码字的概率均等，为码字总数的倒数
  205. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  206. {
  207. for (n_Code_Word_Index = 0; n_Code_Word_Index < pu_DHMM_Model->n_Code_Book_Size; n_Code_Word_Index++)
  208. {
  209. pu_DHMM_Model->d2dda_B[n_State_Index][n_Code_Word_Index] = 1.0F / pu_DHMM_Model->n_Code_Book_Size;
  210. }
  211. }
  213. d2dda_Nom = d2dda_New(pu_DHMM_Model->n_State_Num, pu_DHMM_Model->n_Code_Book_Size);
  214. pd_Denom = new double[pu_DHMM_Model->n_State_Num];
  215. ASSERT((d2dda_Nom != NULL) && (pd_Denom != NULL));
  216. for (n_Word_Sample_Index = 0; n_Word_Sample_Index < n_Word_Sample_Num; n_Word_Sample_Index++)
  217. {
  218. pu_Word_Sample[n_Word_Sample_Index].d2dda_Gamma = d2dda_New(pu_Word_Sample[n_Word_Sample_Index].n_Feature_Sequence_Len, pu_DHMM_Model->n_State_Num);
  219. ASSERT(pu_Word_Sample[n_Word_Sample_Index].d2dda_Gamma != NULL);
  220. }
  222. d_Total_Likelihood = -MAX_DOUBLE_VALUE;
  223. for (n_Loop_Index = 0; n_Loop_Index < MODEL_TRAIN_CODE_BOOK_LOOP_TIME; n_Loop_Index++)
  224. {
  225. // 计算每个词条的Gamma系数，二维数组，帧数 * 状态数
  226. for (n_Word_Sample_Index = 0; n_Word_Sample_Index < n_Word_Sample_Num; n_Word_Sample_Index++)
  227. {
  228. DHMM_Model_Calculate_Gamma(&pu_Word_Sample[n_Word_Sample_Index], pu_DHMM_Model);
  229. }
  231. // 准备重估B
  232. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  233. {
  234. pd_Denom[n_State_Index] = 0.0F;
  236. for (n_Code_Word_Index = 0; n_Code_Word_Index < pu_DHMM_Model->n_Code_Book_Size; n_Code_Word_Index++)
  237. {
  238. d2dda_Nom[n_State_Index][n_Code_Word_Index] = 0.0F;
  239. }
  240. }
  242. // 计算重估B时每项的分子，和每行的分母
  243. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  244. {
  245. for (n_Word_Sample_Index = 0; n_Word_Sample_Index < n_Word_Sample_Num; n_Word_Sample_Index++)
  246. {
  247. for (n_Frame_Index = 0; n_Frame_Index < pu_Word_Sample[n_Word_Sample_Index].n_Feature_Sequence_Len; n_Frame_Index++)
  248. {
  249. d2dda_Nom[n_State_Index][pu_Word_Sample[n_Word_Sample_Index].pn_VQed_Feature_Sequence[n_Frame_Index]]
  250. += pu_Word_Sample[n_Word_Sample_Index].d2dda_Gamma[n_Frame_Index][n_State_Index];
  251. pd_Denom[n_State_Index] += pu_Word_Sample[n_Word_Sample_Index].d2dda_Gamma[n_Frame_Index][n_State_Index];
  252. }
  253. }
  254. }
  256. // 重新计算B
  257. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  258. {
  259. for (n_Code_Word_Index = 0; n_Code_Word_Index < pu_DHMM_Model->n_Code_Book_Size; n_Code_Word_Index++)
  260. {
  261. pu_DHMM_Model->d2dda_B[n_State_Index][n_Code_Word_Index] = 
  262. d2dda_Nom[n_State_Index][n_Code_Word_Index] / pd_Denom[n_State_Index];
  263. }
  264. }
  266. // 计算当前模型对于全体训练词条的匹配分数和
  267. d_Old_Total_Likelihood = d_Total_Likelihood;
  268. d_Total_Likelihood = 0.0F;
  269. for (n_Word_Sample_Index = 0; n_Word_Sample_Index < n_Word_Sample_Num; n_Word_Sample_Index++)
  270. {
  271. DHMM_Recog_Forward_Backward_GL(pu_DHMM_Model, &pu_Word_Sample[n_Word_Sample_Index], &dTmp);
  272. d_Total_Likelihood += dTmp;
  273. }
  274. // 如果迭代收敛，跳出
  275. // if (fabs((d_Old_Total_Likelihood - d_Total_Likelihood) / d_Old_Total_Likelihood) < 1.0E-6) break;
  276. // DEBUG_PRINTF("tTotal likelihood = %10.4f, changed %15.4E.n", d_Total_Likelihood, ((d_Old_Total_Likelihood - d_Total_Likelihood) / d_Old_Total_Likelihood));
  277. }
  278. PRO_LOG("tLoop = %4d, Total likelihood = %10.4f, changed %15.4E.n", n_Loop_Index, d_Total_Likelihood, ((d_Old_Total_Likelihood - d_Total_Likelihood) / d_Old_Total_Likelihood));
  280. for (n_Word_Sample_Index = 0; n_Word_Sample_Index < n_Word_Sample_Num; n_Word_Sample_Index++)
  281. {
  282. d2dda_Free(pu_Word_Sample[n_Word_Sample_Index].d2dda_Gamma, pu_Word_Sample[n_Word_Sample_Index].n_Feature_Sequence_Len, pu_DHMM_Model->n_State_Num);
  283. pu_Word_Sample[n_Word_Sample_Index].d2dda_Gamma = NULL;
  284. }
  285. d2dda_Free(d2dda_Nom, pu_DHMM_Model->n_State_Num, pu_DHMM_Model->n_Code_Book_Size);
  286. delete[] pd_Denom;
  288. return 0;
  289. }
  291. int DHMM_Recog_Viterbi_HQ(DHMM_MODEL * pu_DHMM_Model,
  292.   WORD_SAMPLE * pu_Word_Sample,
  293.   double * pd_Max_Likelihood, int * pn_Status_Sequence)
  294. {
  295. DYNA_2DIM_DOUBLE_ARRAY d2dda_B;
  296. DYNA_2DIM_INT_ARRAY d2dna_LogB;
  297. int n_Code_Word_Index, n_State_Index;
  299. d2dda_B = d2dda_New(pu_DHMM_Model->n_State_Num, pu_DHMM_Model->n_Code_Book_Size);
  300. d2dna_LogB = d2dna_New(pu_DHMM_Model->n_State_Num, pu_DHMM_Model->n_Code_Book_Size);
  301. ASSERT((d2dda_B != NULL) && (d2dna_LogB != NULL));
  303. // 对于B矩阵进行定点化处理，下截底并取对数
  304. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  305. {
  306. memcpy(d2dda_B[n_State_Index], pu_DHMM_Model->d2dda_B[n_State_Index], sizeof(double) * pu_DHMM_Model->n_Code_Book_Size);
  307. }
  309. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  310. {
  311. for (n_Code_Word_Index = 0; n_Code_Word_Index < pu_DHMM_Model->n_Code_Book_Size; n_Code_Word_Index++)
  312. {
  313. if (d2dda_B[n_State_Index][n_Code_Word_Index] < EPSILON_DOUBLE_VALUE)
  314. d2dda_B[n_State_Index][n_Code_Word_Index] = EPSILON_DOUBLE_VALUE;
  315. d2dna_LogB[n_State_Index][n_Code_Word_Index]
  316. = (short)(log10(d2dda_B[n_State_Index][n_Code_Word_Index]) * (65536L / LOG_SCALE) + 32768L);
  317. ASSERT((d2dna_LogB[n_State_Index][n_Code_Word_Index] >= short(MIN_SHORT_VALUE)) && (d2dna_LogB[n_State_Index][n_Code_Word_Index] <= MAX_SHORT_VALUE));
  318. }
  319. }
  321. // 调用定点的Viterbi算法计算匹配分数
  322. *pd_Max_Likelihood = DHMM_Recog_Viterbi_HQ_FIX(d2dna_LogB, pu_DHMM_Model->n_State_Num,
  323. pu_Word_Sample->pn_VQed_Feature_Sequence, pu_Word_Sample->n_Feature_Sequence_Len);
  325. d2dda_Free(d2dda_B, pu_DHMM_Model->n_State_Num, pu_DHMM_Model->n_Code_Book_Size);
  326. d2dna_Free(d2dna_LogB, pu_DHMM_Model->n_State_Num, pu_DHMM_Model->n_Code_Book_Size);
  328. return 0;
  329. }
  331. // 定点viterbi算法，已经对于Pi和A作了简化假设
  332. long DHMM_Recog_Viterbi_HQ_FIX(DYNA_2DIM_INT_ARRAY d2dna_LogB, int n_State_Num,
  333.   int * pn_VQed_Feature_Sequence, int n_Feature_Sequence_Len)
  334. {
  335. long * pl_Alpha;
  336. int n_State_Index, n_Frame_Index;
  337. long lTmp1, lTmp2;
  339. int i=0;
  341. int first = 1;
  342. long sl_1 = 0;
  343. long sl_2 = 0;
  344. int second = 1;
  346. pl_Alpha = new long[n_State_Num];
  347. ASSERT(pl_Alpha != NULL);
  349. for (n_State_Index = 0; n_State_Index < n_State_Num; n_State_Index++) pl_Alpha[n_State_Index] = long(MIN_LONG_VALUE) / 2;
  350. pl_Alpha[0] = 0;
  351. pl_Alpha[1] = 0;
  353. // lTmp1: Delta[t-1][i-1], lTmp2: Delta[t-1][i]
  354. for (n_Frame_Index = 1; n_Frame_Index < n_Feature_Sequence_Len; n_Frame_Index++)
  355. {
  356. lTmp1 = MIN_LONG_VALUE;
  357. for (n_State_Index = 0; n_State_Index < n_State_Num; n_State_Index++)
  358. {
  359. lTmp2 = pl_Alpha[n_State_Index];
  360. if (lTmp1 > lTmp2) 
  361. pl_Alpha[n_State_Index] = lTmp1;
  362. pl_Alpha[n_State_Index] += d2dna_LogB[n_State_Index][pn_VQed_Feature_Sequence[n_Frame_Index]];
  363. lTmp1 = lTmp2;
  364. }
  365. }
  367. lTmp1 = MIN_LONG_VALUE;
  368. for (n_State_Index = 0; n_State_Index < n_State_Num; n_State_Index++)
  369. {
  370. if (lTmp1 < pl_Alpha[n_State_Index]) 
  371. lTmp1 = pl_Alpha[n_State_Index];
  372. }
  374. delete[] pl_Alpha;
  376. return lTmp1;
  377. }
  379. int DHMM_Recog_Forward_Backward_HQ(DHMM_MODEL * pu_DHMM_Model,
  380.    WORD_SAMPLE * pu_Word_Sample,
  381.    double * pd_Max_Likelihood)
  382. {
  383. DYNA_2DIM_DOUBLE_ARRAY d2dda_Alpha;
  384. int n_Frame_Index, n_State_Index;
  385. int nTmp;
  386. double dTmp;
  388. d2dda_Alpha = d2dda_New(pu_Word_Sample->n_Feature_Sequence_Len, pu_DHMM_Model->n_State_Num);
  389. ASSERT(d2dda_Alpha != NULL);
  391. for (n_Frame_Index = 0; n_Frame_Index < pu_Word_Sample->n_Feature_Sequence_Len; n_Frame_Index++)
  392. {
  393. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  394. {
  395. d2dda_Alpha[n_Frame_Index][n_State_Index] = 0.0F;
  396. }
  397. }
  398. d2dda_Alpha[0][0] = pu_DHMM_Model->d2dda_B[0][pu_Word_Sample->pn_VQed_Feature_Sequence[0]];
  400. for (n_Frame_Index = 1; n_Frame_Index < pu_Word_Sample->n_Feature_Sequence_Len; n_Frame_Index++)
  401. {
  402. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  403. {
  404. dTmp = 0.0F;
  405. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  406. {
  407. dTmp += d2dda_Alpha[n_Frame_Index - 1][nTmp] * pu_DHMM_Model->d2dda_A[nTmp][n_State_Index];
  408. }
  409. d2dda_Alpha[n_Frame_Index][n_State_Index] = dTmp * pu_DHMM_Model->d2dda_B[n_State_Index][pu_Word_Sample->pn_VQed_Feature_Sequence[n_Frame_Index]];
  410. }
  411. }
  413. dTmp = 0.0F;
  414. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  415. {
  416. dTmp += d2dda_Alpha[pu_Word_Sample->n_Feature_Sequence_Len - 1][n_State_Index];
  417. }
  418. (*pd_Max_Likelihood) = log(dTmp);
  420. d2dda_Free(d2dda_Alpha, pu_Word_Sample->n_Feature_Sequence_Len, pu_DHMM_Model->n_State_Num);
  422. return 0;
  423. }
  425. static int DHMM_Model_Calculate_Gamma(WORD_SAMPLE * pu_Word_Sample, DHMM_MODEL * pu_DHMM_Model)
  426. {
  427. DYNA_2DIM_DOUBLE_ARRAY d2dda_Alpha;
  428. DYNA_2DIM_DOUBLE_ARRAY d2dda_Beta;
  429. double * pd_C;
  430. int n_Frame_Index, n_State_Index;
  431. int nTmp;
  432. double dTmp;
  434. d2dda_Alpha = d2dda_New(pu_Word_Sample->n_Feature_Sequence_Len, pu_DHMM_Model->n_State_Num);
  435. ASSERT(d2dda_Alpha !=NULL);
  436. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  437. {
  438. d2dda_Alpha[0][nTmp] = 0.0F;
  439. }
  440. d2dda_Alpha[0][0] = pu_DHMM_Model->d2dda_B[0][pu_Word_Sample->pn_VQed_Feature_Sequence[0]];
  442. pd_C = new double[pu_Word_Sample->n_Feature_Sequence_Len];
  443. pd_C[0] = 0.0F;
  444. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  445. {
  446. pd_C[0] += d2dda_Alpha[0][nTmp];
  447. }
  448. pd_C[0] = 1.0F / pd_C[0];
  449. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  450. {
  451. d2dda_Alpha[0][nTmp] *= pd_C[0];
  452. }
  454. for (n_Frame_Index = 1; n_Frame_Index < pu_Word_Sample->n_Feature_Sequence_Len; n_Frame_Index++)
  455. {
  456. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  457. {
  458. dTmp = 0.0F;
  459. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  460. {
  461. dTmp += d2dda_Alpha[n_Frame_Index - 1][nTmp] * pu_DHMM_Model->d2dda_A[nTmp][n_State_Index];
  462. }
  463. d2dda_Alpha[n_Frame_Index][n_State_Index] = dTmp * pu_DHMM_Model->d2dda_B[n_State_Index][pu_Word_Sample->pn_VQed_Feature_Sequence[n_Frame_Index]];
  464. }
  465. pd_C[n_Frame_Index] = 0.0F;
  466. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  467. {
  468. pd_C[n_Frame_Index] += d2dda_Alpha[n_Frame_Index][nTmp];
  469. }
  470. pd_C[n_Frame_Index] = 1.0F / pd_C[n_Frame_Index];
  471. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  472. {
  473. d2dda_Alpha[n_Frame_Index][nTmp] *= pd_C[n_Frame_Index];
  474. }
  475. }
  477. d2dda_Beta = d2dda_New(pu_Word_Sample->n_Feature_Sequence_Len, pu_DHMM_Model->n_State_Num);
  478. ASSERT(d2dda_Beta != NULL);
  480. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  481. {
  482. d2dda_Beta[pu_Word_Sample->n_Feature_Sequence_Len - 1][nTmp] = pd_C[pu_Word_Sample->n_Feature_Sequence_Len - 1];
  483. }
  485. for (n_Frame_Index = pu_Word_Sample->n_Feature_Sequence_Len - 2; n_Frame_Index >= 0; n_Frame_Index--)
  486. {
  487. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  488. {
  489. d2dda_Beta[n_Frame_Index][n_State_Index] = 0.0F;
  490. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  491. {
  492. d2dda_Beta[n_Frame_Index][n_State_Index] +=
  493. d2dda_Beta[n_Frame_Index + 1][nTmp] * pu_DHMM_Model->d2dda_B[nTmp][pu_Word_Sample->pn_VQed_Feature_Sequence[n_Frame_Index + 1]] * pu_DHMM_Model->d2dda_A[n_State_Index][nTmp];
  494. }
  495. }
  496. for (nTmp = 0; nTmp < pu_DHMM_Model->n_State_Num; nTmp++)
  497. {
  498. d2dda_Beta[n_Frame_Index][nTmp] *= pd_C[n_Frame_Index];
  499. }
  500. }
  502. for (n_Frame_Index = 0; n_Frame_Index < pu_Word_Sample->n_Feature_Sequence_Len; n_Frame_Index++)
  503. {
  504. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  505. {
  506. pu_Word_Sample->d2dda_Gamma[n_Frame_Index][n_State_Index]
  507. = d2dda_Alpha[n_Frame_Index][n_State_Index] * d2dda_Beta[n_Frame_Index][n_State_Index];
  508. }
  510. dTmp = 0.0F;
  511. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  512. {
  513. dTmp += pu_Word_Sample->d2dda_Gamma[n_Frame_Index][n_State_Index];
  514. }
  515. for (n_State_Index = 0; n_State_Index < pu_DHMM_Model->n_State_Num; n_State_Index++)
  516. {
  517. pu_Word_Sample->d2dda_Gamma[n_Frame_Index][n_State_Index] /= dTmp;
  518. }
  519. }
  521. d2dda_Free(d2dda_Beta, pu_Word_Sample->n_Feature_Sequence_Len, pu_DHMM_Model->n_State_Num);
  522. delete[] pd_C;
  523. d2dda_Free(d2dda_Alpha, pu_Word_Sample->n_Feature_Sequence_Len, pu_DHMM_Model->n_State_Num);
  525. return 0;
  526. }