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

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

DSP编程

开发平台：

Visual C++

DHMM_MODEL_MFC.cpp：源码内容
  1. // DHMM_MODEL_MFC.cpp:
  2. // Implementation of the DHMM_MODEL_MFC Module.
  3. // That is to train DHMM_Model.
  4. //
  5. // Created 2001/08, By DongMing, MDSR.
  6. //
  7. //////////////////////////////////////////////////////////////////////
  9. #include "stdafx.h"
  10. #include "DHMM_Model_MFC.h"
  11. #include "kwspot.h"
  12. #include "DAT_File_Access.h"
  13. #include "DHMM_VQ_MFC.h"
  15. #include "DHMM_GL.h"
  16. #include "DHMM_LHS.h"
  17. #include "DHMM_HQ.h"
  19. extern PRO_CONFIG u_Pro_Config;
  21. //////////////////////////////////////////////////////////////////////
  22. // API functions
  24. //////////////////////////////////////////////////////////////////////
  25. // 函数名称：DHMM_Model
  26. // 函数功能：DHMM程序进行模型训练模块的入口
  27. // 函数性质：API
  28. // 输入参数：
  29. // 无
  30. // 输出参数：
  31. // 无
  32. // 返回值：
  33. // 0 表示成功
  34. // 备注：本模块完成DHMM模型训练，模块的应用接口实际上是基于文件的，
  35. // 训练的结果将保存在u_Pro_Config.sz_Toload_DHMM_Model_File_Name中
  36. int DHMM_Model(void)
  37. {
  38. int nRetCode;
  39. DHMM_MODEL * pu_DHMM_Model;
  40. int n_Model_Index;
  41. DHMM_MODEL Silence_Model;
  42. int Total_Model_Num;
  44. if ((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) == MODEL_CONFIG_LOAD_WITH_SILENCE_MODEL)
  45. {
  46. //  为静音模型多准备两个状态
  47. u_Pro_Config.n_DHMM_Model_State_Num += 2;
  48. }
  49. Total_Model_Num =u_Pro_Config.n_DHMM_Model_Num;
  51. // 为DHMM模型准备内存
  52. pu_DHMM_Model = new DHMM_MODEL[Total_Model_Num];
  53. ASSERT(pu_DHMM_Model);
  54. for (n_Model_Index = 0; n_Model_Index < Total_Model_Num; n_Model_Index++)
  55. {
  56. pu_DHMM_Model[n_Model_Index].n_State_Num = u_Pro_Config.n_DHMM_Model_State_Num;
  57. pu_DHMM_Model[n_Model_Index].n_Code_Book_Size = u_Pro_Config.n_VQ_Code_Book_Size;
  58. pu_DHMM_Model[n_Model_Index].pdPi = new double[u_Pro_Config.n_DHMM_Model_State_Num];
  59. pu_DHMM_Model[n_Model_Index].d2dda_A = d2dda_New(u_Pro_Config.n_DHMM_Model_State_Num, u_Pro_Config.n_DHMM_Model_State_Num);
  60. pu_DHMM_Model[n_Model_Index].d2dda_B = d2dda_New(u_Pro_Config.n_DHMM_Model_State_Num, u_Pro_Config.n_VQ_Code_Book_Size);
  61. ASSERT((pu_DHMM_Model[n_Model_Index].pdPi != NULL)
  62. && (pu_DHMM_Model[n_Model_Index].d2dda_A != NULL)
  63. && (pu_DHMM_Model[n_Model_Index].d2dda_B != NULL));
  64. }
  66. Silence_Model.n_State_Num = 1;
  67. Silence_Model.n_Code_Book_Size = u_Pro_Config.n_VQ_Code_Book_Size;
  68. Silence_Model.pdPi = new double[u_Pro_Config.n_DHMM_Model_State_Num];
  69. Silence_Model.d2dda_A = d2dda_New(Silence_Model.n_State_Num, Silence_Model.n_State_Num);
  70. Silence_Model.d2dda_B = d2dda_New(Silence_Model.n_State_Num, u_Pro_Config.n_VQ_Code_Book_Size);
  71. ASSERT((Silence_Model.pdPi != NULL)
  72. && (Silence_Model.d2dda_A != NULL)
  73. && (Silence_Model.d2dda_B != NULL));
  75. // Load_Only With Silence DHMM_Model
  76. if ((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) == MODEL_CONFIG_LOAD_WITH_SILENCE_MODEL)
  77. {
  78. nRetCode = DHMM_Model_Load_DHMM_Model_File_With_Silence(u_Pro_Config.sz_Toload_DHMM_Model_File_Name, pu_DHMM_Model, Total_Model_Num);
  79. ASSERT(nRetCode == 0);
  80. }
  81. // Train_Only With Silence DHMM_Model
  82. else if ((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) == MODEL_CONFIG_TRAIN_WITH_SILENCE_MODEL)
  83. {
  84. nRetCode = DHMM_Model_Train_Silence_DHMM_Model(&Silence_Model);
  85. nRetCode = DHMM_Model_Train_All_DHMM_Model(pu_DHMM_Model, u_Pro_Config.n_DHMM_Model_Num);
  86. ASSERT(nRetCode == 0);
  87. nRetCode = DHMM_Model_Save_DHMM_Model_File_With_Silence(u_Pro_Config.sz_Toload_DHMM_Model_File_Name, pu_DHMM_Model, &Silence_Model,Total_Model_Num);
  88. ASSERT(nRetCode == 0);
  89. }
  91. // 释放模型占用内存
  92. for (n_Model_Index = 0; n_Model_Index < Total_Model_Num; n_Model_Index++)
  93. {
  94. delete[] pu_DHMM_Model[n_Model_Index].pdPi;
  95. d2dda_Free(pu_DHMM_Model[n_Model_Index].d2dda_A, u_Pro_Config.n_DHMM_Model_State_Num, u_Pro_Config.n_DHMM_Model_State_Num);
  96. d2dda_Free(pu_DHMM_Model[n_Model_Index].d2dda_B, u_Pro_Config.n_DHMM_Model_State_Num, u_Pro_Config.n_VQ_Code_Book_Size);
  97. }
  98. delete[] pu_DHMM_Model;
  99. if ((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) == MODEL_CONFIG_LOAD_WITH_SILENCE_MODEL)
  100. {
  101. //  为静音模型多准备两个状态
  102. u_Pro_Config.n_DHMM_Model_State_Num -= 2;
  103. }
  105. delete [] Silence_Model.pdPi;
  106. d2dda_Free(Silence_Model.d2dda_A, Silence_Model.n_State_Num, Silence_Model.n_State_Num);
  107. d2dda_Free(Silence_Model.d2dda_B, Silence_Model.n_State_Num, u_Pro_Config.n_VQ_Code_Book_Size);
  109. return 0;
  110. }
  112. //////////////////////////////////////////////////////////////////////
  113. // 函数名称：DHMM_Model_Save_DHMM_Model_File_With_Silence
  114. // 函数功能：向文件写入DHMM模型
  115. // 函数性质：API
  116. // 输入参数：
  117. // sz_Tosave_DHMM_Model_File_Name，存储模型的文件名
  118. // n_DHMM_Model_Num，要存储的模型个数
  119. // 输出参数：
  120. // pu_DHMM_Model，存放待写入的DHMM模型
  121. // 返回值：
  122. // 0 表示成功
  123. // 备注：关于DHMM_MODEL的定义，参见公共的.H文件
  124. // 模型存储使用.DAT格式中的模型存储格式，可参见DAT_File_Access模块
  125. int DHMM_Model_Save_DHMM_Model_File_With_Silence(char * sz_Tosave_DHMM_Model_File_Name,
  126. DHMM_MODEL * pu_DHMM_Model, DHMM_MODEL * pu_Silence_Model, int n_DHMM_Model_Num)
  127. {
  128. FILE * fp_DHMM_Model_File;
  129. DHMM_MODEL_FILE_HEAD u_DHMM_Model_File_Head;
  130. long l_Word_Sample_Offset;
  131. int n_Model_Index, n_State_Index;
  132. long lTmp;
  134. CString Silence_File(sz_Tosave_DHMM_Model_File_Name);
  135. Silence_File.Replace(".DAT", "WS.DAT");
  136. fp_DHMM_Model_File = fopen(Silence_File, "wb");
  137. ASSERT(fp_DHMM_Model_File != NULL);
  139. // 填写模型文件头
  140. memset(&u_DHMM_Model_File_Head, 0, sizeof(u_DHMM_Model_File_Head));
  141. u_DHMM_Model_File_Head.lVersion = DAT_FILE_VERSION;
  142. strcpy(u_DHMM_Model_File_Head.szName, "DHMM_Model");
  143. u_DHMM_Model_File_Head.sDHMM_Model_Num = u_DHMM_Model_File_Head.sDHMM_Model_Num2 = n_DHMM_Model_Num;
  144. strcpy(u_DHMM_Model_File_Head.szParameterType, "DHMMModel");
  145. u_DHMM_Model_File_Head.sSampleType = SAMPLE_DATA_TYPE_DOUBLE;
  146. u_DHMM_Model_File_Head.sModelStateNum = pu_DHMM_Model[0].n_State_Num + 2;
  147. u_DHMM_Model_File_Head.sCodeBookSize = pu_DHMM_Model[0].n_Code_Book_Size;
  149. ASSERT(sizeof(u_DHMM_Model_File_Head) == 200);
  150. fwrite(&u_DHMM_Model_File_Head, sizeof(u_DHMM_Model_File_Head), 1, fp_DHMM_Model_File);
  152. // 用空索引表占据空间
  153. lTmp = 0;
  154. for (n_Model_Index = 0; n_Model_Index < n_DHMM_Model_Num; n_Model_Index++)
  155. {
  156. fwrite(&lTmp, sizeof(long), 1, fp_DHMM_Model_File);
  157. fwrite(&lTmp, sizeof(long), 1, fp_DHMM_Model_File);
  158. }
  160. // 依次写入每个模型
  161. for (n_Model_Index = 0; n_Model_Index < n_DHMM_Model_Num; n_Model_Index++)
  162. {
  163. // 得到模型的文件偏移值，写入索引表
  164. fseek(fp_DHMM_Model_File, 0, SEEK_END);
  165. l_Word_Sample_Offset = ftell(fp_DHMM_Model_File);
  166. fseek(fp_DHMM_Model_File, 200 + 4 * 2 * (n_Model_Index), SEEK_SET);
  167. fwrite(&l_Word_Sample_Offset, sizeof(long), 1, fp_DHMM_Model_File);
  169. fseek(fp_DHMM_Model_File, l_Word_Sample_Offset, SEEK_SET);
  170. // Pi
  171. fwrite(pu_DHMM_Model[n_Model_Index].pdPi, sizeof(double), u_DHMM_Model_File_Head.sModelStateNum - 2, fp_DHMM_Model_File);
  172. // A
  173. for (n_State_Index = 0; n_State_Index < u_DHMM_Model_File_Head.sModelStateNum - 2; n_State_Index++)
  174. {
  175. fwrite(pu_DHMM_Model[n_Model_Index].d2dda_A[n_State_Index], sizeof(double), u_DHMM_Model_File_Head.sModelStateNum - 2, fp_DHMM_Model_File);
  176. }
  177. // B
  178. fwrite(pu_Silence_Model[0].d2dda_B[0], sizeof(double), u_DHMM_Model_File_Head.sCodeBookSize, fp_DHMM_Model_File);
  179. for (n_State_Index = 0; n_State_Index < u_DHMM_Model_File_Head.sModelStateNum - 2; n_State_Index++)
  180. {
  181. fwrite(pu_DHMM_Model[n_Model_Index].d2dda_B[n_State_Index], sizeof(double), u_DHMM_Model_File_Head.sCodeBookSize, fp_DHMM_Model_File);
  182. }
  183. fwrite(pu_Silence_Model[0].d2dda_B[0], sizeof(double), u_DHMM_Model_File_Head.sCodeBookSize, fp_DHMM_Model_File);
  185. }
  187. fclose(fp_DHMM_Model_File);
  189. return 0;
  190. }
  192. //////////////////////////////////////////////////////////////////////
  193. // 函数名称：DHMM_Model_Load_DHMM_Model_File_With_Silence
  194. // 函数功能：从文件读入带静音的DHMM模型
  195. // 函数性质：API
  196. // 输入参数：
  197. // sz_Toload_DHMM_Model_File_Name，存储模型的文件名
  198. // n_DHMM_Model_Num，要读取的模型个数
  199. // 输出参数：
  200. // pu_DHMM_Model，存放读出的DHMM模型
  201. // 返回值：
  202. // 0 表示成功
  203. // 备注：关于DHMM_MODEL的定义，参见公共的.H文件
  204. // 模型存储使用.DAT格式中的模型存储格式，可参见DAT_File_Access模块
  205. int DHMM_Model_Load_DHMM_Model_File_With_Silence(char * sz_Toload_DHMM_Model_File_Name,
  206. DHMM_MODEL * pu_DHMM_Model, int n_DHMM_Model_Num)
  207. {
  208. FILE * fp_DHMM_Model_File;
  209. DHMM_MODEL_FILE_HEAD u_DHMM_Model_File_Head;
  210. int * pn_DHMM_Model_Offset;
  211. int n_Model_Index, n_State_Index;
  212. long lTmp;
  214. CString Silence_File(sz_Toload_DHMM_Model_File_Name);
  215. Silence_File.Replace(".DAT", "WS.DAT");
  216. fp_DHMM_Model_File = fopen(Silence_File, "rb");
  217. ASSERT(fp_DHMM_Model_File != NULL);
  219. fread(&u_DHMM_Model_File_Head, sizeof(u_DHMM_Model_File_Head), 1, fp_DHMM_Model_File);
  220. ASSERT(u_DHMM_Model_File_Head.lVersion >= DAT_FILE_VERSION);
  221. // ASSERT(u_DHMM_Model_File_Head.sDHMM_Model_Num == u_Pro_Config.n_DHMM_Model_Num);
  223. // ASSERT(u_DHMM_Model_File_Head.sModelStateNum == pu_DHMM_Model->n_State_Num);
  225. pn_DHMM_Model_Offset = new int[n_DHMM_Model_Num];
  226. ASSERT(pn_DHMM_Model_Offset != NULL);
  228. // 读入每个模型的文件偏移
  229. for (n_Model_Index = 0; n_Model_Index < n_DHMM_Model_Num; n_Model_Index++)
  230. {
  231. fread(&pn_DHMM_Model_Offset[n_Model_Index], sizeof(long), 1, fp_DHMM_Model_File);
  232. fread(&lTmp, sizeof(long), 1, fp_DHMM_Model_File);
  233. }
  235. // 依次读入每个模型数据
  236. for (n_Model_Index = 0; n_Model_Index < n_DHMM_Model_Num; n_Model_Index++)
  237. {
  238. pu_DHMM_Model[n_Model_Index].n_State_Num = u_DHMM_Model_File_Head.sModelStateNum;
  239. pu_DHMM_Model[n_Model_Index].n_Code_Book_Size = u_DHMM_Model_File_Head.sCodeBookSize;
  241. fseek(fp_DHMM_Model_File, pn_DHMM_Model_Offset[n_Model_Index], SEEK_SET);
  243. // Pi
  244. fread(pu_DHMM_Model[n_Model_Index].pdPi, sizeof(double), u_DHMM_Model_File_Head.sModelStateNum - 2, fp_DHMM_Model_File);
  245. // A
  246. for (n_State_Index = 0; n_State_Index < u_DHMM_Model_File_Head.sModelStateNum - 2; n_State_Index++)
  247. {
  248. fread(pu_DHMM_Model[n_Model_Index].d2dda_A[n_State_Index], sizeof(double), u_DHMM_Model_File_Head.sModelStateNum - 2, fp_DHMM_Model_File);
  249. }
  250. // B
  251. for (n_State_Index = 0; n_State_Index < u_DHMM_Model_File_Head.sModelStateNum; n_State_Index++)
  252. {
  253. fread(pu_DHMM_Model[n_Model_Index].d2dda_B[n_State_Index], sizeof(double), u_DHMM_Model_File_Head.sCodeBookSize, fp_DHMM_Model_File);
  254. }
  255. }
  257. delete[] pn_DHMM_Model_Offset;
  258. fclose(fp_DHMM_Model_File);
  260. return 0;
  261. }
  263. //////////////////////////////////////////////////////////////////////
  264. // 函数名称：DHMM_Model_To_519_Model
  265. // 函数功能：向文件写入可以用于519系统的定点，对数化，DHMM模型。
  266. // 函数性质：API
  267. // 备注：关于DHMM_MODEL的定义，参见公共的.H文件
  268. // 模型存储使用.DAT格式中的模型存储格式，可参见DAT_File_Access模块
  269. int DHMM_Model_To_519_Model(void)
  270. {
  271. DHMM_MODEL * pu_DHMM_Model;
  272. int n_Model_Index;
  273. int n_DHMM_Model_Num;
  274. int nRetCode;
  276. char ModelFile[256];
  277. strcpy(ModelFile, u_Pro_Config.sz_Toload_DHMM_Model_File_Name);
  279. n_DHMM_Model_Num = u_Pro_Config.n_DHMM_Model_Num;
  280. if (((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) == (MODEL_CONFIG_TRAIN_WITH_SILENCE_MODEL))
  281. | ((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) == ( MODEL_CONFIG_LOAD_WITH_SILENCE_MODEL)))
  282. {
  283. u_Pro_Config.n_DHMM_Model_State_Num += 2;
  284. }
  287. // 为DHMM模型准备内存
  288. pu_DHMM_Model = new DHMM_MODEL[n_DHMM_Model_Num];
  289. ASSERT(pu_DHMM_Model);
  290. for (n_Model_Index = 0; n_Model_Index < n_DHMM_Model_Num; n_Model_Index++)
  291. {
  292. pu_DHMM_Model[n_Model_Index].n_State_Num = u_Pro_Config.n_DHMM_Model_State_Num;
  293. pu_DHMM_Model[n_Model_Index].n_Code_Book_Size = u_Pro_Config.n_VQ_Code_Book_Size;
  294. pu_DHMM_Model[n_Model_Index].pdPi = new double[u_Pro_Config.n_DHMM_Model_State_Num];
  295. pu_DHMM_Model[n_Model_Index].d2dda_A = d2dda_New(u_Pro_Config.n_DHMM_Model_State_Num, u_Pro_Config.n_DHMM_Model_State_Num);
  296. pu_DHMM_Model[n_Model_Index].d2dda_B = d2dda_New(u_Pro_Config.n_DHMM_Model_State_Num, u_Pro_Config.n_VQ_Code_Book_Size);
  297. ASSERT((pu_DHMM_Model[n_Model_Index].pdPi != NULL)
  298. && (pu_DHMM_Model[n_Model_Index].d2dda_A != NULL)
  299. && (pu_DHMM_Model[n_Model_Index].d2dda_B != NULL));
  300. }
  302. double** d2dda_B;
  303. double** d2dda_LogB = d2dda_New(u_Pro_Config.n_DHMM_Model_State_Num, u_Pro_Config.n_VQ_Code_Book_Size);
  304. ASSERT((d2dda_LogB != NULL));
  306. if (((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) == (MODEL_CONFIG_TRAIN_WITH_SILENCE_MODEL))
  307. | ((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) == ( MODEL_CONFIG_LOAD_WITH_SILENCE_MODEL)))
  308. {
  309. nRetCode = DHMM_Model_Load_DHMM_Model_File_With_Silence(u_Pro_Config.sz_Toload_DHMM_Model_File_Name, pu_DHMM_Model, n_DHMM_Model_Num);
  310. }
  311. ASSERT(nRetCode == 0);
  313. CString model_519file = u_Pro_Config.sz_Toload_DHMM_Model_File_Name;
  314. model_519file.Replace(".DAT", "519.dat");
  316. FILE *fp_DHMM_Model_File, *fp_DHMM_Model_TXT_File, *fp_DHMM_Model_BIN_File;
  317. fp_DHMM_Model_File = fopen(model_519file, "wb");
  318. fp_DHMM_Model_TXT_File = fopen("..//..//data//modelTXT.dat","wb+");
  319. fp_DHMM_Model_BIN_File = fopen("..//..//data//modelBIN.dat","wb+");
  320. ASSERT(fp_DHMM_Model_File != NULL);
  322. short data;
  324. // 依次写入每个模型
  325. for (n_Model_Index = 0; n_Model_Index < n_DHMM_Model_Num; n_Model_Index++)
  326. {
  327. d2dda_B = pu_DHMM_Model[n_Model_Index].d2dda_B;
  328. // B
  329. for (int n_State_Index = 0; n_State_Index < u_Pro_Config.n_DHMM_Model_State_Num; n_State_Index++)
  330. {
  331. for(int n_Code_Word_Index = 0; n_Code_Word_Index < pu_DHMM_Model->n_Code_Book_Size; n_Code_Word_Index++)
  332. {
  333. if (d2dda_B[n_State_Index][n_Code_Word_Index] < EPSILON_DOUBLE_VALUE)
  334. d2dda_B[n_State_Index][n_Code_Word_Index] = EPSILON_DOUBLE_VALUE;
  335. d2dda_LogB[n_State_Index][n_Code_Word_Index]
  336. = (int)(log10(d2dda_B[n_State_Index][n_Code_Word_Index]) * (65536L / LOG_SCALE) + 32768L/* + 0.5F*/);
  337. ASSERT((d2dda_LogB[n_State_Index][n_Code_Word_Index] >= short(MIN_SHORT_VALUE)) && (d2dda_LogB[n_State_Index][n_Code_Word_Index] <= MAX_SHORT_VALUE));
  338. data = (short)d2dda_LogB[n_State_Index][n_Code_Word_Index];
  339. fwrite(&data,sizeof(short),1,fp_DHMM_Model_File);
  340. // if ((n_Model_Index < 15) || (n_Model_Index > 15 && n_Model_Index < 20)
  341. // || (n_Model_Index > 25 && n_Model_Index < 34))
  342. {
  343. fwrite(&data,sizeof(short),1,fp_DHMM_Model_BIN_File);
  344. fprintf(fp_DHMM_Model_TXT_File,"%d,",data);
  345. }
  347. }
  349. }
  350. fprintf(fp_DHMM_Model_TXT_File,"n");
  351. }
  353. fclose(fp_DHMM_Model_File);
  354. fclose(fp_DHMM_Model_TXT_File);
  355. fclose(fp_DHMM_Model_BIN_File);
  356. d2dda_Free(d2dda_LogB, pu_DHMM_Model->n_State_Num, pu_DHMM_Model->n_Code_Book_Size);
  359. // 释放模型占用内存
  360. for (n_Model_Index = 0; n_Model_Index < n_DHMM_Model_Num; n_Model_Index++)
  361. {
  362. delete[] pu_DHMM_Model[n_Model_Index].pdPi;
  363. d2dda_Free(pu_DHMM_Model[n_Model_Index].d2dda_A, u_Pro_Config.n_DHMM_Model_State_Num, u_Pro_Config.n_DHMM_Model_State_Num);
  364. d2dda_Free(pu_DHMM_Model[n_Model_Index].d2dda_B, u_Pro_Config.n_DHMM_Model_State_Num, u_Pro_Config.n_VQ_Code_Book_Size);
  365. }
  366. delete[] pu_DHMM_Model;
  367. if ((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) == (MODEL_CONFIG_TRAIN_WITH_SILENCE_MODEL))
  368. u_Pro_Config.n_DHMM_Model_State_Num -= 2;
  369. else if((u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_GENERATE_DHMM_MODEL_MASK) ==  MODEL_CONFIG_LOAD_WITH_SILENCE_MODEL)
  370. u_Pro_Config.n_DHMM_Model_State_Num -= 2;
  372. return 0;
  373. }
  375. //////////////////////////////////////////////////////////////////////
  376. // 函数名称：DHMM_Model_Train_All_DHMM_Model
  377. // 函数功能：训练所有词的DHMM模型
  378. // 函数性质：API
  379. // 输入参数：
  380. // n_DHMM_Model_Num，要训练的模型个数
  381. // 输出参数：
  382. // pu_DHMM_Model，存放训好的DHMM模型
  383. // 返回值：
  384. // 0 表示成功
  385. // 备注：关于训练的细节参数，均在u_Pro_Config中指定，
  386. // n_Feature_Person_Num，总的语料库人数
  387. // n_DHMM_Model_Train_Set_Person_Num，训练集的人数
  388. // n_DHMM_Model_Person_Start_Index，训练集起始人的标号，
  389. // 训练集将从此人顺序持续指定人数，标号越界自动折返到0
  390. int DHMM_Model_Train_All_DHMM_Model(DHMM_MODEL * pu_DHMM_Model, int n_DHMM_Model_Num)
  391. {
  392. int nRetCode;
  393. char sz_Feature_File_Name[256];
  394. DYNA_2DIM_DOUBLE_ARRAY d2dda_Code_Book;
  395. WORD_SAMPLE * pu_Word_Sample;
  396. int n_Word_Sample_Index, n_Person_Index, n_Train_Set_Person_Index;
  398. // 读入码书
  399. d2dda_Code_Book = d2dda_New(u_Pro_Config.n_VQ_Code_Book_Size, u_Pro_Config.n_Feature_Dim);
  400. ASSERT(d2dda_Code_Book != NULL);
  401. nRetCode = DHMM_VQ_Load_Code_Book_File(u_Pro_Config.sz_Toload_Code_Book_File_Name,
  402. d2dda_Code_Book, u_Pro_Config.n_VQ_Code_Book_Size, u_Pro_Config.n_Feature_Dim);
  403. ASSERT(nRetCode == 0);
  405. ASSERT((0 <= u_Pro_Config.n_DHMM_Model_Person_Start_Index) && (u_Pro_Config.n_DHMM_Model_Person_Start_Index < u_Pro_Config.n_Feature_Person_Num)
  406. && (0 <= u_Pro_Config.n_DHMM_Model_Person_End_Index) && (u_Pro_Config.n_DHMM_Model_Person_End_Index < u_Pro_Config.n_Feature_Person_Num));
  408. // 为训练集的词条准备内存
  409. pu_Word_Sample = new WORD_SAMPLE[u_Pro_Config.n_DHMM_Model_Train_Set_Person_Num];
  410. ASSERT(pu_Word_Sample != NULL);
  412. // 该重循环，训练每一个词条的模型
  413. for (n_Word_Sample_Index = 0; n_Word_Sample_Index < u_Pro_Config.n_DHMM_Model_Num; n_Word_Sample_Index++)
  414. {
  415. int Sen_Index = n_Word_Sample_Index + u_Pro_Config.n_Sentence_Start_Index;
  416. // 该重循环，对一个词条，用所有训练集进行训练的数据准备
  417. n_Train_Set_Person_Index = 0;
  418. for (n_Person_Index = 0; n_Person_Index < u_Pro_Config.n_Feature_Person_Num; n_Person_Index++)
  419. {
  420. // 跳过测试集的人
  421. if (u_Pro_Config.n_DHMM_Model_Person_Start_Index <= u_Pro_Config.n_DHMM_Model_Person_End_Index)
  422. {
  423. if ((n_Person_Index < u_Pro_Config.n_DHMM_Model_Person_Start_Index) || (n_Person_Index > u_Pro_Config.n_DHMM_Model_Person_End_Index)) continue;
  424. }
  425. else
  426. {
  427. if ((n_Person_Index > u_Pro_Config.n_DHMM_Model_Person_End_Index) && (n_Person_Index < u_Pro_Config.n_DHMM_Model_Person_Start_Index)) continue;
  428. }
  430. // 准备该词条的内存空间
  431. sprintf(sz_Feature_File_Name, u_Pro_Config.sz_Feature_Origin_File_Name_Format, n_Person_Index);
  432. pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len = dfa_Feature_Get_Sentence_Frame_Num(sz_Feature_File_Name, Sen_Index);
  433. pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Dim = u_Pro_Config.n_Feature_Dim;
  434. pu_Word_Sample[n_Train_Set_Person_Index].d2dda_Feature_Sequence =
  435. d2dda_New(pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len, pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Dim);
  436. pu_Word_Sample[n_Train_Set_Person_Index].pn_VQed_Feature_Sequence = 
  437. new int[pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len];
  438. ASSERT((pu_Word_Sample[n_Train_Set_Person_Index].d2dda_Feature_Sequence  != NULL)
  439. && (pu_Word_Sample[n_Train_Set_Person_Index].pn_VQed_Feature_Sequence != NULL));
  441. // 读入特征参数
  442. nRetCode = dfa_Feature_Read_A_Sentence(sz_Feature_File_Name, Sen_Index, u_Pro_Config.n_Feature_Dim,
  443. pu_Word_Sample[n_Train_Set_Person_Index].d2dda_Feature_Sequence);
  444. ASSERT(nRetCode == pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len);
  446. // VQ特征
  447. DHMM_VQ_Encode_A_Word_Sample(d2dda_Code_Book, u_Pro_Config.n_VQ_Code_Book_Size, u_Pro_Config.n_Feature_Dim,
  448. &pu_Word_Sample[n_Train_Set_Person_Index]);
  450. // 释放原始的特征参数占用空间
  451. d2dda_Free(pu_Word_Sample[n_Train_Set_Person_Index].d2dda_Feature_Sequence,
  452. pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len, pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Dim);
  454. n_Train_Set_Person_Index++;
  455. }
  456. ASSERT(n_Train_Set_Person_Index == u_Pro_Config.n_DHMM_Model_Train_Set_Person_Num);
  458. PRO_LOG("Model:tTraining Model %4d of %4d.n", n_Word_Sample_Index, u_Pro_Config.n_DHMM_Model_Num);
  460. // 训练一个词条的模型
  461. DHMM_Model_Train_DHMM_Model(pu_Word_Sample, u_Pro_Config.n_DHMM_Model_Train_Set_Person_Num, &pu_DHMM_Model[n_Word_Sample_Index]);
  463. // 释放VQ后的特征占用的内存
  464. for (n_Train_Set_Person_Index = 0; n_Train_Set_Person_Index < u_Pro_Config.n_DHMM_Model_Train_Set_Person_Num; n_Train_Set_Person_Index++)
  465. {
  466. delete[] pu_Word_Sample[n_Train_Set_Person_Index].pn_VQed_Feature_Sequence;
  467. }
  468. }
  470. // 释放所有训练集的词条所占内存，释放码书内存
  471. delete[] pu_Word_Sample;
  472. d2dda_Free(d2dda_Code_Book, u_Pro_Config.n_VQ_Code_Book_Size, u_Pro_Config.n_Feature_Dim);
  474. return 0;
  475. }
  477. //////////////////////////////////////////////////////////////////////
  478. // 函数名称：DHMM_Model_Train_Silence_DHMM_Model
  479. // 函数功能：训练静音的单状态DHMM模型
  480. // 函数性质：API
  481. // 输入参数：
  482. // n_DHMM_Model_Num，要训练的模型个数
  483. // 输出参数：
  484. // pu_DHMM_Model，存放训好的DHMM模型
  485. // 返回值：
  486. // 0 表示成功
  487. // 备注：关于训练的细节参数，均在u_Pro_Config中指定，
  488. // n_Feature_Person_Num，总的语料库人数
  489. // n_DHMM_Model_Train_Set_Person_Num，训练集的人数
  490. // n_DHMM_Model_Person_Start_Index，训练集起始人的标号，
  491. // 训练集将从此人顺序持续指定人数，标号越界自动折返到0
  492. int DHMM_Model_Train_Silence_DHMM_Model(DHMM_MODEL * pu_DHMM_Model)
  493. {
  494. int nRetCode;
  495. char sz_Feature_File_Name[256];
  496. char sz_Silence_File_Name[256];
  497. DYNA_2DIM_DOUBLE_ARRAY d2dda_Code_Book;
  498. WORD_SAMPLE * pu_Word_Sample;
  499. int n_Word_Sample_Index, n_Person_Index, n_Train_Set_Person_Index;
  500. int n_DHMM_Model_Train_Set_Person_Num; 
  502. int     i, j/*, k,  n,  m*/;
  503. int  Status_num = 1;
  504. int     Output_num = u_Pro_Config.n_VQ_Code_Book_Size; // VQ码本大小（码字个数）
  505. double  *Pi; // 初始概率
  506. double  **A; // A矩阵：Status_num*Status_num
  507. double  **B; // B矩阵：Status_num*Output_num
  508. double  w;
  510. // Generate (A, B, Pi)
  511. Pi = pu_DHMM_Model->pdPi; // The above block transform to this line. #DongMing#
  513. // allocate memory for A matrix
  514. A = pu_DHMM_Model->d2dda_A; // The above block transform to this line. #DongMing#
  516. // allocate memory for B matrix
  517. B = pu_DHMM_Model->d2dda_B; // The above block transform to this line. #DongMing#
  519. // 初始化初始概率Pi:状态0概率为1，其余状态概率为0
  520. Pi[0] = 1;
  521. for(i=1; i<Status_num; i++) Pi[i] = 0;
  523. for(i=0; i<Status_num; i++)
  524. {
  525. // 初始化A矩阵
  526. for(j=0; j<Status_num; j++) A[i][j] = 0;
  527. if(i < Status_num-1)
  528. {
  529. A[i][i]   = 0.5;
  530. A[i][i+1] = 0.5;
  531. }
  532. else
  533. {
  534. A[i][i]   = 1.0;
  535. }
  536. // 归一化A矩阵
  537. w = 0;
  538. for(j=0; j<Status_num; j++) w = w + A[i][j];
  539. for(j=0; j<Status_num; j++) A[i][j] = A[i][j] / w;
  541. w = 0;
  542. // 初始化B矩阵
  543. for(j=0; j<Output_num; j++)
  544. {
  545. B[i][j] = 1.0 / Output_num * (0.9 + ((rand()%1000) / 5000.0));
  546. w = w + B[i][j];
  547. }
  548. // 归一化B矩阵
  549. for(j=0; j<Output_num; j++) B[i][j] = 0; //B[i][j] / w;
  550. }
  552. // 读入码书
  553. d2dda_Code_Book = d2dda_New(u_Pro_Config.n_VQ_Code_Book_Size, u_Pro_Config.n_Feature_Dim);
  554. ASSERT(d2dda_Code_Book != NULL);
  555. nRetCode = DHMM_VQ_Load_Code_Book_File(u_Pro_Config.sz_Toload_Code_Book_File_Name,
  556. d2dda_Code_Book, u_Pro_Config.n_VQ_Code_Book_Size, u_Pro_Config.n_Feature_Dim);
  557. ASSERT(nRetCode == 0);
  559. ASSERT((0 <= u_Pro_Config.n_DHMM_Model_Person_Start_Index) && (u_Pro_Config.n_DHMM_Model_Person_Start_Index < u_Pro_Config.n_Feature_Person_Num)
  560. && (0 <= u_Pro_Config.n_DHMM_Model_Person_End_Index) && (u_Pro_Config.n_DHMM_Model_Person_End_Index < u_Pro_Config.n_Feature_Person_Num));
  562. // 为训练集的词条准备内存
  563. pu_Word_Sample = new WORD_SAMPLE[u_Pro_Config.n_DHMM_Model_Train_Set_Person_Num * u_Pro_Config.n_DHMM_Model_Num];
  564. ASSERT(pu_Word_Sample != NULL);
  566. n_Train_Set_Person_Index = 0;
  567. // 该重循环，加载每一个词条的静音数据
  568. for (n_Word_Sample_Index = 0; n_Word_Sample_Index < u_Pro_Config.n_DHMM_Model_Num; n_Word_Sample_Index++)
  569. {
  570. int Sen_Index = n_Word_Sample_Index + u_Pro_Config.n_Sentence_Start_Index;
  571. // 该重循环，对一个词条，用所有训练集进行训练的数据准备
  572. for (n_Person_Index = 0; n_Person_Index < u_Pro_Config.n_Feature_Person_Num; n_Person_Index++)
  573. {
  574. // 跳过测试集的人
  575. if (u_Pro_Config.n_DHMM_Model_Person_Start_Index <= u_Pro_Config.n_DHMM_Model_Person_End_Index)
  576. {
  577. if ((n_Person_Index < u_Pro_Config.n_DHMM_Model_Person_Start_Index) || (n_Person_Index > u_Pro_Config.n_DHMM_Model_Person_End_Index)) continue;
  578. }
  579. else
  580. {
  581. if ((n_Person_Index > u_Pro_Config.n_DHMM_Model_Person_End_Index) && (n_Person_Index < u_Pro_Config.n_DHMM_Model_Person_Start_Index)) continue;
  582. }
  584. // 修改文件名
  585. sprintf(sz_Feature_File_Name, u_Pro_Config.sz_Feature_Origin_File_Name_Format, n_Person_Index);
  586. strcpy(sz_Silence_File_Name, sz_Feature_File_Name);
  587. int j = strlen(sz_Silence_File_Name) - 4;
  588. sz_Silence_File_Name[j] = '';
  589. strcat(sz_Silence_File_Name,"_sl.dat");
  591. // 准备该词条的内存空间
  592. pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len = dfa_Feature_Get_Silence_Frame_Num(sz_Silence_File_Name, Sen_Index);
  593. //pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len = 2 * RELAX_FRAME;
  594. pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Dim = u_Pro_Config.n_Feature_Dim;
  595. pu_Word_Sample[n_Train_Set_Person_Index].d2dda_Feature_Sequence =
  596. d2dda_New(pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len, pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Dim);
  597. pu_Word_Sample[n_Train_Set_Person_Index].pn_VQed_Feature_Sequence = 
  598. new int[pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len];
  599. ASSERT((pu_Word_Sample[n_Train_Set_Person_Index].d2dda_Feature_Sequence  != NULL)
  600. && (pu_Word_Sample[n_Train_Set_Person_Index].pn_VQed_Feature_Sequence != NULL));
  602. // 读入特征参数
  603. nRetCode = dfa_Feature_Read_A_Silence(sz_Silence_File_Name, Sen_Index, u_Pro_Config.n_Feature_Dim,
  604. pu_Word_Sample[n_Train_Set_Person_Index].d2dda_Feature_Sequence);
  605. ASSERT(nRetCode == pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len);
  607. // VQ特征
  608. DHMM_VQ_Encode_A_Word_Sample(d2dda_Code_Book, u_Pro_Config.n_VQ_Code_Book_Size, u_Pro_Config.n_Feature_Dim,
  609. &pu_Word_Sample[n_Train_Set_Person_Index]);
  611. // 释放原始的特征参数占用空间
  612. d2dda_Free(pu_Word_Sample[n_Train_Set_Person_Index].d2dda_Feature_Sequence,
  613. pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Sequence_Len, pu_Word_Sample[n_Train_Set_Person_Index].n_Feature_Dim);
  615. n_Train_Set_Person_Index++;
  616. }
  617. }
  619. PRO_LOG("Model:tTraining Silence Model...n");
  620.     n_DHMM_Model_Train_Set_Person_Num = n_Train_Set_Person_Index;
  622. int fr_num;
  624. for(i = 0; i < n_DHMM_Model_Train_Set_Person_Num; i++)
  625. {
  626. fr_num = pu_Word_Sample[i].n_Feature_Sequence_Len;
  627. for(j = 0; j < fr_num; j++)
  628. B[0][pu_Word_Sample[i].pn_VQed_Feature_Sequence[j]]++;
  629. }
  631. // 释放VQ后的特征占用的内存
  632. for (n_Train_Set_Person_Index = 0; n_Train_Set_Person_Index < n_DHMM_Model_Train_Set_Person_Num; n_Train_Set_Person_Index++)
  633. {
  634. delete[] pu_Word_Sample[n_Train_Set_Person_Index].pn_VQed_Feature_Sequence;
  635. }
  637. for(i = 0; i < Output_num; i++)
  638. {
  639. B[0][i] /= (fr_num * n_DHMM_Model_Train_Set_Person_Num);
  640. if (B[0][i] < Epsilon_B)
  641. B[0][i] = Epsilon_B;
  642. }
  644. for(j=0; j<Output_num; j++)
  645. w = w + B[0][j];
  646. // 归一化B矩阵
  647. for(j=0; j<Output_num; j++) B[0][j] = B[0][j] / w;
  651. // 释放所有训练集的词条所占内存，释放码书内存
  652. delete[] pu_Word_Sample;
  653. d2dda_Free(d2dda_Code_Book, u_Pro_Config.n_VQ_Code_Book_Size, u_Pro_Config.n_Feature_Dim);
  655. return 0;
  656. }
  658. //////////////////////////////////////////////////////////////////////
  659. // 函数名称：DHMM_Model_Train_DHMM_Model
  660. // 函数功能：训练一个词的DHMM模型
  661. // 函数性质：API
  662. // 输入参数：
  663. // pu_Word_Sample，存放该词训练集的数据
  664. // n_Word_Sample_Num，训练集的词数
  665. // 输出参数：
  666. // pu_DHMM_Model，存放训好的DHMM模型
  667. // 返回值：
  668. // 0 表示成功
  669. // 备注：WORD_SAMPLE的定义，参见公共的.H文件
  670. // 该函数是一个分发函数，按照u_Pro_Config.l_DHMM_Model_Config配置的信息
  671. // 将具体调用不同的函数体
  672. int DHMM_Model_Train_DHMM_Model(WORD_SAMPLE * pu_Word_Sample, int n_Word_Sample_Num,
  673. DHMM_MODEL * pu_DHMM_Model)
  674. {
  675. switch (u_Pro_Config.l_DHMM_Model_Config & MODEL_CONFIG_TRAIN_PROCEDURE_MASK)
  676. {
  677. case MODEL_CONFIG_TRAIN_PROCEDURE_STD:
  678. ASSERT(0);
  679. break;
  680. case MODEL_CONFIG_TRAIN_PROCEDURE_GL:
  681. return DHMM_Model_Train_DHMM_Model_GL(pu_Word_Sample, n_Word_Sample_Num, pu_DHMM_Model);
  682. break;
  683. case MODEL_CONFIG_TRAIN_PROCEDURE_LHS:
  684. ASSERT(0); //LHS的训练过程，与GL的完全相同，故略去
  685. break;
  686. case MODEL_CONFIG_TRAIN_PROCEDURE_HQ:
  687. return DHMM_Model_Train_DHMM_Model_HQ(pu_Word_Sample, n_Word_Sample_Num, pu_DHMM_Model);
  688. break;
  689. case MODEL_CONFIG_TRAIN_PROCEDURE_WP:
  690. ASSERT(0);
  691. break;
  692. default:
  693. ASSERT(0);
  694. break;
  695. }
  697. return 0;
  698. }