自然语言分词处理，词频统计

最新推荐文章于 2023-01-17 12:40:41 发布
最新推荐文章于 2023-01-17 12:40:41 发布
阅读量1.7k 收藏 2
点赞数
分类专栏： 全文检索相关 文章标签： 自然语言 前端 事务 博客
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linhaiyun_ytdx/article/details/77337646
版权

 目标：将一段文字做分词处理，并统计分词中出现频度最高的五组词。

代码：

ToAnalysis.java

package com.test;

import java.io.Reader;
import java.util.ArrayList;
import java.util.List;

import org.ansj.domain.Result;
import org.ansj.domain.Term;
import org.ansj.recognition.arrimpl.AsianPersonRecognition;
import org.ansj.recognition.arrimpl.ForeignPersonRecognition;
import org.ansj.recognition.arrimpl.NumRecognition;
import org.ansj.recognition.arrimpl.UserDefineRecognition;
import org.ansj.splitWord.Analysis;
import org.ansj.util.AnsjReader;
import org.ansj.util.Graph;
import org.ansj.util.NameFix;
import org.ansj.util.TermUtil.InsertTermType;
import org.nlpcn.commons.lang.tire.domain.Forest;

/**
 * 标准分词
 * 
 * @author ansj
 * 
 */
public class ToAnalysis extends Analysis {

	@Override
	protected List<Term> getResult(final Graph graph) {

		Merger merger = new Merger() {
			@Override
			public List<Term> merger() {

				graph.walkPath();

				// 数字发现
				if (isNumRecognition && graph.hasNum) {
					new NumRecognition().recognition(graph.terms);
				}

				// 姓名识别
				if (graph.hasPerson && isNameRecognition) {
					// 亚洲人名识别
					new AsianPersonRecognition().recognition(graph.terms);
					graph.walkPathByScore();
					NameFix.nameAmbiguity(graph.terms);
					// 外国人名识别
					new ForeignPersonRecognition().recognition(graph.terms);
					graph.walkPathByScore();
				}

				// 用户自定义词典的识别
				userDefineRecognition(graph, forests);

				return getResult();
			}

			private void userDefineRecognition(final Graph graph, Forest... forests) {
				new UserDefineRecognition(InsertTermType.SKIP, forests).recognition(graph.terms);
				graph.rmLittlePath();
				graph.walkPathByScore();
			}

			private List<Term> getResult() {
				List<Term> result = new ArrayList<Term>();
				int length = graph.terms.length - 1;
				for (int i = 0; i < length; i++) {
					if (graph.terms[i] != null) {
						result.add(graph.terms[i]);
					}
				}
				setRealName(graph, result);
				return result;
			}
		};
		return merger.merger();
	}

	public ToAnalysis() {
		super();
	}

	public ToAnalysis(Reader reader) {
		super.resetContent(new AnsjReader(reader));
	}
	
	public static Result parse(String str) {
		return new ToAnalysis().parseStr(str);
	}

	public static Result parse(String str, Forest... forests) {
		return new ToAnalysis().setForests(forests).parseStr(str);
	}

}

SameStringCount.java
 

package com.wordcount;

import java.util.HashMap;

public class SameStringCount {
	 private HashMap map;  
	 private int counter;
	 public SameStringCount() {  
	        map = new HashMap<String,Integer>();  
	 }  
	 
	 public void hashInsert(String string) {  
	    if (map.containsKey(string)) {   //判断指定的Key是否存在  
	         counter = (Integer)map.get(string);  //根据key取得value  
	         map.put(string, ++counter);  
	      } else {  
	            map.put(string, 1);  
	    }  
	 } 
	 
	 public HashMap getHashMap(){  
	    return map;  
	 }  
}
Result.java 

package org.ansj.domain;

import java.util.Iterator;
import java.util.List;

import org.ansj.recognition.Recognition;
import org.nlpcn.commons.lang.util.StringUtil;

/**
 * 分词结果的一个封装
 * 
 * @author Ansj
 *
 */
public class Result implements Iterable<Term> {

	private List<Term> terms = null;

	public Result(List<Term> terms) {
		this.terms = terms;
	}

	public List<Term> getTerms() {
		return terms;
	}

	public void setTerms(List<Term> terms) {
		this.terms = terms;
	}

	@Override
	public Iterator<Term> iterator() {
		return terms.iterator();
	}

	public int size() {
		return terms.size();
	}

	public Term get(int index) {
		return terms.get(index);
	}

	/**
	 * 调用一个发现引擎
	 * 
	 * @return
	 */
	public Result recognition(Recognition re) {
		re.recognition(this);
		return this;
	}

	@Override
	public String toString() {
		return toString(",");
	}

	
	public String toString(String split) {
		return StringUtil.joiner(this.terms, split);
	}

	/**
	 * 返回没有词性的切分结果
	 * @return
	 */
	public String toStringWithOutNature(){
		return  toStringWithOutNature(",");
	}
	
	/**
	 * 返回没有词性的切分结果
	 * @return
	 */
	public String toStringWithOutNature(String split) {
		
		if(terms==null || terms.size()==0){
			return "" ;
		}
		
		Iterator<Term> iterator = terms.iterator() ;
		
		StringBuilder sb = new StringBuilder(iterator.next().getRealName()) ;
		
		while(iterator.hasNext()){
			sb.append(split);
			sb.append(iterator.next().getRealName()) ;
		}
		
		return sb.toString();
	}

}

Term.java 

package org.ansj.domain;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.ansj.util.MathUtil;
import org.nlpcn.commons.lang.util.StringUtil;

public class Term implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	// 当前词
	private String name;
	//
	private String realName;
	// 当前词的起始位置
	private int offe;
	// 词性列表
	private TermNatures termNatures = TermNatures.NULL;
	// 词性列表
	private AnsjItem item = AnsjItem.NULL;
	// 同一行内数据
	private Term next;
	// 分数
	private double score = 0;
	// 本身分数
	private double selfScore = 1;
	// 起始位置
	private Term from;
	// 到达位置
	private Term to;
	// 本身这个term的词性.需要在词性识别之后才会有值,默认是空
	private Nature nature = Nature.NULL;
	//是否是一个新词
	private boolean newWord ;
	//同义词
	private List<String> synonyms ;
	

	private List<Term> subTerm = null;

	public Term(String name, int offe, AnsjItem item) {
		super();
		this.name = name;
		this.offe = offe;
		this.item = item;
		if (item.termNatures != null) {
			this.termNatures = item.termNatures;
			if (termNatures.nature != null) {
				this.nature = termNatures.nature;
			}
		}
	}

	public Term(String name, int offe, TermNatures termNatures) {
		super();
		this.name = name;
		this.offe = offe;
		this.termNatures = termNatures;
		if (termNatures.nature != null) {
			this.nature = termNatures.nature;
		}
	}

	public Term(String name, int offe, String natureStr, int natureFreq) {
		super();
		this.name = name;
		this.offe = offe;
		TermNature termNature = new TermNature(natureStr, natureFreq);
		this.nature = termNature.nature;
		this.termNatures = new TermNatures(termNature);
	}

	// 可以到达的位置
	public int toValue() {
		return offe + name.length();
	}

	public int getOffe() {
		return offe;
	}

	public void setOffe(int offe) {
		this.offe = offe;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	/**
	 * 核心构建最优的路径
	 * 
	 * @param term
	 */
	public void setPathScore(Term from, Map<String, Double> relationMap) {
		// 维特比进行最优路径的构建
		double score = MathUtil.compuScore(from, this, relationMap);
		if (this.from == null || this.score == 0 || this.score >= score) {
			this.setFromAndScore(from, score);
		}
	}

	/**
	 * 核心分数的最优的路径,越小越好
	 * 
	 * @param term
	 */
	public void setPathSelfScore(Term from) {
		double score = this.selfScore + from.score;
		// 维特比进行最优路径的构建
		if (this.from == null || this.score > score) {
			this.setFromAndScore(from, score);
		}
	}

	private void setFromAndScore(Term from, double score) {
		this.from = from;
		this.score = score;
	}

	/**
	 * 进行term合并
	 * 
	 * @param term
	 * @param maxNature
	 */
	public Term merage(Term to) {
		this.name = this.name + to.getName();
		if (StringUtil.isNotBlank(this.realName) && StringUtil.isNotBlank(to.getRealName())) {
			this.realName = this.realName + to.getRealName();
		}
		this.setTo(to.to);
		return this;
	}

	/**
	 * 进行term合并,能合并空白字符
	 * 
	 * @param term
	 * @param maxNature
	 */
	public Term merageWithBlank(Term to) {
		this.name = this.name + to.getName();
		this.realName = this.realName + to.getRealName();
		this.setTo(to.to);
		return this;
	}
	
	/**
	 * 更新偏移量
	 * 
	 * @param offe
	 */
	public void updateOffe(int offe) {
		this.offe += offe;
	}

	public Term next() {
		return next;
	}

	/**
	 * 返回他自己
	 * 
	 * @param next
	 *            设置他的下一个
	 * @return
	 */
	public Term setNext(Term next) {
		this.next = next;
		return this;
	}

	public Term from() {
		return from;
	}

	public Term to() {
		return to;
	}

	public void setFrom(Term from) {
		this.from = from;
	}

	public void setTo(Term to) {
		this.to = to;
	}

	/**
	 * 获得这个term的所有词性
	 * 
	 * @return
	 */
	public TermNatures termNatures() {
		return termNatures;
	}

	public void setNature(Nature nature) {
		this.nature = nature;
	}

	/**
	 * 获得这个词的词性.词性计算后才可生效
	 * 
	 * @return
	 */
	public Nature natrue() {
		return nature;
	}

	public String getNatureStr() {
		return nature.natureStr;
	}

	@Override
	public String toString() {
		if ("null".equals(nature.natureStr)) {
			return this.getRealName();
		}	
	  //return this.getRealName() + "/" + nature.natureStr;
		return this.getRealName();    //自己修改的地方(lhy)
	}

	/**
	 * 将term的所有分数置为0
	 */
	public void clearScore() {
		this.score = 0;
		this.selfScore = 0;
	}

	public void setSubTerm(List<Term> subTerm) {
		this.subTerm = subTerm;
		 
	}

	public List<Term> getSubTerm() {
		return subTerm;
	}

	public String getRealName() {
		if (realName == null) {
			return name;
		}
		return realName;
	}

	public void setRealName(String realName) {
		this.realName = realName;
	}

	public double score() {
		return this.score;
	}

	public void score(double score) {
		this.score = score;
	}

	public double selfScore() {
		return this.selfScore;
	}

	public void selfScore(double selfScore) {
		this.selfScore = selfScore;
	}

	public AnsjItem item() {
		return this.item;
	}

	public boolean isNewWord() {
		return newWord;
	}

	public void setNewWord(boolean newWord) {
		this.newWord = newWord;
	}

	public void updateTermNaturesAndNature(TermNatures termNatures) {
		this.termNatures = termNatures;
		this.nature = termNatures.nature ;
	}

	public List<String> getSynonyms() {
		return synonyms;
	}

	public void setSynonyms(List<String> synonyms) {
		this.synonyms = synonyms;
	}
	
}

WordCount.java 

package com.wordcount;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.ansj.splitWord.analysis.ToAnalysis;
import org.ansj.util.MyStaticValue;

/*
 * 功能：分词频度最高的五组词，和对应的频度
 * 作者：lhy
 * 时间：2017年8月17日
 */
public class WordCount {
    public HashMap<String , Integer> getGarticiples(String str){
		MyStaticValue.isNumRecognition = true ;
		MyStaticValue.isQuantifierRecognition = false ;
		String[]ss;
		String s = ToAnalysis.parse(str).toString(); 
		ss = s.split(",");
		SameStringCount Count = new SameStringCount();
		
		String regex = "([\u4e00-\u9fa5]+){2,10}";    //匹配两个以上中文的正则表达式
		for(int i=0; i<ss.length; i++){
			boolean flag = match(regex, ss[i].toString());
			if(flag){
				Count.hashInsert(ss[i]);   //添加该分词
			}
		}
		
		HashMap map = Count.getHashMap();
		HashMap<String, Integer> news = new HashMap<String,Integer>();      //定义一个新的哈希图来保存分词
	    String temp ;
	    List<Map.Entry<String,Integer>> list=new ArrayList<>();   
	    list.addAll(map.entrySet());  
	    WordCount.ValueComparator vc=new ValueComparator();  
	    Collections.sort(list,vc);      //分词频度的排序
	    int num = 0;
	    Iterator<Map.Entry<String, Integer>> it = list.iterator();
	    while (it.hasNext()) {
	       if(num == 5){
	    	   break;
	       }
	       Map.Entry<String, Integer> entry = it.next();
//	       System.out.println("key=" + entry.getKey() + ",value=" + entry.getValue());
	       news.put(entry.getKey(), entry.getValue());
	       num++;
	   }
	    return news;     //返回频度最高的五组词
    }
    
	//正则表达式的判定
	private static boolean match(String regex, String str) {
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(str);
		return matcher.matches();
    }
	
	 private static class ValueComparator implements Comparator<Map.Entry<String,Integer>> {  
	    public int compare(Map.Entry<String,Integer> m,Map.Entry<String,Integer> n){  
		      return n.getValue()-m.getValue();  
		 }  
	 }  
}


WordDegrees.java 

package com.wordcount;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.ansj.splitWord.analysis.ToAnalysis;
import org.ansj.util.MyStaticValue;

/*
 * 功能：分词频度最高的五组词,返回五组词，空格相连
 * 作者：lhy
 * 时间：2017年8月17日
 */
public class WordDegrees {
    public String WordProcessing(String str){
		MyStaticValue.isNumRecognition = true ;
		MyStaticValue.isQuantifierRecognition = false ;
		String[]ss;
		String s = ToAnalysis.parse(str).toString(); 
		ss = s.split(",");
		SameStringCount Count = new SameStringCount();
		
		String regex = "([\u4e00-\u9fa5]+){2,10}";    //匹配两个以上中文的正则表达式
		for(int i=0; i<ss.length; i++){
			boolean flag = match(regex, ss[i].toString());
			if(flag){
				Count.hashInsert(ss[i]);   //添加该分词
			}
		}
		
		HashMap map = Count.getHashMap();
	    String temp ;
	    List<Map.Entry<String,Integer>> list=new ArrayList<>();   
	    list.addAll(map.entrySet());  
	    WordDegrees.ValueComparator vc=new ValueComparator();  
	    Collections.sort(list,vc);      //分词频度的排序
	    int num = 0;
	    String key="";    //存放五组分词的字符串
	    Iterator<Map.Entry<String, Integer>> it = list.iterator();
	    while (it.hasNext()) {
	       if(num == 5){
	    	   break;
	       }
	       Map.Entry<String, Integer> entry = it.next();
//	       System.out.println("key=" + entry.getKey() + ",value=" + entry.getValue());
	       key +=entry.getKey().toString()+" ";
	       num++;
	   }
	    return key;     //返回频度最高的五组词
    }
    
	//正则表达式的判定
	private static boolean match(String regex, String str) {
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(str);
		return matcher.matches();
    }
	
	 private static class ValueComparator implements Comparator<Map.Entry<String,Integer>> {  
	    public int compare(Map.Entry<String,Integer> m,Map.Entry<String,Integer> n){  
		      return n.getValue()-m.getValue();  
		 }  
	 }  
}

Test.java 

package com.wordcount;

import java.util.HashMap;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	   String str = "《热爱生命》,可以说是汪国真的代表作之一,这首诗以四个肯定的回答表达出为何要热爱生命的哲理.四个段落,看似相似,却各有其趣.四个段落分别以“成功”、“爱情”、“奋斗历程”和“未来”为意象进行分析和回答.这四个意象可以说是包括汪国真、席慕容在内的一些清新哲理派诗人惯用的几个意象,不晦涩,不故弄玄虚,不生僻难解,可以说是完全区别于朦胧诗的特点,也是汪国真的诗歌取得成功之原因所在.";
	   
	   //第一种方式
	   WordCount word = new WordCount();
	   HashMap<String, Integer> hash = word.getGarticiples(str);
	   System.out.println("第一种方式：");
	   System.out.println(hash);
	   
	   //第二种方式
	   System.out.println("第二种方式：");
	   WordDegrees degre = new WordDegrees();
	   String result = degre.WordProcessing(str);
	   System.out.println(result); 
	}

}

截图：




总结：主要是借鉴别人的开源项目，自己添加的一个功能。



潇潇雨歇_
关注
专栏目录
自然语言------结巴(jieba)、词云(wordcloud)和词频统计（TfidfVectorizer）
m0_47405013的博客
12-21 416
1. 结巴 words='天王盖地虎我在山中走' d=jieba.cut(words,cut_all=False) dd=list(d) print(dd) print(' '.join(dd)) print('--------------------------') d1 = jieba.cut(words, cut_all=True) dd1=list(d1) print(dd1) print(' '.join(dd1)) print('------------------------------')
python英文分词统计词频_数据分析-词频统计-nltk自然语言处理
weixin_39797758的博客
11-24 787
读取数据由于我们之前是吧每个职位都存储为单个的csv文件，所以我们先把它们的details职位要求细节信息读取出来。代码如下，具体说明参照之前的文章。#cell-1定义读取细节的函数defreadDetail(fileName):withopen(fileName,'r')asf:job=json.load(f)details=job['details'].lower()det...
自然语言理解 之 统计词频
weixin_30293135的博客
12-03 95
统计词频，中文字体编码格式：GB2312。 1 #include <iostream> 2 #include <fstream> 3 #include <algorithm> 4 #include <functional> 5 #include <string> 6 #include <vec...
【自然语言处理】最简单的词频统计
Bobby's Blog
08-29 1168
因为NLTK库的出现，词频统计的方法更简单，结果也更加准确，NLTK的使用可参考：【自然语言处理】词性标注 在对英文文章实现较为简单的词频统计时，我们可以从以下几个细节入手 英文中两个词之间一定有空格隔开 对英文文章应该先进行小写处理 分词后带有逗号、句号等标点符号的词应该去标点符号 词频较小的词（比如<=3）可以忽略掉 核心代码如下：（contents是一个列表，每个元素是txt文件的每一行） import string dic = {} t = [] for line in contents
python 中自然语言处理（中文）——统计词频
fennvde007的专栏
05-16 5787
今天做统计词频，看了python自然语言处理的那本书。
NLP自然语言处理实战(三):词频背后的语义--2.隐性语义分析及奇异值分解
weixin_44288092的博客
10-16 874
LSA,SVD
python小项目+自然语言处理+词频统计
最新发布
08-14
在获取到PDF中的文本后，项目会采用自然语言处理（NLP）技术，如jieba（针对中文）等分词工具，对文本进行分词处理。随后，通过统计每个词汇出现的频率，生成词频表。这一过程不仅能帮助用户快速了解文档中的关键...
自然语言处理/词频统计/宋词生成/段落生成/句子分词/源代码/课设
11-11
自然语言处理（Natural Language Processing, NLP）是计算机科学领域的一个重要分支，它涉及如何让计算机理解、生成和处理人类的自然语言。在这个项目中，我们关注的是几个关键的NLP任务，包括词频统计、宋词生成、...
execise two.zip_popularoqi_中文词频统计_文本分词及词频统计
09-23
在“execise two.zip_popularoqi_中文词频统计_文本分词及词频统计”这个项目中，我们关注的是使用C++编程语言来设计和实现一个面向对象的中文文本处理系统，其核心功能包括中文文本的分词以及词频统计。下面将详细...
基于搜狗搜索日志的CompKey竞争性关键词算法实现，NLP分词 词频统计
06-08
【作品名称】：基于搜狗搜索日志的CompKey竞争性关键词算法实现，NLP分词 词频统计 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 ...
文本分类之词频统计（分词、词干提取、去停用词、计算词频，有界面）
05-12
主要是读取文本，然后进行分词、词干提取、去停用词、计算词频，有界面，很实用
学习NLP的第10天——文章关键词提取：词频统计
12-22
关键词提取是词语颗粒度的信息抽取的一种重要的需求，即提取文章中重要的词语。 关键词提取的常用方法包括词频统计、TF-IDF和TextRank等。 其中，词频和TextRank属于单文档算法，即只需一篇文章即可提取出其中的关键词；而TF-IDF则属于多文档宣发，需要其他文档的辅助来提取当前文章的关键词。 词频统计的Python实现 词频统计的逻辑是：在一篇文章中，越重要的关键词往往会在文章中反复出现；因为为了解释关键词，作者经常会反复地提及它们。所以通过统计文章中各个词语的出现频率，即可初步地获得关键词。 但是因为齐夫定律，文章中出现频率最高的往往并不是长度较长的关键词，而是标点符号和助词等，因
NLP自然语言处理实战(三):词频背后的语义--1.从词频到主题得分
weixin_44288092的博客
10-14 814
semantic parsing、TF-IDF、topic vector、LDA
分词统计频率和个数
qq_41972336的博客
07-02 1047
from sklearn.feature_extraction import DictVectorizer as D from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer from sklearn.preprocessing import MaxAbsScaler import jieba A=op...
JAVA开源中文分词器Ansj(依赖注入+调用方式+停词器)
JAVA小白的博客
01-14 4084
Java有11大开源中文分词器，分别是word分词器，Ansj分词器，Stanford分词器，FudanNLP分词器，Jieba分词器，Jcseg分词器，MMSeg4j分词器，IKAnalyzer分词器，Paoding分词器，smartcn分词器，HanLP分词器。 不同的分词器有不同的用法，定义的接口也不一样，至于效果哪个好，那要结合自己的应用场景自己来判断。 这里我就主要介绍Ansj中文分词器...
开源 Java 中文分词器 Ansj 作者孙健专访
小飞侠的博客
12-17 341
Ansj 是一个开源的 Java 中文分词工具，基于中科院的 ictclas 中文分词算法，比其他常用的开源分词工具（如mmseg4j）的分词准确率更高。 在线演示：http://ansj.sdapp.cn/demo/seg.jsp 官网地址：http://www.ansj.org/ Github地址：https://github.com/ansjsun/ansj_seg 我们本期采访...
自然语言处理之词典分词
qq_53429705的博客
08-28 2203
目录 2. 词典分词 2.1 什么是词 2.2 词典 2.3 切分算法 2.4 字典树 2.5 基于字典树的其它算法 2.6 HanLP的词典分词实现 2. 词典分词 中文分词：指的是将一段文本拆分为一系列单词的过程，这些单词顺序拼接后等于原文本。 中文分词算法大致分为基于词典规则与基于机器学习这两大派。 2.1 什么是词 在基于词典的中文分词中，词的定义要现实得多：词典中的字符串就是词。 词的性质–齐夫定律：一个单词的词频与它的词频排名成反比。 2.2 词典 互联网词库(SogouW，
【自然语言处理】基于词典的分词方法
ayaishere_的博客
01-17 817
自然语言处理之基于词典的分词方法
验一 中文分词和词频统计
05-15
中文分词是将一段中文文本分割成词语的过程。词频统计是统计一段文本中每个词语出现的次数。这两个任务在自然语言处理中非常常见，也是很多NLP任务的基础。 常用的中文分词工具有：jieba、pkuseg、thulac等。这些工具都可以将一段中文文本分割成词语，并且提供了不同的分词模式和参数设置，可以根据具体的任务需求进行调整。 词频统计可以通过词袋模型来实现，即将一段文本中的所有词语看作一个集合，统计每个词语在集合中出现的次数。常用的词频统计工具有Python中的collections模块和numpy库中的bincount函数。除了简单的词频统计，还可以使用TF-IDF等方法来计算词语的重要性。 综上，中文分词和词频统计是自然语言处理中非常基础的任务，也是很多NLP任务的基础。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潇潇雨歇_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值