IK分词器 原理分析 源码解析

IK分词器在是一款 基于词典和规则 的中文分词器。本文讲解的IK分词器是独立于elasticsearch、Lucene、solr，可以直接用在java代码中的部分。关于如何开发es分词插件，后续会有文章介绍。

IK分词器的源码：Google Code，直接下载请点击这里。

一、两种分词模式

IK提供两种分词模式：智能模式和细粒度模式（智能：对应es的IK插件的ik_smart，细粒度：对应es的IK插件的ik_max_word）。

先看两种分词模式的demo和效果

import org.wltea.analyzer.core.IKSegmenter;





import org.wltea.analyzer.core.Lexeme;





import java.io.IOException;





import java.io.StringReader;





 





public class IKSegmenterTest {





    static String text = "IK Analyzer是一个结合词典分词和文法分词的中文分词开源工具包。它使用了全新的正向迭代最细粒度切分算法。";





 





    public static void main(String[] args) throws IOException {





        IKSegmenter segmenter = new IKSegmenter(new StringReader(text), false);





        Lexeme next;





        System.out.print("非智能分词结果：");





        while((next=segmenter.next())!=null){





            System.out.print(next.getLexemeText()+"  ");





        }





 





        System.out.println();





        System.out.println("----------------------------分割线------------------------------");





 





        IKSegmenter smartSegmenter = new IKSegmenter(new StringReader(text), true);





        System.out.print("智能分词结果：");





        while((next=smartSegmenter.next())!=null) {





            System.out.print(next.getLexemeText() + "  ");





        }





    }





}

输出如下：

非智能分词结果：ik  analyzer  是  一个  一  个  结合  词典  分词  和文  文法  分词  的  中文  分词  开源  工具包  工具  包  它  使用  用了  全新  的  正向  迭代  最  细粒度  细粒  粒度  切分  切  分  算法 

----------------------------分割线------------------------------

智能分词结果：ik  analyzer  是  一个  结合  词典  分词  和  文法  分词  的  中文  分词  开源  工具包  它  使  用了  全新  的  正向  迭代  最  细粒度  切分  算法

可以看到：细粒度分词，包含每一种切分可能，而智能模式，只包含各种切分路径中最可能的一种。

二、源码概览

根据文章开头提供的链接下载源码在idea中打开后，目录结构如下

我们只需要关注cfg,core,dic三个包。

把lucene,query,sample,solr四个包下的代码注释掉，这几个包的代码是封装IKSegmenter，适配其他类库分词器的接口（lucene,solr），我们在此无需关注。

cfg包括IK的配置接口以及默认配置类，

core包括了IK的分词器接口ISegmenter，分词器核心类IKSegmenter，语义单元类Lexeme，上下文AnalyzeContext，以及子分词器LetterSegementer(英文字符子分词器),CN_QuantifierSegmenter(中文量词子分词器),CJKSegmenter(中日韩字符分词器)，

dic包括了词典类Dictionary，词典树分段类DictSegmenter，用来记录词典匹配命中记录的类Hit，以及主词典main2012.dic和中文量词词典quantifier.dic

三、词典

目前，IK分词器自带主词典拥有27万左右的汉语单词量。此外，对于分词组件应用场景所涉及的领域不同，需要各类专业词库的支持，为此IK提供了对扩展词典的支持。同时，IK还提供了对用户自定义的停止词（过滤词）的扩展支持。

1.词典的初始化

在分词器IKSegmenter首次实例化时，默认会根据DefaultConfig找到主词典和中文量词词典路径，同时DefaultConfig会根据classpath下配置文件IKAnalyzer.cfg.xml，找到扩展词典和停止词典路径，用户可以在该配置文件中配置自己的扩展词典和停止词典。

找到个词典路径后，初始化Dictionary.java，Dictionary是单例的。在Dictionary的构造函数中加载词典。Dictionary是IK的词典管理类，真正的词典数据是存放在DictSegment中，该类实现了一种树结构，如下图。

举个例子，要对字符串“A股市场”进行分词，首先拿到字符串的第一个字符'A'，在上面的tree中可以匹配到A节点，然后拿到字符串第二个字符'股'，首先从前一个节点A往下找，我们找到了股节点，股是一个终点节点。所以，“A股“是一个词。

Dictionary加载主词典，以，将主词典保存到它的_MainDict字段中，加载完主词典后，立即加载扩展词典，扩展词典同样保存在_MainDict中。

/*





 * 主词典对象





 */





private DictSegment _MainDict;





 





 





/**





 * 加载主词典及扩展词典





 */





private void loadMainDict(){





   //建立一个主词典实例





   _MainDict = new DictSegment((char)0);





   //读取主词典文件





       InputStream is = this.getClass().getClassLoader().getResourceAsStream(cfg.getMainDictionary());





       if(is == null){





           throw new RuntimeException("Main Dictionary not found!!!");





       }





       





   try {





      BufferedReader br = new BufferedReader(new InputStreamReader(is , "UTF-8"), 512);





      String theWord = null;





      do {





         theWord = br.readLine();





         if (theWord != null && !"".equals(theWord.trim())) {





            _MainDict.fillSegment(theWord.trim().toLowerCase().toCharArray());//加载主词典





         }





      } while (theWord != null);





      





   } catch (IOException ioe) {





      System.err.println("Main Dictionary loading exception.");





      ioe.printStackTrace();





      





   }finally{





      try {





         if(is != null){





                   is.close();





                   is = null;





         }





      } catch (IOException e) {





         e.printStackTrace();





      }





   }





   //加载扩展词典





   this.loadExtDict();





}  

fillSegment方法是DictSegment加载单个词的核心方法，charArray是词的字符数组，先是从存储节点搜索词的第一个字符，如果不存在则创建一个节点用于存储第一个字符，后面递归存储，直到最后一个字符。

/**





 * 加载填充词典片段





 * @param charArray





 * @param begin





 * @param length





 * @param enabled





 */





private synchronized void fillSegment(char[] charArray , int begin , int length , int enabled){





   //获取字典表中的汉字对象





   Character beginChar = new Character(charArray[begin]);





   //搜索当前节点的存储，查询对应keyChar的keyChar，如果没有则创建





   DictSegment ds = lookforSegment(keyChar , enabled);





   if(ds != null){





      //处理keyChar对应的segment





      if(length > 1){





         //词元还没有完全加入词典树





         ds.fillSegment(charArray, begin + 1, length - 1 , enabled);





      }else if (length == 1){





         //已经是词元的最后一个char,设置当前节点状态为enabled，





         //enabled=1表明一个完整的词，enabled=0表示从词典中屏蔽当前词





         ds.nodeState = enabled;





      }





   }





 





}

停止词和数量词同样的加载方法。参考Dictionary中loadStopWordDict()和loadQuantifierDict()方法。

tips，热词更新:

当词典初始化完毕后，可以调用Dictionary的addWords(Collection<String> words)方法往主词典_MainDict添加热词。

/**





 * 批量加载新词条





 * @param words Collection<String>词条列表





 */





public void addWords(Collection<String> words){





   if(words != null){





      for(String word : words){





         if (word != null) {





            //批量加载词条到主内存词典中





            singleton._MainDict.fillSegment(word.trim().toLowerCase().toCharArray());





         }





      }





   }





}

四、基于词典的切分

上面提到，主词典加载在Dictionary的_MainDict字段(DictSegment类型)中，

创建IKSegmenter时，需要传进来一个Reader实例，IK分词时，采用流式处理方式。

在IKSegmenter的next()方法中，首先调用AnalyzeContext.fillBuffer(this.input)从Reader读取8K数据到到segmentBuff的char数组中，然后调用子分词器CJKSegmenter（中日韩文分词器），CN_QuantifierSegmenter（中文数量词分词器），LetterSegmenter（英文分词器）的analyze方法依次从头处理segmentBuff中的每一个字符。

LetterSegmenter.analyze()：英文分词器逻辑很简单，从segmentBuff中遇到第一个英文字符往后，直到碰到第一个非英文字符，这中间的所有字符则切分为一个英文单词。

CN_QuantifierSegmenter.analyze()：中文量词分词器处理逻辑也很简单，在segmentBuff中遇到每一个中文数量词，然后检查该数量词后一个字符是否未中文量词（根据是否包含在中文量词词典中为判断依据），如是，则分成一个词，如否，则不是一个词。

/**





 * 分词，获取下一个词元





 * @return Lexeme 词元对象





 * @throws IOException





 */





public synchronized Lexeme next()throws IOException{





   Lexeme l = null;





   





   while((l = context.getNextLexeme()) == null){





      /*





       * 从reader中读取数据，填充buffer





       * 如果reader是分次读入buffer的，那么buffer要进行移位处理





       * 移位处理上次读入的但未处理的数据





       */





      int available = context.fillBuffer(this.input);





      if(available <= 0){





         //reader已经读完





         context.reset();





         return null;





         





      }else{





         //初始化指针





         context.initCursor();





         do{





                 //遍历子分词器





                 for(ISegmenter segmenter : segmenters){





                    segmenter.analyze(context);





                 }





                 //字符缓冲区接近读完，需要读入新的字符





                 if(context.needRefillBuffer()){





                    break;





                 }





            //向前移动指针





         }while(context.moveCursor());





         //重置子分词器，为下轮循环进行初始化





         for(ISegmenter segmenter : segmenters){





            segmenter.reset();





         }





      }





      //对分词进行歧义处理





      this.arbitrator.process(context, this.cfg.useSmart());       





      //处理未切分CJK字符





      context.outputToResult();





      //记录本次分词的缓冲区位移





      context.markBufferOffset();          





   }





   





   return l;





}  

CJKSegmenter.analyze则比较复杂一些，拿到第一个字符，调用Dictionary.matchInMainDict()方法，实际就是调用_MainDict.match()方法，在主词典的match方法中去匹配，首先判断该字能否单独成词（即判断_MainDict中该词所在第一个层的节点状态是否为1），如果能则加入上下文中保存起来。然后再判断该词是否可能为其他词的前缀（即判断_MainDict中该词所在第一层节点是否还有子节点），如果是则保存在分词器的临时字段tmpHits中。

再往后拿到segmentBuff中第二个字符，首先判断该词是否存在上一轮保存在temHits中的字符所在节点的子节点中，如果存在则判断这两个字符能否组成完整的词（同样，依据字符节点的状态是否为1来判断），如果成词，保存到上下文中，并且继续判断是否可能为其他词的前缀（还是判断该字符节点是否还有子节点），如果有，继续保存到tmpHits中，如果没有，则抛弃。然后再讲该字符重复与第一个字符一样的操作即可。

public void analyze(AnalyzeContext context) {





   if(CharacterUtil.CHAR_USELESS != context.getCurrentCharType()){





      





      //优先处理tmpHits中的hit





      if(!this.tmpHits.isEmpty()){





         //处理词段队列





         Hit[] tmpArray = this.tmpHits.toArray(new Hit[this.tmpHits.size()]);





         for(Hit hit : tmpArray){





            hit = Dictionary.getSingleton().matchWithHit(context.getSegmentBuff(), context.getCursor() , hit);





            if(hit.isMatch()){





               //输出当前的词





               Lexeme newLexeme = new Lexeme(context.getBufferOffset() , hit.getBegin() , context.getCursor() - hit.getBegin() + 1 , Lexeme.TYPE_CNWORD);





               context.addLexeme(newLexeme);





               





               if(!hit.isPrefix()){//不是词前缀，hit不需要继续匹配，移除





                  this.tmpHits.remove(hit);





               }





               





            }else if(hit.isUnmatch()){





               //hit不是词，移除





               this.tmpHits.remove(hit);





            }              





         }





      }        





      





      //*********************************





      //再对当前指针位置的字符进行单字匹配





      Hit singleCharHit = Dictionary.getSingleton().matchInMainDict(context.getSegmentBuff(), context.getCursor(), 1);





      if(singleCharHit.isMatch()){//首字成词





         //输出当前的词





         Lexeme newLexeme = new Lexeme(context.getBufferOffset() , context.getCursor() , 1 , Lexeme.TYPE_CNWORD);





         context.addLexeme(newLexeme);





 





         //同时也是词前缀





         if(singleCharHit.isPrefix()){





            //前缀匹配则放入hit列表





            this.tmpHits.add(singleCharHit);





         }





      }else if(singleCharHit.isPrefix()){//首字为词前缀





         //前缀匹配则放入hit列表





         this.tmpHits.add(singleCharHit);





      }





      





 





   }else{





      //遇到CHAR_USELESS字符





      //清空队列





      this.tmpHits.clear();





   }





   





   //判断缓冲区是否已经读完





   if(context.isBufferConsumed()){





      //清空队列





      this.tmpHits.clear();





   }





   





   //判断是否锁定缓冲区





   if(this.tmpHits.size() == 0){





      context.unlockBuffer(SEGMENTER_NAME);





      





   }else{





      context.lockBuffer(SEGMENTER_NAME);





   }





}

当子分词器处理完segmentBuff中所有字符后，字符的所有成词情况都已保存到上下文的orgLexemes字段中。

调用分词歧义裁决器IKArbitrator，如果分词器使用细粒度模式（useSmart=false），则裁决器不做不做歧义处理，将上下文orgLexemes字段中所有成词情况全部保存到上下文pathMap中。

然后调用context.outputToResult()方法根据pathMap中的成词情况，将最终分词结果保存到上下文的result字段中。

至此，segmentBuff中所有字符的分词结果全部保存在result中了，通过IKSegmenter.next()方法一个一个返回给调用者。

当next方法返回result所有分词后，分词器再从Reader中读取下一个8K数据到segmentBuff中，重复上述所有步骤，直至Reader全部读取完毕。

五、基于规则的歧义判断

分词裁决器IKArbitrator只有在Smart模式才会生效。

judge是IKArbitrator处理分词歧义的方法。

裁决器从上下文orgLexemes读取所有的成词，判断有交叉（有交叉即表示分词有歧义）的成词，然后，遍历每一种不交叉的情况，用LexemePath对象表示，然后保存到自定义有序链表TreeSet中，最后first()取出链表第一个元素，即为最佳分词结果。

/**





 * 歧义识别





 * @param lexemeCell 歧义路径链表头





 * @param fullTextLength 歧义路径文本长度





 * @param option 候选结果路径





 * @return





 */





private LexemePath judge(QuickSortSet.Cell lexemeCell , int fullTextLength){





   //候选路径集合





   TreeSet<LexemePath> pathOptions = new TreeSet<LexemePath>();





   //候选结果路径





   LexemePath option = new LexemePath();





   





   //对crossPath进行一次遍历,同时返回本次遍历中有冲突的Lexeme栈





   Stack<QuickSortSet.Cell> lexemeStack = this.forwardPath(lexemeCell , option);





   





   //当前词元链并非最理想的，加入候选路径集合





   pathOptions.add(option.copy());





   





   //存在歧义词，处理





   QuickSortSet.Cell c = null;





   while(!lexemeStack.isEmpty()){





      c = lexemeStack.pop();





      //回滚词元链





      this.backPath(c.getLexeme() , option);





      //从歧义词位置开始，递归，生成可选方案





      this.forwardPath(c , option);





      pathOptions.add(option.copy());





   }





   





   //返回集合中的最优方案





   return pathOptions.first();





 





}

然后我们看一下LexemePath对象的比较规则，即为IK的歧义判断规则，LexemePath实现了Comparable接口。

从compareTo方法可以得出，IK歧义判断规则如下，优先级从上到下一致降低：

1.分词文本长度越长越好

2.分词个数越少越好

3.分词路径跨度越大越好

4.分词位置越靠后的优先

5.词长越平均越好

6.词元位置权重越大越好（这个我也没明白，先这样，后面有需要再弄明白具体细节）

public int compareTo(LexemePath o) {





   //比较有效文本长度





   if(this.payloadLength > o.payloadLength){





      return -1;





   }else if(this.payloadLength < o.payloadLength){





      return 1;





   }else{





      //比较词元个数，越少越好





      if(this.size() < o.size()){





         return -1;





      }else if (this.size() > o.size()){





         return 1;





      }else{





         //路径跨度越大越好





         if(this.getPathLength() >  o.getPathLength()){





            return -1;





         }else if(this.getPathLength() <  o.getPathLength()){





            return 1;





         }else {





            //根据统计学结论，逆向切分概率高于正向切分，因此位置越靠后的优先





            if(this.pathEnd > o.pathEnd){





               return -1;





            }else if(pathEnd < o.pathEnd){





               return 1;





            }else{





               //词长越平均越好





               if(this.getXWeight() > o.getXWeight()){





                  return -1;





               }else if(this.getXWeight() < o.getXWeight()){





                  return 1;





               }else {





                  //词元位置权重比较





                  if(this.getPWeight() > o.getPWeight()){





                     return -1;





                  }else if(this.getPWeight() < o.getPWeight()){





                     return 1;





                  }





                  





               }





            }





         }





      }





   }





   return 0;





}

六、总结

总的来说，IK分词是一个基于词典的分词器，只有包含在词典的词才能被正确切分，IK解决分词歧义只是根据几条可能是最佳的分词实践规则，并没有用到任何概率模型，也不具有新词发现的功能。

原文地址：https://blog.csdn.net/jiandabang/article/details/83539783