NPL系列之分词和分词框架(二)

如果要从事NPL的相关技术工作,那么最基础的工作就是分词工作,这个也是所有技术的第一步,当然 这里讨论的中文的分词,因为英文的分词技术是比较单一,基本上按照空格进行标准分词就可以了,但是中文就比较复杂了,所以今天就一起简单的学习一下NPL的基础工作之分词技术和对应的分词开源框架

尽管中文的分词是比较复杂的,但是目前还是有很多的开源框架给开发者使用,目前开源的分词器有下面这些,但是有的如果用的商用的话,可能是需要收费的.所以要注意,像word,ansj,stanford,hanlp,jibea,foundnlp,jcseg,mmse4j,ik,paoding,smartcn,不过可以分为两大类,一大类是之提供分词相关的功能,还有一大类是分词只是基础,还提供和自然语言处理相关的功能:

& 提供分词分词相关的功能

>>mmse4j,ik,smartcn,paoding,ansj

& 提供自然语言处理相关的功能(肯定包括分词相关的功能)

>>jibea,hanlp,stanfor,foundnlp,jcseg

接下来,介绍一下每个分词器的功能

MMSE4J:

优点:

  • 采用了特有的正向迭代最细粒度切分算法,具有60万字/秒的高速处理能力。

  • 采用了多子处理器分析模式,支持:英文字母(IP地址、EmailURL)、数字(日期,常用中文数量词,罗马数字,科学计数法),中文词汇(姓名、地名处理)等分词处理。

  • 优化的词典存储,更小的内存占用。支持用户词典扩展定义。

  • 针对Lucene全文检索优化的查询分析器IKQueryParser,采用歧义分析算法优化查询关键字的搜索排列组合,能极大的提高Lucene检索的命中率。

IK:

算法:基于正向匹配

功能:支持smart和非smart模式

SMARTCN:

算法:基于最短路径

功能:简化版的中科院Java

缺点:不支持动态字典的扩展

PAODING:

优点:

  • 高扩展性:能非常方便的扩充字典,也可以非常方便的添加停用词。

  • 效率极高-极高效率的字典查找算法;尽量避免无谓试探查找。 

  • 算法简练-简单易理解的算法,但效率却是非常高效的。

  • 轻松支持最大/最小切词。 

缺点:

  • 分词精确度不好,涉及了汉语语义的问题,几乎不可完全解决。如:“和服”实例。

ANSJ:

这是一个基于n-Gram+CRF+HMM的中文分词的java实现.

分词速度达到每秒钟大约200万字左右(mac air下测试),准确率能达到96%以上

目前实现了.中文分词. 中文姓名识别 . 用户自定义词典,关键字提取,自动摘要,关键字标记等功能

可以应用到自然语言处理等方面,适用于对分词效果要求高的各种项目.

JCSEG:

  • 中文分词:mmseg算法 + Jcseg 独创的优化算法,四种切分模式。
  • 关键字提取:基于textRank算法。
  • 关键短语提取:基于textRank算法。
  • 关键句子提取:基于textRank算法。
  • 文章自动摘要:基于BM25+textRank算法。
  • 自动词性标注:基于词库+(统计歧义去除计划),目前效果不是很理想,对词性标注结果要求较高的应用不建议使用。
  • 命名实体标注:基于词库+(统计歧义去除计划),电子邮件,网址,大陆手机号码,地名,人名,货币,datetime时间,长度,面积,距离单位等。
  • Restful api:嵌入jetty提供了一个绝对高性能的server模块,包含全部功能的http接口,标准化json输出格式,方便各种语言客户端直接调用

JIBEA:

  • 支持三种分词模式:

    • 精确模式,试图将句子最精确地切开,适合文本分析-关键字提取,文本摘要获取;
    • 全模式,把句子中所有的可以成词的词语都扫描出来, 速度非常快,但是不能解决歧义;
    • 搜索引擎模式,在精确模式的基础上,对长词再次切分,提高召回率,适合用于搜索引擎分词。
  • 支持繁体分词

  • 支持自定义词典


HANLP:

  • 中文分词
    • HMM-Bigram(速度与精度最佳平衡;一百兆内存)
      • 最短路分词、N-最短路分词
    • 由字构词(侧重精度,可识别新词;适合NLP任务)
      • 感知机分词、CRF分词
    • 词典分词(侧重速度,每秒数千万字符;省内存)
      • 极速词典分词
    • 所有分词器都支持:
      • 索引全切分模式
      • 用户自定义词典
      • 兼容繁体中文
      • 训练用户自己的领域模型
  • 词性标注
    • HMM词性标注(速度快)
    • 感知机词性标注、CRF词性标注(精度高)
  • 命名实体识别
    • 基于HMM角色标注的命名实体识别 (速度快)
      • 中国人名识别、音译人名识别、日本人名识别、地名识别、实体机构名识别
    • 基于线性模型的命名实体识别(精度高)
      • 感知机命名实体识别、CRF命名实体识别
  • 关键词提取
    • TextRank关键词提取
  • 自动摘要
    • TextRank自动摘要
  • 短语提取
    • 基于互信息和左右信息熵的短语提取
  • 拼音转换
    • 多音字、声母、韵母、声调
  • 简繁转换
    • 简繁分歧词(简体、繁体、臺灣正體、香港繁體)
  • 文本推荐
    • 语义推荐、拼音推荐、字词推荐
  • 依存句法分析
    • 基于神经网络的高性能依存句法分析器
    • MaxEnt依存句法分析
  • 文本分类
    • 情感分析
  • word2vec
    • 词向量训练、加载、词语相似度计算、语义运算、查询、KMeans聚类
    • 文档语义相似度计算

WORD:

一个Java实现的分布式的中文分词组件,提供了多种基于词典的分词算法,并利用ngram模型来消除歧义。能准确识别英文、数字,以及日期、时间等数量词,能识别人名、地名、组织机构名等未登录词。能通过自定义配置文件来改变组件行为,能自定义用户词库、自动检测词库变化、支持大规模分布式环境,能灵活指定多种分词算法,能使用refine功能灵活控制分词结果,还能使用词频统计、词性标注、同义标注、反义标注、拼音标注等功能。提供了10种分词算法,还提供了10种文本相似度算法,同时还无缝和Lucene、Solr、ElasticSearch、Luke集成。注意:

FOUNDNLP:一个Java本报实现的分词组件,除分词功能之外,也支持自然语言处理相关的功能.关键字提取,生成自动摘要

STANFORENLP:和上面类似,都是除分词之外还提供一些和自然语言处理相关的功能:

上面就把常用的分词组件进行了简单的介绍,因为只要知道每种功能是做什么以及对应的缺点,才能为业务开发做选性支撑,为了看真实的效果,可以把上面的分词器进行封装,然后统一测试:

首先定义一个接口:

/**
 * 获取文本的所有分词结果, 对比不同分词器结果
 */
public interface WordSegmenter {
    /**
     * 获取文本的所有分词结果
     * @param text 文本
     * @return 所有的分词结果,去除重复
     */
    default public Set seg(String text) {
        return segMore(text).values().stream().collect(Collectors.toSet());
    }
    /**
     * 获取文本的所有分词结果
     * @param text 文本
     * @return 所有的分词结果,KEY 为分词器模式,VALUE 为分词器结果
     */
    public Map segMore(String text);
}


然后看下面每个分词组件的实现:

& word分词器

@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    for(SegmentationAlgorithm segmentationAlgorithm : SegmentationAlgorithm.values()){
        map.put(segmentationAlgorithm.getDes(), seg(text, segmentationAlgorithm));
    }
    return map;
}
private static String seg(String text, SegmentationAlgorithm segmentationAlgorithm) {
    StringBuilder result = new StringBuilder();
    for(Word word : WordSegmenter.segWithStopWords(text, segmentationAlgorithm)){
        result.append(word.getText()).append(" ");
    }
    return result.toString();
}



& ansj分词器

@Override
public Map segMore(String text) {
    Map map = new HashMap<>();

    StringBuilder result = new StringBuilder();
    for(Term term : BaseAnalysis.parse(text)){
        result.append(term.getName()).append(" ");
    }
    map.put("BaseAnalysis", result.toString());

    result.setLength(0);
    for(Term term : ToAnalysis.parse(text)){
        result.append(term.getName()).append(" ");
    }
    map.put("ToAnalysis", result.toString());

    result.setLength(0);
    for(Term term : NlpAnalysis.parse(text)){
        result.append(term.getName()).append(" ");
    }
    map.put("NlpAnalysis", result.toString());

    result.setLength(0);
    for(Term term : IndexAnalysis.parse(text)){
        result.append(term.getName()).append(" ");
    }
    map.put("IndexAnalysis", result.toString());

    return map;
}

& stanford分词器

private static final StanfordCoreNLP CTB = new StanfordCoreNLP("StanfordCoreNLP-chinese-ctb");
private static final StanfordCoreNLP PKU = new StanfordCoreNLP("StanfordCoreNLP-chinese-pku");
private static final PrintStream NULL_PRINT_STREAM = new PrintStream(new NullOutputStream(), false);
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("Stanford Beijing University segmentation", seg(PKU, text));
    map.put("Stanford Chinese Treebank segmentation", seg(CTB, text));
    return map;
}
private static String seg(StanfordCoreNLP stanfordCoreNLP, String text){
    PrintStream err = System.err;
    System.setErr(NULL_PRINT_STREAM);
    Annotation document = new Annotation(text);
    stanfordCoreNLP.annotate(document);
    List sentences = document.get(CoreAnnotations.SentencesAnnotation.class);
    StringBuilder result = new StringBuilder();
    for(CoreMap sentence: sentences) {
        for (CoreLabel token: sentence.get(CoreAnnotations.TokensAnnotation.class)) {
            String word = token.get(CoreAnnotations.TextAnnotation.class);;
            result.append(word).append(" ");
        }
    }
    System.setErr(err);
    return result.toString();
}


& fudannlp分词器

private static CWSTagger tagger = null;
static{
    try{
        tagger = new CWSTagger("lib/fudannlp_seg.m");
        tagger.setEnFilter(true);
    }catch(Exception e){
        e.printStackTrace();
    }
}
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("FudanNLP", tagger.tag(text));
    return map;
}


& jieba分词器

private static final JiebaSegmenter JIEBA_SEGMENTER = new JiebaSegmenter();
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("INDEX", seg(text, SegMode.INDEX));
    map.put("SEARCH", seg(text, SegMode.SEARCH));
    return map;
}
private static String seg(String text, SegMode segMode) {
    StringBuilder result = new StringBuilder();                
    for(SegToken token : JIEBA_SEGMENTER.process(text, segMode)){
        result.append(token.word.getToken()).append(" ");
    }
    return result.toString(); 
}


& jcseg分词器

private static final JcsegTaskConfig CONFIG = new JcsegTaskConfig();
private static final ADictionary DIC = DictionaryFactory.createDefaultDictionary(CONFIG);
static {
    CONFIG.setLoadCJKSyn(false);
    CONFIG.setLoadCJKPinyin(false);
}
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();

    map.put("复杂模式", segText(text, JcsegTaskConfig.COMPLEX_MODE));
    map.put("简易模式", segText(text, JcsegTaskConfig.SIMPLE_MODE));

    return map;
}
private String segText(String text, int segMode) {
    StringBuilder result = new StringBuilder();        
    try {
        ISegment seg = SegmentFactory.createJcseg(segMode, new Object[]{new StringReader(text), CONFIG, DIC});
        IWord word = null;
        while((word=seg.next())!=null) {         
            result.append(word.getValue()).append(" ");
        }
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
    return result.toString();
}


& mmse4j分词器

private static final Dictionary DIC = Dictionary.getInstance();
private static final SimpleSeg SIMPLE_SEG = new SimpleSeg(DIC);
private static final ComplexSeg COMPLEX_SEG = new ComplexSeg(DIC);
private static final MaxWordSeg MAX_WORD_SEG = new MaxWordSeg(DIC);
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put(SIMPLE_SEG.getClass().getSimpleName(), segText(text, SIMPLE_SEG));
    map.put(COMPLEX_SEG.getClass().getSimpleName(), segText(text, COMPLEX_SEG));
    map.put(MAX_WORD_SEG.getClass().getSimpleName(), segText(text, MAX_WORD_SEG));
    return map;
}
private String segText(String text, Seg seg) {
    StringBuilder result = new StringBuilder();
    MMSeg mmSeg = new MMSeg(new StringReader(text), seg);        
    try {
        Word word = null;
        while((word=mmSeg.next())!=null) {       
            result.append(word.getString()).append(" ");
        }
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
    return result.toString();
}


& ik分词器

@Override
public Map segMore(String text) {
    Map map = new HashMap<>();

    map.put("智能切分", segText(text, true));
    map.put("细粒度切分", segText(text, false));

    return map;
}
private String segText(String text, boolean useSmart) {
    StringBuilder result = new StringBuilder();
    IKSegmenter ik = new IKSegmenter(new StringReader(text), useSmart);        
    try {
        Lexeme word = null;
        while((word=ik.next())!=null) {          
            result.append(word.getLexemeText()).append(" ");
        }
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
    return result.toString();
}


& paoding分词器

private static final PaodingAnalyzer ANALYZER = new PaodingAnalyzer();
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();

    map.put("MOST_WORDS_MODE", seg(text, PaodingAnalyzer.MOST_WORDS_MODE));
    map.put("MAX_WORD_LENGTH_MODE", seg(text, PaodingAnalyzer.MAX_WORD_LENGTH_MODE));
    
    return map;
}
private static String seg(String text, int mode){
    ANALYZER.setMode(mode);
    StringBuilder result = new StringBuilder();
    try {
        Token reusableToken = new Token();
        TokenStream stream = ANALYZER.tokenStream("", new StringReader(text));
        Token token = null;
        while((token = stream.next(reusableToken)) != null){
            result.append(token.term()).append(" ");
        }
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
    return result.toString();          
}


& smartcn分词器

private static final SmartChineseAnalyzer SMART_CHINESE_ANALYZER = new SmartChineseAnalyzer();
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("smartcn", segText(text));
    return map;
}
private static String segText(String text) {
    StringBuilder result = new StringBuilder();
    try {
        TokenStream tokenStream = SMART_CHINESE_ANALYZER.tokenStream("text", new StringReader(text));
        tokenStream.reset();
        while (tokenStream.incrementToken()){
            CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
            result.append(charTermAttribute.toString()).append(" ");
        }
        tokenStream.close();
    }catch (Exception e){
        e.printStackTrace();
    }
    return result.toString();
}


& hanlp分词器

private static final Segment N_SHORT_SEGMENT = new NShortSegment().enableCustomDictionary(false).enablePlaceRecognize(true).enableOrganizationRecognize(true);
private static final Segment DIJKSTRA_SEGMENT = new DijkstraSegment().enableCustomDictionary(false).enablePlaceRecognize(true).enableOrganizationRecognize(true);
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("标准分词", standard(text));
    map.put("NLP分词", nlp(text));
    map.put("索引分词", index(text));
    map.put("N-最短路径分词", nShort(text));
    map.put("最短路径分词", shortest(text));
    map.put("极速词典分词", speed(text));
    return map;
}
private static String standard(String text) {
    StringBuilder result = new StringBuilder();
    StandardTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String nlp(String text) {
    StringBuilder result = new StringBuilder();
    NLPTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String index(String text) {
    StringBuilder result = new StringBuilder();
    IndexTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String speed(String text) {
    StringBuilder result = new StringBuilder();
    SpeedTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String nShort(String text) {
    StringBuilder result = new StringBuilder();
    N_SHORT_SEGMENT.seg(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String shortest(String text) {
    StringBuilder result = new StringBuilder();
    DIJKSTRA_SEGMENT.seg(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}


写个测试类进行测试

public static Map> contrast(String text){
    Map> map = new LinkedHashMap<>();
    map.put("word分词器", new WordEvaluation().seg(text));
    map.put("Stanford分词器", new StanfordEvaluation().seg(text));
    map.put("Ansj分词器", new AnsjEvaluation().seg(text));
    map.put("HanLP分词器", new HanLPEvaluation().seg(text));
    map.put("FudanNLP分词器", new FudanNLPEvaluation().seg(text));
    map.put("Jieba分词器", new JiebaEvaluation().seg(text));
    map.put("Jcseg分词器", new JcsegEvaluation().seg(text));
    map.put("MMSeg4j分词器", new MMSeg4jEvaluation().seg(text));
    map.put("IKAnalyzer分词器", new IKAnalyzerEvaluation().seg(text));
    map.put("smartcn分词器", new SmartCNEvaluation().seg(text));
    return map;
}
public static Map> contrastMore(String text){
    Map> map = new LinkedHashMap<>();
    map.put("word分词器", new WordEvaluation().segMore(text));
    map.put("Stanford分词器", new StanfordEvaluation().segMore(text));
    map.put("Ansj分词器", new AnsjEvaluation().segMore(text));
    map.put("HanLP分词器", new HanLPEvaluation().segMore(text));
    map.put("FudanNLP分词器", new FudanNLPEvaluation().segMore(text));
    map.put("Jieba分词器", new JiebaEvaluation().segMore(text));
    map.put("Jcseg分词器", new JcsegEvaluation().segMore(text));
    map.put("MMSeg4j分词器", new MMSeg4jEvaluation().segMore(text));
    map.put("IKAnalyzer分词器", new IKAnalyzerEvaluation().segMore(text));
    map.put("smartcn分词器", new SmartCNEvaluation().segMore(text));
    return map;
}
public static void show(Map> map){
    map.keySet().forEach(k -> {
        System.out.println(k + " 的分词结果:");
        AtomicInteger i = new AtomicInteger();
        map.get(k).forEach(v -> {
            System.out.println("\t" + i.incrementAndGet() + " 、" + v);
        });
    });
}
public static void showMore(Map> map){
    map.keySet().forEach(k->{
        System.out.println(k + " 的分词结果:");
        AtomicInteger i = new AtomicInteger();
        map.get(k).keySet().forEach(a -> {
            System.out.println("\t" + i.incrementAndGet()+ " 、【"   + a + "】\t" + map.get(k).get(a));
        });
    });
}
public static void main(String[] args) {
    show(contrast("我爱楚离陌"));
    showMore(contrastMore("我爱楚离陌"));
}


看一下最终的效果:

********************************************
word分词器 的分词结果:
    1 、我 爱 楚离陌 
Stanford分词器 的分词结果:
    1 、我 爱 楚 离陌 
    2 、我 爱 楚离陌 
Ansj分词器 的分词结果:
    1 、我 爱 楚离 陌 
    2 、我 爱 楚 离 陌 
HanLP分词器 的分词结果:
    1 、我 爱 楚 离 陌 
smartcn分词器 的分词结果:
    1 、我 爱 楚 离 陌 
FudanNLP分词器 的分词结果:
    1 、我 爱楚离陌
Jieba分词器 的分词结果:
    1 、我爱楚 离 陌 
Jcseg分词器 的分词结果:
    1 、我 爱 楚 离 陌 
MMSeg4j分词器 的分词结果:
    1 、我爱 楚 离 陌 
IKAnalyzer分词器 的分词结果:
    1 、我 爱 楚 离 陌 
********************************************
********************************************
word分词器 的分词结果:
    1 、【全切分算法】    我 爱 楚离陌 
    2 、【双向最大最小匹配算法】    我 爱 楚离陌 
    3 、【正向最大匹配算法】    我 爱 楚离陌 
    4 、【双向最大匹配算法】    我 爱 楚离陌 
    5 、【逆向最大匹配算法】    我 爱 楚离陌 
    6 、【正向最小匹配算法】    我 爱 楚离陌 
    7 、【双向最小匹配算法】    我 爱 楚离陌 
    8 、【逆向最小匹配算法】    我 爱 楚离陌 
Stanford分词器 的分词结果:
    1 、【Stanford Chinese Treebank segmentation】    我 爱 楚离陌 
    2 、【Stanford Beijing University segmentation】    我 爱 楚 离陌 
Ansj分词器 的分词结果:
    1 、【BaseAnalysis】    我 爱 楚 离 陌 
    2 、【IndexAnalysis】    我 爱 楚 离 陌 
    3 、【ToAnalysis】    我 爱 楚 离 陌 
    4 、【NlpAnalysis】    我 爱 楚离 陌 
HanLP分词器 的分词结果:
    1 、【NLP分词】    我 爱 楚 离 陌 
    2 、【标准分词】    我 爱 楚 离 陌 
    3 、【N-最短路径分词】    我 爱 楚 离 陌 
    4 、【索引分词】    我 爱 楚 离 陌 
    5 、【最短路径分词】    我 爱 楚 离 陌 
    6 、【极速词典分词】    我 爱 楚 离 陌 
smartcn分词器 的分词结果:
    1 、【smartcn】    我 爱 楚 离 陌 
FudanNLP分词器 的分词结果:
    1 、【FudanNLP】    我 爱楚离陌
Jieba分词器 的分词结果:
    1 、【SEARCH】    我爱楚 离 陌 
    2 、【INDEX】    我爱楚 离 陌 
Jcseg分词器 的分词结果:
    1 、【简易模式】    我 爱 楚 离 陌 
    2 、【复杂模式】    我 爱 楚 离 陌 
MMSeg4j分词器 的分词结果:
    1 、【SimpleSeg】    我爱 楚 离 陌 
    2 、【ComplexSeg】    我爱 楚 离 陌 
    3 、【MaxWordSeg】    我爱 楚 离 陌 
IKAnalyzer分词器 的分词结果:
    1 、【智能切分】    我 爱 楚 离 陌 
    2 、【细粒度切分】    我 爱 楚 离 陌 
********************************************

从上面的结果中可以看出来hanlp支持的分词类型是最多的,最后提一点建议,就是关于如何选择和学习?

选型

1 如果当前的分词功能是为了和搜索引擎结合,比如像solr,elasticsearch,luncene等那么使用IK,MMSE4J,JIBEA即可

2 如果当前的分词功能是基础,还需要其它相关功能,比如自动文本摘要提权,关键字提权,词性识别等,那么使用hanlp,fudannlp,jibea,jcseg等

学习:(对于新手而言)

那么多的框架,肯定不需要全部掌握,但是对于常用的框架,最好能够系统性的进行掌握,比如举个列子,对于jibea而言,它提供分词,关键字提权,文本摘要生成等,尽管用它的时候,大多数都是使用分词功能,但是从学习掌握技术的全面性来说,可以把它所有的功能都掌握一下,比如像jieba常用的功能如下

#encoding=utf8
import jieba
from jieba import analyse
from jieba import posseg
# 算法介绍
#基于前缀词典实现高效的词图扫描,生成句子中汉字所有可能成词情况所构成的有向无环图 (DAG)
#采用了动态规划查找最大概率路径, 找出基于词频的最大切分组合
#对于未登录词,采用了基于汉字成词能力的 HMM 模型,使用了 Viterbi 算法

# 分词速度
#1.5 MB / Second in Full Mode
#400 KB / Second in Default Mode
#测试环境: Intel(R) Core(TM) i7-2600 CPU @ 3.4GHz;《围城》.txt

# 核心功能
# 1 基本分词演示
# 2 添加自定义字典
# 3 关键词提取
# 4 词性标注
# 5 并行分词
# 6 Tokenizer使用

# 封装jibea基础功能的演示
class JibeaFunciont():

    # 初始化方法
    def __init__(self,dictPath):

        print("init object..."+dictPath)

    # 测试基本分词使用
    def cutWord(self,str):
        print("=====================进入分词功能=====================")
        #设置并行分词 processnum=并行分词的线程数
        jieba.enable_parallel(processnum=4)
        seg_list = jieba.cut(str, cut_all=True)
        print("[全模式匹配:] " + "/ ".join(seg_list))  # 全模式

        seg_list = jieba.cut(str, cut_all=False)
        print("[精确模式匹配:] " + "/ ".join(seg_list))  # 精确模式

        seg_list = jieba.cut(str)  # 默认是精确模式
        print("[默认模式匹配:]"+",".join(seg_list))

        seg_list = jieba.cut_for_search(str)  # 搜索引擎模式
        print("[搜索引擎模式匹配:]"+",".join(seg_list))


    #加载自定义词典
    # 词典格式和 dict.txt 一样,一个词占一行;每一行分三部分:词语、词频(可省略)、词性(可省略),用空格隔开,顺序不可颠倒。
    # file_name 若为路径或二进制方式打开的文件,则文件必须为 UTF-8 编码
    def loadDict(self,str,dictPath):
        print("=====================进入加载自定义词典=====================")
        jieba.load_userdict(dictPath)
        self._fillWordFreq(dictPath)
        seg_list = jieba.cut(str,HMM=False)
        print("[全模式匹配:] " + "/ ".join(seg_list))

        #知识点补充 有时候就算使用自定义词典发现词还是没有被正确分出来 因为分词有个因子是和词频相关的 所以需要进行扩展
        # 使用 add_word(word, freq=None, tag=None)  del_word(word) 可在程序中动态修改词典
        # 使用 suggest_freq(segment, tune=True) 可调节单个词语的词频,使其能(或不能)被分出来

    #动态填充词典中每个词的频率
    def _fillWordFreq(self,dicPath):
        for line in open(dictPath,encoding="utf-8"):
            # 保证自定义的词典一定是不会被拆分的 能分出一个完整的词
            jieba.suggest_freq(segment=line.strip(),tune=True)
            # 从程序效率角度来说 可以用下面这行代码实现
            #[jieba.suggest_freq(line.strip(),tune=True)  for line in open(dictPath,encoding="utf-8")]

    #基于TF-IDF
    def _extractWord_TFIDF(self,str):
        tfidf = analyse.extract_tags
        words = tfidf(str)
        print("keywords by tfidf:")
        for word in words:
            print(word+"/")

    #基于TextRank
    def _extractWord_TextRank(self,str):
        textrank = analyse.textrank
        words = textrank(str)
        print("keywords by textrank:")
        for word in words:
            print(word+"/")

    # 抽取关键字 https://www.cnblogs.com/zhbzz2007/p/6177832.html
    def extractKeyWord(self,str,type):
        if(type=="tfidf"):
            self._extractWord_TFIDF(str)
        if(type=="textrank"):
            self._extractWord_TextRank(str)
        if(type==""):
            print("对不起请输入要抽取转换的类型...")

    # 词性识别
    def posseg(self,str):
        words = posseg.cut(str)
        for w in words:
            print(w.word,w.flag)

if __name__ == "__main__":
    dictPath ="jibea_dic.txt"
    str = "线程是程序执行时的最小单位,它是进程的一个执行流,\
        CPU调度和分派的基本单位,一个进程可以由很多个线程组成,\
        线程间共享进程的所有资源,每个线程有自己的堆栈和局部变量。\
        线程由CPU独立调度执行,在多CPU环境下就允许多个线程同时运行。\
        同样多线程也可以实现并发操作,每个请求分配一个线程来处理。"
    jf = JibeaFunciont(dictPath)
    #jf.cutWord(str)
    jf.loadDict("周围神经浸润、肠道梗阻或穿孔",dictPath)
    #jf.extractWord_TFIDF(str)
    #jf.extractKeyWord(str,"tfidf")
    #jf.extractKeyWord(str,"textrank")
    #jf.posseg(str)

其他框架也可以按照这个来进行学习和掌握.ok 在掌握了这些基础框架之后,就可以做很多其他的功能,这个放在后面再说,关于分词和分词框架的使用就介绍到额,和分词相关的常用算法,放在下一个章节来介绍.

如果自己像深入掌握分词框架,建议可以选择其中一种功能丰富的框架进行源码级别的分析,个人建议可以选择hanlp

你可能感兴趣的:(NPL系列)