关闭

ICTCLAS分词系统研究(五)--N最短路径

标签: 数据结构算法blog
13616人阅读 评论(2) 收藏 举报
分类:

 

ICTCLAS和别的分司系统不一样的地方就是于--N最短路径分词算法。所谓N最短路径其实就是最短路径和最大路径的折中,保留前N个最优路径。这样做的目的就是对这两种方法取长补短,既能达到一个比较理解的分词不达意效果,又能保证分词不达意速度。在此处,我们中国人的中庸思想被完美体现:)。

在N-最短路径求解之前,ICTCLAS首先通过二叉分词图表(邻接表,如下图一所示)表示出了每个词组之间的耦合关系,每一个节点都表示分词图表中的一条边,它的行值代表边的起点(前驱),它的列值代表边的终点(后驱),这一点务必弄清楚。可以通过图一、图二相结合对照来理解。通过计算词组之间的耦合关系,来最终确定初次的分词路径。我们都知道Dijkstra算法是求源点到某一点的最短路径,也就是最优的那一条,在此处的N-最短路径指的是找出前N条最优的路径(实际上在FreeICTCLAS的源代码当中N是等于1的,即nValueKind==1)。按照Dijkstra的表示方法把二叉分词图表转化成图二的表示形式,就能比较清楚地看出来,求解的过程实际就是求源点0到终于12的最短路径,和纯粹的Dijkstra算法不同的地方是在此处需要记录每个节点的N个前驱,Dijkstra当中记录一个即可。

              图一

           图二

 

在求解过程中,源程序通过二维数组m_pParent[i][j]、m_pWeight[m][n]来记录每个节点的N个前驱和每个前驱和权重,而求解最短路径权重时借用了一个队列来实现排序,数据结构如下图三所示:        

图四

在源程序中,N最短路径是在CNShortPath类里里面实现的。

bool CSegment::BiSegment(char *sSentence, double dSmoothingPara, CDictionary &dictCore, CDictionary &dictBinary, unsigned int nResultCount)
{

......

//调用构造函数,生成一个二维链表,如下图一所示。每个链表节点是一个队列,数据结构如下图二所示
 CNShortPath sp(&aBiwordsNet,nResultCount);

//最短路径算法实现
 sp.ShortPath();

//输出最短路径
 sp.Output(nSegRoute,false,&m_nSegmentCount);

 .....

}


对源代码进行解析,以“他说的确实在理”为实例:

//进行N-最短路径的求解,找出每一个节点的前驱计算前驱的权值(从源点到该前驱节点)
int CNShortPath::ShortPath()
{
    unsigned 
int nCurNode=1,nPreNode,i,nIndex;
    ELEMENT_TYPE eWeight;
    PARRAY_CHAIN pEdgeList;
    
    
//遍历所示节点,按列优先原则,从1开始
    
//m_apCost其实是一个邻接表,或者叫稀疏矩阵,如图一所示,
    
//每一个节点代表的是分词路径中的一条边,
    
//该节点的行值代表边的起点,该节点的列值代表该边的终点
    for(;nCurNode<m_nVertex;nCurNode++)
    
{
       CQueue queWork;

       
//得到从nCurNode开始的所有结点,列优先原则
       eWeight=m_apCost->GetElement(-1,nCurNode,0,&pEdgeList);//Get all the edges

       
//遍历列下标等于nCurNode的所有结点,即遍历邻接表中所有终点为nCurNode的边
       while(pEdgeList!=0 && pEdgeList->col==nCurNode)
       
{
           
//取得该边的起点
           nPreNode=pEdgeList->row;
           
//该条边的权值
           eWeight=pEdgeList->value;//Get the value of edges

           
//m_nValueKind代表的是N-最短路径的N,即前N条最短分词路径
           
//m_pWeight记录当前节点的最短路径的权值,即从开始点到该点所有边的权值的总和
           
//每条边的起点的前驱可能有若干个,在这里只记录权值最小的m_nValueKind个
           for(i=0;i<m_nValueKind;i++)
           
{
               
if(nPreNode>0)//Push the weight and the pre node infomation
               {  
                   
if(m_pWeight[nPreNode-1][i]==INFINITE_VALUE)
                       
break;
  
                   queWork.Push(nPreNode,i,eWeight
+m_pWeight[nPreNode-1][i]);
               }

               
else//该条边的起点是0,即该起点没有父结点,是分词的源点
               {
                   queWork.Push(nPreNode,i,eWeight);
                   
break;
               }

           }
//end for
           pEdgeList=pEdgeList->next;
           
       }
//end while
       
       
//Now get the result queue which sort as weight.
       
//Set the current node information
       for(i=0;i<m_nValueKind;i++)
       
{
            m_pWeight[nCurNode
-1][i]=INFINITE_VALUE;
       }

       
//memset((void *),(int),sizeof(ELEMENT_TYPE)*);
       
//init the weight
       i=0;       

       
//设置当前节点的N个前驱节点的最短路径的权值 
       
//以"他说的确实在理"为例
       
//m_pWeight[0][0]=3.846
       
//m_pWeight[1][0]=6.025
       
//m_pWeight[2][0]=10.208
       
//m_pWeight[3][0]=15.063
       
//m_pWeight[4][0]=16.190
       
//m_pWeight[5][0]=16.184
       
//m_pWeight[6][0]=28.331
       
//m_pWeight[7][0]=28.331
       
//m_pWeight[8][0]=28.923
       
//m_pWeight[9][0]=28.923
       
//m_pWeight[10][0]=36.416
       
//m_pWeight[11][0]= 39.889
       while(i<m_nValueKind&&queWork.Pop(&nPreNode,&nIndex,&eWeight)!=-1)
       
{//Set the current node weight and parent
           if(m_pWeight[nCurNode-1][i]==INFINITE_VALUE)
               m_pWeight[nCurNode
-1][i]=eWeight;

           
//记录下一个前驱的权值,在queWork里面已经做过排序,
           
//所以不会有后来的eWeight更小的可能
           
//我总得把此if语句的表达式反过来比较可能会更容易理解一点
           else if(m_pWeight[nCurNode-1][i]<eWeight)//Next queue
           {
               i
++;//Go next queue and record next weight
               if(i==m_nValueKind)//Get the last position
                   break

               m_pWeight[nCurNode
-1][i]=eWeight;
           }

            
           
//m_pParent[0][0]=(0,0,0)
           
//m_pParent[1][0]=(1,0,0)
           
//m_pParent[2][0]=(2,0,0)
           
//m_pParent[3][0]=(2,0,0)
           
//m_pParent[4][0]=(3,0,0)
           
//m_pParent[5][0]=(3,0,0)
           
//m_pParent[6][0]=(4,0,0)
           
//m_pParent[7][0]=(4,0,0)
           
//m_pParent[8][0]=(6,0,0)
           
//m_pParent[9][0]=(6,0,0)
           
//m_pParent[10][0]=(9,0,0)
           
//m_pParent[11][0]=(11,0,0)
           m_pParent[nCurNode-1][i].Push(nPreNode,nIndex);
       }

    }
//end for

    
return 1;
}

 经过对每个节点的前驱求解后,得到前驱的最短路径权值和它的父节点,记录如下图四所示:


                     图四

然后通过队列(其实更象一个栈)来求出二叉分词路径: 

//bBest=true: only get one best result and ignore others
//Added in 2002-1-24
void CNShortPath::GetPaths(unsigned int nNode,unsigned int nIndex,int **nResult,bool bBest)
{
    CQueue queResult;
    unsigned 
int nCurNode,nCurIndex,nParentNode,nParentIndex,nResultIndex=0;
    
    
if(m_nResultCount>=MAX_SEGMENT_NUM)//Only need 10 result
        return ;
    nResult[m_nResultCount][nResultIndex]
=-1;//Init the result 

    
//先把末节点压栈
    queResult.Push(nNode,nIndex);
    nCurNode
=nNode;
    nCurIndex
=nIndex;
    
bool bFirstGet;
    
while(!queResult.IsEmpty())
    
{
        
while(nCurNode>0)//
        {   //Get its parent and store them in nParentNode,nParentIndex
            
//根据m_pParent数组中记录的每一个节点的前驱,把相应的前驱也压入栈中,
            
//当把0节点也压入栈中时,即表示找到一个条完整的最短路径,
            
//详情可参考吕震宇的BLOG:SharpICTCLAS分词系统简介(4)NShortPath-1 
            if(m_pParent[nCurNode-1][nCurIndex].Pop(&nParentNode,&nParentIndex,0,false,true)!=-1)
            
{
               nCurNode
=nParentNode;
               nCurIndex
=nParentIndex;
            }

            
if(nCurNode>0)
                queResult.Push(nCurNode,nCurIndex);
        }

        
//当到0节点时,也就意为着形成了一条最短路径
        if(nCurNode==0)
        
//Get a path and output
             nResult[m_nResultCount][nResultIndex++]=nCurNode;//Get the first node
           bFirstGet=true;
           nParentNode
=nCurNode;

           
//输出该条分词怎么,在这里queResult并不实际弹出元素,只是下标位移遍历元素
           
//遍历元素通过第四个参数bModify来控制是否真正删除栈顶元素
           while(queResult.Pop(&nCurNode,&nCurIndex,0,false,bFirstGet)!=-1)
           
{
               nResult[m_nResultCount][nResultIndex
++]=nCurNode;
               bFirstGet
=false;
               nParentNode
=nCurNode;
           }

           nResult[m_nResultCount][nResultIndex]
=-1;//Set the end
           m_nResultCount+=1;//The number of result add by 1
           if(m_nResultCount>=MAX_SEGMENT_NUM)//Only need 10 result
                return ;
           nResultIndex
=0;
           nResult[m_nResultCount][nResultIndex]
=-1;//Init the result 

           
if(bBest)//Return the best result, ignore others
               return ;
        }


        
//首先判断栈顶元素是否有下一个前驱,如果没有则删除栈顶元素直到有下一个前驱的元素出现
        queResult.Pop(&nCurNode,&nCurIndex,0,false,true);//Read the top node
        while(queResult.IsEmpty()==false&&(m_pParent[nCurNode-1][nCurIndex].IsSingle()||m_pParent[nCurNode-1][nCurIndex].IsEmpty(true)))
        
{
           queResult.Pop(
&nCurNode,&nCurIndex,0);//Get rid of it
           queResult.Pop(&nCurNode,&nCurIndex,0,false,true);//Read the top node
        }


        
//如果找到了有下一个前驱的节点,则它的前驱压入栈中,重新循环直到把源点也压入
        if(queResult.IsEmpty()==false&&m_pParent[nCurNode-1][nCurIndex].IsEmpty(true)==false)
        
{
               m_pParent[nCurNode
-1][nCurIndex].Pop(&nParentNode,&nParentIndex,0,false,false);
               nCurNode
=nParentNode;
               nCurIndex
=nParentIndex;
               
if(nCurNode>0)
                   queResult.Push(nCurNode,nCurIndex);
        }

    }

}

 


最终得到最短路么(0,1,2,3,6,9,11,12),里面的数值分别对应研究(四)中图四的下标,到此分词的第一大步就结束了,并形成最终结果:始##始/他/说/的/确实/在/理/末##末

 如果想详细getPaths()当中的实现原理,推荐大家看吕震宇的BLOG:

http://www.cnblogs.com/zhenyulu/articles/669795.html

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:452806次
    • 积分:5088
    • 等级:
    • 排名:第5477名
    • 原创:66篇
    • 转载:2篇
    • 译文:0篇
    • 评论:232条
    文章分类
    最新评论