如果要从事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地址、Email、URL）、数字（日期，常用中文数量词，罗马数字，科学计数法），中文词汇（姓名、地名处理）等分词处理。
优化的词典存储，更小的内存占用。支持用户词典扩展定义。
针对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:
- 中文分词
- 词性标注
- 命名实体识别
- 关键词提取
- 自动摘要
- 短语提取
- 拼音转换
- 多音字、声母、韵母、声调
- 简繁转换
- 简繁分歧词（简体、繁体、臺灣正體、香港繁體）
- 文本推荐
- 语义推荐、拼音推荐、字词推荐
- 依存句法分析
- 文本分类
- word2vec
- 词向量训练、加载、词语相似度计算、语义运算、查询、KMeans聚类
- 文档语义相似度计算
WORD:
一个Java实现的分布式的中文分词组件，提供了多种基于词典的分词算法，并利用ngram模型来消除歧义。能准确识别英文、数字，以及日期、时间等数量词，能识别人名、地名、组织机构名等未登录词。能通过自定义配置文件来改变组件行为，能自定义用户词库、自动检测词库变化、支持大规模分布式环境，能灵活指定多种分词算法，能使用refine功能灵活控制分词结果，还能使用词频统计、词性标注、同义标注、反义标注、拼音标注等功能。提供了10种分词算法，还提供了10种文本相似度算法，同时还无缝和Lucene、Solr、ElasticSearch、Luke集成。注意：
FOUNDNLP:一个Java本报实现的分词组件,除分词功能之外,也支持自然语言处理相关的功能.关键字提取,生成自动摘要
STANFORENLP:和上面类似,都是除分词之外还提供一些和自然语言处理相关的功能:
上面就把常用的分词组件进行了简单的介绍,因为只要知道每种功能是做什么以及对应的缺点,才能为业务开发做选性支撑,为了看真实的效果,可以把上面的分词器进行封装,然后统一测试:
首先定义一个接口:
/** * 获取文本的所有分词结果, 对比不同分词器结果 */ public interface WordSegmenter { /** * 获取文本的所有分词结果 * @param text 文本 * @return 所有的分词结果，去除重复 */ default public Set<String> seg(String text) { return segMore(text).values().stream().collect(Collectors.toSet()); } /** * 获取文本的所有分词结果 * @param text 文本 * @return 所有的分词结果，KEY 为分词器模式，VALUE 为分词器结果 */ public Map<String, String> segMore(String text); }
然后看下面每个分词组件的实现:
& word分词器
@Override public Map<String, String> segMore(String text) { Map<String, String> 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<String, String> segMore(String text) { Map<String, String> 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<String, String> segMore(String text) { Map<String, String> 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<CoreMap> 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<String, String> segMore(String text) { Map<String, String> map = new HashMap<>(); map.put("FudanNLP", tagger.tag(text)); return map; }
& jieba分词器
private static final JiebaSegmenter JIEBA_SEGMENTER = new JiebaSegmenter(); @Override public Map<String, String> segMore(String text) { Map<String, String> 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<String, String> segMore(String text) { Map<String, String> 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<String, String> segMore(String text) { Map<String, String> 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<String, String> segMore(String text) { Map<String, String> 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<String, String> segMore(String text) { Map<String, String> 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<String, String> segMore(String text) { Map<String, String> 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<String, String> segMore(String text) { Map<String, String> 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<String, Set<String>> contrast(String text){ Map<String, Set<String>> 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<String, Map<String, String>> contrastMore(String text){ Map<String, Map<String, String>> 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<String, Set<String>> 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<String, Map<String, String>> 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
434
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
