利用HMM的孤立字词语音识别系统.docx
《利用HMM的孤立字词语音识别系统.docx》由会员分享，可在线阅读，更多相关《利用HMM的孤立字词语音识别系统.docx（17页珍藏版）》请在冰豆网上搜索。
利用HMM的孤立字词语音识别系统
利用HMM的孤立字（词）语音识别系统
/*************************************************************************/
/*文件名称：
recog.cpp（主程序）*/
/****************************************************************************/
#include"emhmm.h"
intBR_Disp[MAX_ARCS];/*Displaymenttosavemultiplies（branch_prob）*/
intME_Disp[MAX_ARCS];/*Displaymenttosavemnltiplies（mean）*/
intCO_Disp[MAX_ARCS];/*Displaymenttosavemultiplies（covariance）*/
intTrain_Disp[MAX_ARCS+MAX_STATES];/*reallyonlyneedmax（ma,ms）*/
imNum_Dimensions;
intNum_Train_Sets;/*Sizeofdimensionoftrainingdata*/
intTotal_Frames;
intLongest_Train;/*thelengthofthelongesttrainingset*/
TRAININGTrain[MAX-_TRAIN_SIZE];
HMMHmm[MAX_REF];
main（argc,argv）
intargc;
char*argv[];
{
inti,num_ref,result;
intcnt[MAX_REF];
stringhmm_file;
char*infile=NULL,*ref_list=NULL;
charch_r[MAX_REF][8];
FILE*fp;
/****************
*命令行参数设置*
***************/
if（argc<5）
usage（argv[0]）;
for（i=1;iif（argv[i][0]!
='-'）{
fprinff（stderr,"Illegalswitch%s\n",argv[i]）;
usage（amv[0]）;
}
switch（argv[i]）[1]）;
}
case'h':
ref_list=argv[++i];
break;
case'i':
in_file=argv[++i];
break;
default:
fprimf（stderr,"Illegalswitch%s\n',argv[i]）;
usage（argv[0]）;
break;
}
}
/****************************
*读取参考模型的数量，即词表的大小*
****************************/
if（（fp=fopen（ref_list,"r"））==NULL）{
fprinff（stderr,"%s:
can'topen%storead.\n',ref_list）;
exit（0）;
}
fscanf（fp,'%d',&num_ref）;
/************
*读取模型的参数*
***********/
for（i=0;icnt[i]=0;
fscanf（fp,"%s%s",hmm_file,ch_r[i]）;
read_hmm（hmm_file,i）;
cal_invdet（i）;
}
fclose（fp）;
pfintf（"Categorysize:
%d\n',hum_ref）;
/***************
*读取待识别语音的数据*
*****************/
if（（Num_Train_Sets=read_training（in_file））>MAX_TRAIN_SIZE）{
fprintf（stderr,'%s:
toomanytestpatternsin%s.\n",argv[0],in_file）;
exit（0）;
}
/**********
*识别*
*********/
for（i=0;iresult=dp（Train+i,numref）;
++cnt[result];
#ifTRACE
printf（"[%3d]%3d:
%s\n",i+1,Train[i].length,ch_r[result]）;
fflush（stdout）;
#endif
free（Train[i].data）;
}
printf（"###识别结果###"）；
for（i=0;iprintf（"###/%4s/=%6.2f%%\n",ch_r[i],cnt[i]*100.0/Num_Train_Sets）;
}
/*****************************************************************/
/*函数名称：
usage
/*函数功能：
提示信息，并退出程序*/
/*输入函数：
obj-指向提示信息的指针*/
/****************************************************************/
usage（obj）
char*obj;
{
fprintf（stderr,"Useage:
%s-hHMM-list-iinput-file\n",obj）;
exit（0）;
}
文件名称：
（CMHMM的输入输出函数）
#include"cmhmm.h"
#include
externintBR_Disp[],ME_Disp[],CO_Disp[],Train_Disp[];
externintTotal_Frames;
externintNum_Dimensions,Longest_Train;
externTRAININGTrain[];
externHMMHmm[];
voidread_hmm（char*file,intrnum）
{
FILE*fp;
inttemp,i,j,k,num,mat_num,from,to,bdisp,mdisp,cdisp;
floattrans_prob;
if（（fp=fopen（file,"r"））==NULL）
exit（0）;
if（fscanf（fp,"%d",&Num_Dimensions）==EOF）
exit（0）;
if（fscanf（fp,"%d",&temp）==EOF）
exit（0）;
Hmm[rnum].num_omatrix=temp;
if（fscanf（fp,"%d",&temp）==EOF）
exit（0）;
Hmm[rnum].num_mixture=temp;
for（i=0;i{
temp=i*Hmm[rnum].num_mixture;
BR_Disp[i]=temp;
temp*=Num_Dimensions;
ME_Disp[i]=temp;
temp*=Num_Dimensions;
CO_Disp[i]=temp;
}
temp=FLOATSIZE*Hmm[rnum].num_omatrix*Hmm[rnum].num_mixture;
if（（Hmm[rnum].branch_prob=（float*）malloc（temp））==NULL）
exit（0）;
temp*=Num_Dimensions;
if（（Hmm[rnum].mean=（float*）malloc（temp））==NULL）
exit（0）;
temp*=Num_Dimensions;
if（（Hmm[rnum].covariance=（float*）malloc（temp））==NULL）
exit（0）;
for（i=0;i{
bdisp=BR_Disp[i];
for（j=0;j{
if（fscanf（fp,"%f",Hmm[rnum].branch_prob+bdisp+j）==EOF）
exit（0）;
}
for（temp=0,j=0;j{
mdisp=ME_Disp[i]+temp;
cdisp=CO_Disp[i]+temp*Num_Dimensions;
for（k=0;k{
if（fscanf（fp,"%f",Hmm[rnum].mean+mdisp+k）==EOF）
exit（0）;
}
for（k=0;k{
if（fscanf（fp,"%f",Hmm[rnum].covariance+cdisp+k）==EOF）
exit（0）;
}
}
}
if（fscanf（fp,"%d",&temp）==EOF）exit（0）;
Hmm[rnum].num_states=temp;
if（（Hmm[rnum].states=（STATE*）malloc（sizeof（STATE）*Hmm[rnum].num_states））==NULL）exit（0）;
for（i=0;i{
Hmm[rnum].states[i].label=i;
Hmm[rnum].states[i].num_from=Hmm[rnum].states[i].num_to=0;
Hmm[rnum].states[i].is_initial=Hmm[rnum].states[i].is_final=FALSE;
}
if（fscanf（fp,"%d",&temp）==EOF）exit（0）;
Hmm[rnum].num_initial=temp;
for（i=0;i{
if（fscanf（fp,"%d",&num）==EOF）exit（0）;
Hmm[rnum].states[num].is_initial=TRUE;
}
if（fscanf（fp,"%d",&temp）==EOF）exit（0）;
Hmm[rnum].num_final=temp;
for（i=0;i{
if（fscanf（fp,"%d",&num）==EOF）exit（0）;
Hmm[rnum].states[num].is_final=TRUE;
}
if（fscanf（fp,"%d",&temp）==EOF）exit（0）;
Hmm[rnum].num_arcs=temp;
if（（Hmm[rnum].transitions=（TRANSITION*）malloc（sizeof（TRANSITION）*\
Hmm[rnum].num_arcs））==NULL）exit（0）;
for（i=0;i{
if（fscanf（fp,"%d%d%e%d",&from,&to,&trans_prob,&mat_num）==EOF）exit（0）;
if（（mat_num>=Hmm[rnum].num_omatrix）||（（mat_num<0）&&（mat_num!
=NULL_TRANSITION）））exit（0）;
if（（from>Hmm[rnum].num_states-1）||（from<0）||（to>Hmm[rnum].num_states-1）||（to<0））
{
fprintf（stderr,"read_hmm:
Illegalfrom（%d）-to（%d）\n",from,to）;
exit（0）;
}
if（trans_prob<=0.0）exit（0）;
Hmm[rnum].transitions[i].trans_prob=log（trans_prob）;
Hmm[rnum].transitions[i].origin=from;
Hmm[rnum].transitions[i].destination=to;
Hmm[rnum].transitions[i].out_prob_index=mat_num;
Hmm[rnum].states[from].trans_from[Hmm[rnum].states[from].num_from++]=i;
Hmm[rnum].states[to].trans_to[Hmm[rnum].states[to].num_to++]=i;
}
if（fscanf（fp,"%*d"）!
=EOF）exit（0）;
fclose（fp）;
}
intread_training（char*f_list）
{
FILE*fp,*fs;
intcnt,i,j,k,length,total_length=0,max=0;
intm;
stringf_name;
floatbuff[100];
if（Num_Dimensions>100）exit（0）;
if（（fs=fopen（f_list,"r"））==NULL）
{
fprintf（stderr,"red_data:
can'topen%storead\n",f_list）;
exit（0）;
}
for（cnt=0;fscanf（fs,"%s",f_name）!
=EOF;++cnt）
{
if（cnt==MAX_TRAIN_SIZE）
{
printf（"Warninginread_data:
numberofdatasets（%s）isforcedinto%d.\n",f_list,\
MAX_TRAIN_SIZE）;
fflush（stdout）;
break;
}
if（（fp=fopen（f_name,"rb"））==NULL）exit（0）;
for（length=0;（m=fread（buff,FLOATSIZE,（Num_Dimensions+1）,fp））==（Num_Dimensions+1）;++length）;
if（（Train[cnt].data=（float*）malloc（FLOATSIZE*Num_Dimensions*length））==NULL）
{
fprintf（stderr,"read_data:
notenoughspacefor%s\n",f_list）;
exit（EOF）;
}
rewind（fp）;
for（i=j=0;（m=fread（buff,FLOATSIZE,（Num_Dimensions+1）,fp））==（Num_Dimensions+1）;++i）
for（k=1;k<（Num_Dimensions+1）;）
Train[cnt].data[j++]=100.0*buff[k++];
fclose（fp）;
if（length!
=1）
{
fprintf（stderr,"read_data:
sizemissmatch（%d!
=%d）\n",length,i）;exit（EOF）;
}
Train[cnt].length=length;
total_length+=length;
if（length>max）max=length;
}
fclose（fs）;
Total_Frames=total_length;
Longest_Train=max;
for（i=j=0;jTrain_Disp[j]=i;
printf（"Trainingdatalist:
%s[%ddatasets]\n",f_list,cnt）;
returncnt;
}
文件名称：
cmhmmdp.cpp
#include"cmhmm.h"
externintBR_Disp[],ME_Disp,CO_Dsip[],Train_Disp[];
externintNum_Dimensions,Num_Train_Sets,Longest_Train;
externTRAININGTrain[];
externHMMHmm[];
externdouble*Inv_Covariance[],*Det_Covariance[];
float*date;
/***************************************************************************/
/*函数名称：
dp*/
/*函数功能：
计算任一特征向量序列输入到各个HMM时的输出频率，并返回有最大输出概率的*/
/*HMM的序列*/
/*输入参数：
train-输入的特征响亮序列；num-ref—词表的大小*/
/*返回值：
返回有最大输出概率的HMM的序号。
*/
/***************************************************************************/
intdp（TRAINING*train,intnum_ref）
{
char*stop,*cptr;
inti,j,k,l,m,n,t;
intlength,index,x;
intout,lx,nhat;
intOutprob_Disp[MAX_STATES];
double*outprob_buff,oprob;
doubleout_prob,banch_prob,sum_prob;
double*pn,*prev_pn,px,p[MAX_REF];
TRAINSITION*tptr;
length=train->length;
data=train->data;
/*memoryallocationforwork*/
if（（pn=（double*）malloc（Longest_Train*MAX_STATES*DOUBLEESIZE））==NULL）
exit（0）;
if（（outprob_buff=（double*）malloc（（Longest_Train）*MAX_ARCS*DOUBLESIZE））==NULL）
exit（0）;
for（s=i=0;sfor（n=0;ns=MAX_STATES*Longest_Train;
for（i=0;ifor（s=0;sif（Hmm[n].states[s].is_initial）
pn[Train_Disp[s]]=0.0;
}
for（i=0;ifor（s=0;sfor（i=0;isum_prob=0.0;
for（j=0;jbranch_prob=Humm[n].branch_prob[BR_disp[s]+j];
if（branch_prob==0.0）continue;
sum_prob+=pow（branch_prob,5.0）*cal_outprob（&（Humm[n]）,n,s,i,j）;
}
outprob_buff[Outprob_Disp[s]+i]=log（sum_prob）;
}
}
for（i=0;ifor（s=0;sindex=Train_Disp[s]+i;
stop=&（Humm[n].states[s].trans_to[Humm[n].states[s].num_to]）;
for（cptr=&（Humm[n].states[s].trans_to[0]）;cptrtptr=&（Humm[n].transitions[*cptr]）;
px=INFINIT;
if（tptr->out_prob_index==NULL_TRANSITION）{
prev_pn=pn+（Train_Disp[tptr->origin]+i）;
if（*prev_pn>INFINIT）
px=
升级会员 