HTK中Lattice词格的结构

最新推荐文章于 2021-06-15 16:37:34 发布
最新推荐文章于 2021-06-15 16:37:34 发布
阅读量435 收藏
点赞数
分类专栏： 语音识别 文章标签： HTK Lattice词格 词网络结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjx5200/article/details/117335721
版权

Lattice是非常重要的数据结构，它是语音识别系统支持的高层次的抽象语法。一般由定义的gram生成。

typedef struct lattice
{
   MemHeap *heap;               /* Heap lattice uses */
   LatFormat format;	       	/* indicate which fields are valid */
   Vocab *voc;                  /* Dictionary lattice based on */

   int nn;                      /* Number of nodes */
   int na;                      /* Number of arcs */
   LNode *lnodes;               /* Array of lattice nodes */
   LArc *larcs;                 /* Array of lattice arcs */

   LabId subLatId;              /* Lattice Identifier (for SubLats only) */
   SubLatDef *subList;          /* List of sublats in this lattice level */
   SubLatDef *refList;          /* List of all SubLats referring to this lat */
   struct lattice *chain;       /* Linked list used for various jobs */

   char *utterance;		/* Utterance file name (NULL==unknown) */
   char *vocab;			/* Dictionary file name (NULL==unknown) */
   char *hmms;			/* MMF file name (NULL==unknown) */
   char *net;			/* Network file name (NULL==unknown) */

   float acscale;       /* Acoustic scale factor */
   float lmscale;		/* LM scale factor */
   LogFloat wdpenalty;		/* Word insertion penalty */
   float prscale;		/* Pronunciation scale factor */
   HTime framedur;      /* Frame duration in 100ns units */
   float logbase;       /* base of logarithm for likelihoods in lattice files
                                   (1.0 = default (e), 0.0 = no logs) */
   float tscale;        /* time scale factor (default: 1, i.e. seconds) */

   Ptr hook;            /* User definable hook */
}
Lattice;

这个lattice应该包含哪些信息，才能完整的描述一个词格网络。得有字典对象（它的wtab包含了所有词）、节点信息、边的信息（个数和实体列表），得包含从哪些信息得到这个词格网络的，有utterance文件名、发音字典文件名、描述HMM的文件名，还有描述Netword的文件名。

函数ReadOneLattice返回一个Lattice的指针。这个函数里，首选会读取Net文件中有多少个节点N=（nn）和多少个边L=（na），然后构建一个空的Lattice。为lattice的lnodes和larcs分配合适的空间（依赖nn和na）。然后依次读取文件，并且把节点和边的标号作为下标来访问（不重要，这是C语言特性决定的）。

/* ReadOneLattice: Read (one level) of lattice from file */
Lattice *ReadOneLattice(Source *src, MemHeap *heap, Vocab *voc, 
                               Boolean shortArc, Boolean add2Dict)
{
   int i,s,e,n,v=0,nn,na;
   Lattice *lat;
   LNode *ln;
   LArc *la;
   Word wordId;
   double time,aclike,lmlike;
   double prlike;
   char nbuf[132],vbuf[132],*ptr,ntype,del;
#define DBUFLEN 4096
   char dbuf[DBUFLEN];
   double lmscl=1.0, lmpen=0.0, acscl=1.0, prscl=1.0;
   float logbase = 1.0, tscale = 1.0;

   char *uttstr,*lmnstr,*vocstr,*hmmstr,*sublatstr,*tag;
   SubLatDef *subLatId = NULL;

   lat = (Lattice *) New(heap,sizeof(Lattice));
   lat->heap=heap; lat->subLatId=NULL; lat->chain=NULL;
   lat->voc=voc; lat->refList=NULL; lat->subList=NULL;

   /* Initialise default header values */
   nn=0;na=0; uttstr=lmnstr=vocstr=hmmstr=sublatstr=NULL;
   /* Process lattice header */
   while((ptr=GetNextFieldName(nbuf,&del,src))) {
      if (nbuf[0]=='\n') {
         if (na != 0 && nn != 0) break;
      }
      else if (strlen(ptr)==1) {
         ntype=*ptr;
         switch(ntype) {
         case 'N':
            nn=GetIntField('N',del,vbuf,src);
            break;
         case 'L':
            na=GetIntField('L',del,vbuf,src);
            break;
         default:
            GetFieldValue(0,src,0);
            break;
         }
      }
      else {
         if (!strcmp(ptr,"UTTERANCE"))
            GetFieldValue(vbuf,src,0),uttstr=CopyString(heap,vbuf);
         // 其他无关代码
         else
            GetFieldValue(NULL,src,0);
      }
   }

   /* Initialise lattice based on header information */
   lat->nn=nn;
   lat->na=na;
   lat->utterance=uttstr;lat->vocab=vocstr;lat->hmms=hmmstr;
   lat->net=lmnstr;lat->lmscale=lmscl;lat->wdpenalty=lmpen;
   lat->acscale = acscl;
   lat->logbase = logbase;
   lat->tscale = tscale;
   lat->framedur=0;
   lat->prscale=prscl;

   /* Presence of SUBLAT=id string indicates more to come */
   lat->subList=NULL; lat->chain=NULL;
   if (sublatstr!=NULL) lat->subLatId = GetLabId(sublatstr,TRUE);
   else lat->subLatId = NULL;

   /* Allocate and initiailise nodes/arcs */
   lat->lnodes=(LNode *) New(heap, sizeof(LNode)*nn);
   if (shortArc) 
      lat->larcs=(LArc *) New(heap, sizeof(LArc_S)*na);
   else 
      lat->larcs=(LArc *) New(heap, sizeof(LArc)*na);

   for(i=0, ln=lat->lnodes; i<nn; i++, ln++) {
      ln->hook=NULL;
      ln->pred=NULL;
      ln->foll=NULL;
      ln->score=0.0;
   }
   for(i=0, la=lat->larcs; i<na; i++, la=NextLArc(lat,la)) {
      la->lmlike=0.0;
      la->start=la->end=NNODE;
      la->farc=la->parc=NARC;
   }

   // 其他代码

    return lat;
}

这个函数太长了，我分段解析。现在这个函数将返回仅仅构建一个nn个LNode和na个LArc的lattice，其值都为NULL。也就是读取了下面Net文件的头两行。

看一下Net的大体格式。

VERSION=1.0
N=31   L=62   
I=0    W=SENT-END            
I=1    W=YOUNG               
I=2    W=!NULL               
I=3    W=STEVE               
I=4    W=LEE                 
I=5    W=PHIL                
I=6    W=WOOD                
I=7    W=DAVE                
I=8    W=TYLER               
I=9    W=JULIAN              
I=10   W=LAW                 
I=11   W=SUE                 
I=12   W=CALL                
I=13   W=!NULL               
I=14   W=PHONE               
I=15   W=ZERO                
I=16   W=!NULL               
I=17   W=OH                  
I=18   W=NINE                
I=19   W=EIGHT               
I=20   W=SEVEN               
I=21   W=SIX                 
I=22   W=FIVE                
I=23   W=FOUR                
I=24   W=THREE               
I=25   W=TWO                 
I=26   W=ONE                 
I=27   W=DIAL                
I=28   W=SENT-START          
I=29   W=!NULL               
I=30   W=!NULL               
J=0     S=2    E=0    
J=1     S=16   E=0    
J=2     S=3    E=1    
J=3     S=13   E=1    
J=4     S=1    E=2    
J=5     S=4    E=2    
J=6     S=6    E=2    
J=7     S=8    E=2    
J=8     S=10   E=2    
J=9     S=13   E=3    
J=10    S=5    E=4    
J=11    S=13   E=4    
J=12    S=13   E=5    
J=13    S=7    E=6    
J=14    S=13   E=6    
J=15    S=13   E=7    
J=16    S=9    E=8    
J=17    S=13   E=8    
J=18    S=13   E=9    
J=19    S=11   E=10   
J=20    S=13   E=10   
J=21    S=13   E=11   
J=22    S=28   E=12   
J=23    S=12   E=13   
J=24    S=14   E=13   
J=25    S=28   E=14   
J=26    S=16   E=15   
J=27    S=27   E=15   
J=28    S=15   E=16   
J=29    S=17   E=16   
J=30    S=18   E=16   
J=31    S=19   E=16   
J=32    S=20   E=16   
J=33    S=21   E=16   
J=34    S=22   E=16   
J=35    S=23   E=16   
J=36    S=24   E=16   
J=37    S=25   E=16   
J=38    S=26   E=16   
J=39    S=16   E=17   
J=40    S=27   E=17   
J=41    S=16   E=18   
J=42    S=27   E=18   
J=43    S=16   E=19   
J=44    S=27   E=19   
J=45    S=16   E=20   
J=46    S=27   E=20   
J=47    S=16   E=21   
J=48    S=27   E=21   
J=49    S=16   E=22   
J=50    S=27   E=22   
J=51    S=16   E=23   
J=52    S=27   E=23   
J=53    S=16   E=24   
J=54    S=27   E=24   
J=55    S=16   E=25   
J=56    S=27   E=25   
J=57    S=16   E=26   
J=58    S=27   E=26   
J=59    S=28   E=27   
J=60    S=30   E=28   
J=61    S=0    E=29   

 

可以看出来，我们这次提供的Net有31个节点，62条边。ReadOneLattice函数会逐一把这些节点和边构建到Lattice中，并且关联起来，形成一个图。从一个节点，可以找到连接它的所有边，再由这些边找到它们的起点和终点。

typedef struct lnode
{
   int n;              /* Sorted order */

   Word word;          /* Word represented by arc (labels may be on nodes) */
   char *tag;          /* Semantic tag for this node */
   short v;            /* Pronunciation variant number */
   SubLatDef *sublat;  /* SubLat for node (if word==lat->voc->subLatWord) */

   HTime time;         /* Time of word boundary at node */

   ArcId foll;         /* Linked list of arcs following node */
   ArcId pred;         /* Linked list of arcs preceding node */

   double score;       /* Field used for pruning */

   Ptr hook;           /* User definable hook */
}
LNode;

看一下这个节点的结构，包含它指向的Word，指向它的所有边pred和它出去的所有边foll。

再看一下边的结构：

typedef struct larc
{
   NodeId start;       /* Node at start of word */
   NodeId end;         /* Node at end of word */
   LogFloat lmlike;    /* Language model likelihood of word */

   ArcId farc;         /* Next arc following start node */
   ArcId parc;         /* Next arc preceding end node */

   LogFloat aclike;    /* Acoustic likelihood of word */

   short nAlign;       /* Number of alignment records in word */
   LAlign *lAlign;     /* Array[0..nAlign-1] of alignment records */

   float score;        /* Field used for pruning/sorting */
   LogFloat prlike;    /* Pronunciation likelihood of arc */
}
LArc;

包含的信息有：边的开始节点、结束节点、开始节点的输出边farc和结束节点的输入边parc。

Net文件里指定边与节点的连接信息，通过这些可以构建lattice的LNode和LArc之间的关系。

   do {
      if ((ptr=GetNextFieldName(nbuf,&del,src)) == NULL)
         break;
      /* Recognised line types have only one character names */
      if (strlen(ptr)==1) 
         ntype=*ptr;
      else 
         ntype=0;
      if (ntype == '.') {
         ptr = NULL;
         break;
      }
      switch(ntype) {
      case '\n': break;
      case 'I':
         n=GetIntField('I',del,vbuf,src);
         ln=lat->lnodes+n;
         time=0.0;wordId=voc->nullWord;tag=NULL;v=-1;
         while((ptr=GetNextFieldName(nbuf,&del,src)) != NULL) {
            if (nbuf[0]=='\n') break;
            else {
               if (strlen(ptr)>=1) 
                  ntype=*ptr;
               else 
                  ntype=0;
               switch(ntype) {
               case 't':
                  time=GetFltField('t',del,vbuf,src);
                  time *= tscale;
                  lat->format |= HLAT_TIMES;
                  break;
               case 'W':
                  GetFieldValue(vbuf,src,0);
                  wordId=GetWord(voc,GetLabId(vbuf,add2Dict),add2Dict);
                  if (wordId==NULL){
                     Dispose(heap, lat);
                     HRError(8251,"ReadLattice: Word %s not in dict",vbuf);
                     return(NULL);
                  }
                  break;
               default:
                  GetFieldValue(0,src,0);
                  break;
               }
            }
         }
         if (wordId != voc->nullWord)
            lat->format &= ~HLAT_ALABS;
         ln->time=time;
         ln->word=wordId;
         ln->tag=tag;
         ln->v=v;
         if (wordId == voc->subLatWord)
            ln->sublat = subLatId;
         else
            ln->sublat = NULL;
         ln->hook=ln;
         nn--;
         break;
      case 'J':
         n=GetIntField('I',del,vbuf,src);
         la=NumbLArc(lat,n);
         s=e=v=-1; wordId=NULL; aclike=lmlike=0.0;
         prlike=0.0;
         while ((ptr=GetNextFieldName(nbuf,&del,src))) {
            if (nbuf[0]=='\n') break;
            else {
               if (strlen(ptr)>=1) ntype=*ptr;
               else ntype=0;
               switch(ntype)
                  {
                  case 'S':
                     s=GetIntField('S',del,vbuf,src);
                     break;
                  case 'E':
                     e=GetIntField('E',del,vbuf,src);
                     break;                
                  default:
                     GetFieldValue(0,src,0);
                     break;
                  }
            }
         }
         la->start=lat->lnodes+s;
         la->end=lat->lnodes+e;
         la->lmlike=lmlike;
           
         if ((lat->format&HLAT_ALABS) && la->end->word == voc->nullWord){
            la->end->word=wordId;
			la->end->v = v;
		 }

         la->farc=la->start->foll;
         la->parc=la->end->pred;
         la->start->foll=la;
         la->end->pred=la;
         if (!shortArc) {
            la->aclike=aclike;
            la->prlike=prlike;
         }
         na--;
         break;
      default:
         GetFieldValue(0,src,0);
         while ((ptr=GetNextFieldName(nbuf,&del,src))) {
            if (nbuf[0]=='\n') break;
            else GetFieldValue(0,src,0);
         }
         break;
      }
   }
   while(ptr != NULL);

这个循环代码，就是处理Net中接下来的所有行信息。根据首字母是“I”还是“J”来判断建立LNode还是LArc，并通过“=”后面的序号，从lat的lnodes和larcs序列中索引相应的节点和边对象，然后填充信息。

hjx5200
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HTK中的数据结构的关系
10-30
用Visio画的数据结构的示意图，希望对理解HTK源码有帮助。涉及HMMSet、HMMDef、StateElem、StateInfo、StreamElem、MixtureElem、MixPDF等，还有UttInfo、Transcription、Observation和它们之间的组合/包含关系。
HTK standard lattice format
程序的魅力
06-28 143
这个格式描述了HTK词网络，主要包含两部分，头部和节点/边定义。 在头部，主要包含版本信息，以及该词网络包含多少个节点和多少条边，分别以字母N和L表示。 在body部分，分别定义节点的编号和词本体信息；边的编号以及边的起点和终点信息，可选的有语言模型的分数。 下面是典型的SLF文件格式。 VERSION=1.0 N=31 L=62 I=0 W=SENT-END I=1 W=YOUNG I=2 W=!NULL
MFE常用数据结构之Lattice
tzy的专栏
05-24 2217
今天看了DUFFY的C++ For FE中关于介绍Lattice的相关内容，为了表示对原作者的尊敬，首先我还是引用一下作者关于Lattice Structures的介绍的原话。 "Lattice structures are well known in quantitative finance.“ 对，没错，原话就这么短。也许是太出名了吧，不需要过多赘述。不过我发现一个奇怪的现象就是在实现这个
lattice
qq_14962179的博客
03-02 2290
lattice 在实际的语音识别系统中，最优路径不一定与实际字序列匹配，我们一般希望能够得到得分最靠前的多条候选路径，即N-best。为了紧凑地保存候选路径，我们一般采用lattice(词图)来保存识别的候选序列。lattice本质上是一个有向无环图。图上的每个节点代表一个词的结束时间点，每条边代表一个可能的词，以及该词发生的声学得分和语言模型得分。 在生成one-best结果时，只需要从最优...
Lattice的构建过程
程序的魅力
06-03 466
我有一张地图，叫Lattice。 它有多个成员叫LNode，数量是nn，成员之间有各种联系叫LArc，也有很多个na。
Lattice学习总结中……
乐观开朗，积极向上
09-05 2375
1.Lattice官网：http://www.latticesemi.com/ 2.需要注册一下（sign in）：按要求填写一下 3.注册完之后，在官网的首页，Products--下载Lattice的设计环境：ispLEVER classic 4.在Licesing处：首先获取自己电脑12位16进制的MAC物理地址（运行--cmd--ipconfig/all）；根据提示将其输入，获取激活邮
HTK中Network的结构
程序的魅力
06-15 142
Network是由lattice扩展而来的。除了依赖lattice，还有HMMSet、pronunciation等。 在lattice中，每个节点是由一个Word指向一个DictEntry
HTK中的那些哈希表
程序的魅力
06-02 145
第一个介绍的是LabId的hashtable #define HASHSIZE 250007 /* size of hash table */ static NameCell *hashtab[HASHSIZE]; /* the actual table */ 一般HTK中的h
HTKbook翻译之第十二章网络、词典及语言模型
程序的魅力
11-11 675
第十二章 网络、词典及语言模型 前几章描述了如何处理语音数据和训练各种HMM模型参数。本章及后面几章将集中描述如何通过HTK工具构建语音识别器。本章聚焦在网络和字典。一个词级网络描述了一系列可能被识别的词；对子词（sub word）模型而言，词典描述了构成每个词的系列子词。词级网络的典型代表是通过任务语法（Task Grammar）显示定义的所有合法词序列，或者一个“词循环（Word-loop）”，即把所有词放置于一个循环中，允许任意词之间相连接。词循环网络通常会被扩展会随机语言模型。网络还可以.
HTK中vocab的节点种类
程序的魅力
06-03 245
分三种: 一是nullWord，它是不发音的，也就是nullWord->pron==NULL,nullWord->nprons==0且LabId为“！NULL”，
HTK孤立词识别
02-08
使用HTK实现孤立词识别（打开、关闭、开始、结束）,文件内包含所使用到的命令并标有注释
HTK孤立词语音识别系统所有文件
12-23
HTK孤立词语音识别系统，实现的是6个单词的识别，所有文件打包，内有使用说明，运行命令可以直接识别。搭建的详细步骤参考我的博客： http://blog.csdn.net/cdj0311/article/details/17504165
HHTKSpeechRecT.rar_HTK_htk识别_识别 中文_语音
07-14
HTK语音识别.rar 连续续中文数字语音识别
HTK中文指南
11-30
htk工具介绍，中文版
语音识别之HTK入门
程序的魅力
09-28 2676
语音识别之HTK入门 其实，无论语音识别还是HTK对我来说都不算是入门的事了。 但是现在重新再走一遍，目标还是很明确的——打牢基础。重新回顾收获肯定多多，就像我前段时间把《C++ primer plus》再看一遍一样。把之前理解不透的，知识盲点清理了一下，感觉顺畅了很多，以后还会再次看看这些经典的书籍。 入门的目标就是能够把《HTK BOOK》中的拨号系统实现，各个中间文件的格式搞明白，用到哪个工具，基本掌握它的实现原理。这次可能还会对关键代码在visual studio下调试一遍。如何在visual
语音识别之HTK入门（四）——HCompV源码解析
程序的魅力
10-10 1182
上一篇博客中用HCompV工具通过全局数据来初始化HMM模型参数，包括proto和vFloor两个文件。同时手工制作hmmdefs模型，在这个文件中列举了每一个单因素模型的参数，它们是完全相同的。 现在一步一步看看HCompV是如何达成目标的。 如前面博客指出的，可以通过visual studio跟踪调试HCompV。 ...
语音识别之HTK入门（七）——HERest训练模型之Baum-Welch算法
程序的魅力
10-26 1043
上一个博客为B-W算法准备了基础，也就是前向算法和后向算法以及EM模型。 现在看看到底Baum-Welch算法是如何利用上述算法及模型来更新HMM的参数的。 之前也分析过多次了，在语音识别领域HMM模型之所以这么复杂，是因为观察向量对应的隐含转态不可得。存在隐藏数据，如果能得知这些标注数据，那么无论是计算初始概率，还是状态转移概率还是混淆概率都异常的简单、直接。 隐藏向量，假设它为I，观察向量为O，（O，I）表明为完全数据。 现在假设表示当前模型下，完全数据的联合概率，分别表示完全数据的对数似然概率
语音识别之HTK入门（二）
程序的魅力
09-29 901
步骤四：准备语音素材 在拨号系统中，可以通过HSGen自动生成合法的拨号句子文本。然后根据这些文本来录制对应的音频文件。HTK的HSLab工具可以完成录音功能。这两个方面都不是语音识别的学习重点，现在就假设我已经有了音频文件，以及标注好的对应文本。 首先，需要对文本进行处理。比如，原先的文本就是一句话，现在要改写成词级的Master Label File (MLF)格式，然后再改写成音子级别的。那么什么是MLF格式呢？百度了下“Master Label File”，并没有结果。看了下《HTK BOOK》
matlab HTK
最新发布
09-22
MATLAB HTK是一种用于训练HMMs、GMMs和简单语音识别器的MATLAB函数接口。您可以使用这个工具包来进行音频处理、特征提取、模型训练和语音识别等任务。 为了使用MATLAB HTK，您需要按照以下步骤进行设置： 1. 下载并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值