基于Hadoop的朴素贝叶斯算法实现

最新推荐文章于 2024-04-26 22:46:43 发布
最新推荐文章于 2024-04-26 22:46:43 发布
阅读量6.3k 收藏 25
点赞数 4
分类专栏： Hadoop 文章标签： hadoop mapreduce Bayes 贝叶斯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Angelababy_huan/article/details/53046151
版权

    贝叶斯分类器的分类原理是通过某对象的先验概率，利用贝叶斯公式计算出其后验概率，即该对象属于某一类的概率，选择具有最大后验概率的类作为该对象所属的类。    

    以下为一个简单的例子：

    数据:天气情况和每天是否踢足球的记录表

日期 踢足球 天气 温度 湿度 风速
1号 否(0) 晴天(0) 热(0) 高(0) 低(0)
2号 否(0) 晴天(0) 热(0) 高(0) 高(1)
3号 是(1) 多云(1) 热(0) 高(0) 低(0)
4号 是(1) 下雨(2) 舒适(1) 高(0) 低(0)
5号 是(1) 下雨(2) 凉爽(2) 正常(1) 低(0)
6号 否(0) 下雨(2) 凉爽(2) 正常(1) 高(1)
7号 是(1) 多云(1) 凉爽(2) 正常(1) 高(1)
8号 否(0) 晴天(0) 舒适(1) 高(0) 低(0)
9号 是(1) 晴天(0) 凉爽(2) 正常(1) 低(0)
10号 是(1) 下雨(2) 舒适(1) 正常(1) 低(0)
11号 是(1) 晴天(0) 舒适(1) 正常(1) 高(1)
12号 是(1) 多云(1) 舒适(1) 高(0) 高(1)
13号 是(1) 多云(1) 热(0) 正常(1) 低(0)
14号 否(0) 下雨(2) 舒适(1) 高(0) 高(1)
15号 ？ 晴天(0) 凉爽(2) 高(0) 高(1)
    需要预测15号，在这种天气情况下是否踢球。

    假设15号去踢球，踢球的概率计算过程如下：

    P(踢球的概率) = 9/14

    P(晴天|踢) = 踢球天数中晴天踢球的次数/踢球次数 = 2/9

    P(凉爽|踢) = 踢球天数中凉爽踢球的次数/踢球次数 = 3/9

    P(湿度高|踢) = 踢球天数中湿度高踢球的次数/踢球次数 = 3/9

    P(风速高|踢) = 踢球天数中风速高踢球的次数/踢球次数 = 3/9

    则15号踢球的概率P = 9/14 * 2/9 * 3/9 * 3/9 * 3/9 = 0.00529

    按照上述步骤还可计算出15号不去踢球的概率P = 5/14 * 3/5 * 1/5 * 4/5 * 3/5 = 0.02057

    可以看出，15号不去踢球的概率大于去踢球的概率，则可预测说，15号不去踢球。

    理解朴素贝叶斯的流程之后，开始设计MR程序。在Mapper中，对训练数据进行拆分，也就是将这条训练数据拆分为类别和训练数据，将训练数据以自定义值类型来保存，然后传递给Reducer。

    Mapper：

public class BayesMapper extends Mapper<Object, Text, IntWritable, MyWritable> {
	Logger log = LoggerFactory.getLogger(BayesMapper.class);
	private IntWritable myKey = new IntWritable();
	private MyWritable myValue = new MyWritable();
	@Override
	protected void map(Object key, Text value, Context context)
			throws IOException, InterruptedException {
		log.info("***"+value.toString());
		int[] values = getIntData(value);
		int label = values[0];  //存放类别
		int[] result = new int[values.length-1]; //存放数据
		for(int i =1;i<values.length;i++){
			result[i-1] = values[i];
		}
		myKey.set(label);
		myValue.setValue(result);
		context.write(myKey, myValue);
		
	}

	private int[] getIntData(Text value) {
		String[] values = value.toString().split(",");
		int[] data = new int[values.length];
		for(int i=0; i < values.length;i++){
			data[i] = Integer.parseInt(values[i]);
		}
		return data;
	}

}
    MyWritable: 

public class MyWritable implements Writable{
	private int[] value;
	public MyWritable() {
		// TODO Auto-generated constructor stub
	}
	public MyWritable(int[] value){
		this.setValue(value);
	}
	@Override
	public void write(DataOutput out) throws IOException {
		out.writeInt(value.length);
		for(int i=0; i<value.length;i++){
			out.writeInt(value[i]);
		}
	}

	@Override
	public void readFields(DataInput in) throws IOException {
		int vLength = in.readInt();
		value = new int[vLength];
		for(int i=0; i<vLength;i++){
			value[i] = in.readInt();
		}
	}
	public int[] getValue() {
		return value;
	}
	public void setValue(int[] value) {
		this.value = value;
	}

}


    Reducer中，需要在setup中初始化测试数据，由于训练数据与测试数据的属性中均只有0,1两种值，因此在reduce中，统计相同类别的不同属性的值的和（也就是统计出现1的次数，0的次数就是用该类别下数据的总和减去出现1的次数）。用对象CountAll来保存当前类别k、在类别k中每个属性出现1的概率、类别k中数据的条数，然后在cleanup中去计算当前测试数据出现哪种类别的概率最大，并设定这个类别为当前测试数据的类别。

public class BayesReducer extends Reducer<IntWritable, MyWritable, IntWritable, IntWritable>{
	Logger log = LoggerFactory.getLogger(BayesReducer.class);
	private String testFilePath;
	// 测试数据
	private ArrayList<int[]> testData = new ArrayList<>();
	// 保存相同k的所有数据
	private ArrayList<CountAll> allData = new ArrayList<>();

	@Override
	protected void setup(Context context)
			throws IOException, InterruptedException {
		Configuration conf = context.getConfiguration();
		testFilePath = conf.get("TestFilePath");
		Path path = new Path(testFilePath);
		FileSystem fs = path.getFileSystem(conf);
		readTestData(fs,path);
	}
	/***
	 * k,v => 0  {{0,1,0,1,0,0,1,...},{},{},...}
	 */
	@Override
	protected void reduce(IntWritable key, Iterable<MyWritable> values,
			Context context)
			throws IOException, InterruptedException {
		Double[] myTest = new Double[testData.get(0).length-1];
		for(int i=0;i<myTest.length;i++){
			myTest[i] = 1.0;
		}
		Long sum = 2L;
		// 计算每个类别中，每个属性值为1的个数
		for (MyWritable myWritable : values) {
			int[] myvalue = myWritable.getValue();
			for(int i=0; i < myvalue.length;i++){
				myTest[i] += myvalue[i];
			}
			sum += 1;
		}
		for(int i=0;i<myTest.length;i++){
			myTest[i] = myTest[i]/sum;
		}
		allData.add(new CountAll(sum,myTest,key.get()));
		
	}
	private IntWritable myKey = new IntWritable();
	private IntWritable myValue = new IntWritable();
	@Override
	protected void cleanup(Context context)
			throws IOException, InterruptedException {
		// 保存每个类别的在训练数据中出现的概率
		// k,v  0,0.4
		// k,v  1,0.6
		HashMap<Integer, Double> labelG = new HashMap<>();
		Long allSum = getSum(allData); //计算训练数据的长度
		for(int i=0; i<allData.size();i++){
			labelG.put(allData.get(i).getK(), 
					Double.parseDouble(allData.get(i).getSum().toString())/allSum);
		}
		//test的长度 要比训练数据中的长度大1
		int sum = 0;
		int yes = 0;
		for(int[] test: testData){
			int value = getClasify(test, labelG);
			if(test[0] == value){
				yes += 1;
			}
			sum +=1;
			myKey.set(test[0]);
			myValue.set(value);
			context.write(myKey, myValue);
		}
		System.out.println("正确率为："+(double)yes/sum);
	}
	/***
	 * 求得所有训练数据的条数
	 * @param allData2
	 * @return
	 */
	private Long getSum(ArrayList<CountAll> allData2) {
		Long allSum = 0L;
		for (CountAll countAll : allData2) {
			log.info("类别："+countAll.getK()+"数据："+myString(countAll.getValue())+"总数："+countAll.getSum());
			allSum += countAll.getSum();
		}
		return allSum;
	}
	/***
	 * 得到分类的结果
	 * @param test
	 * @param labelG
	 * @return
	 */
	private int getClasify(int[] test,HashMap<Integer, Double> labelG ) {
		double[] result = new double[allData.size()]; //以类别的长度作为数组的长度
		for(int i = 0; i<allData.size();i++){
			double count = 0.0;
			CountAll ca = allData.get(i);
			Double[] pdata = ca.getValue();
			for(int j=1;j<test.length;j++){
				if(test[j] == 1){
					// 在该类别中，相同位置上的元素的值出现1的概率
					count += Math.log(pdata[j-1]);
//					count *= pdata[j-1];
				}else{
					count += Math.log(1- pdata[j-1]);
//					count *= (1- pdata[j-1]);
				}
				log.info("count: "+count);
			}
			count += Math.log(labelG.get(ca.getK()));
//			count *= labelG.get(ca.getK());
			result[i] = count;
		}
		// 求出最大的概率
//		int index = 0;
//		double maxValue = Double.MIN_VALUE;
//		log.info("0的概率："+result[0]+"1的概率："+result[1]+"  长度："+result.length);
//		for(int i=0; i< result.length;i++){
//			if(result[i] > maxValue){
//				maxValue = result[i];
//				index = i;
//			}
//		}
//		return allData.get(index).getK();
		if(result[0] > result[1]){
			return 0;
		}else{
			return 1;
		}
	}
	/***
	 * 读取测试数据
	 * @param fs
	 * @param path
	 * @throws NumberFormatException
	 * @throws IOException
	 */
	private void readTestData(FileSystem fs, Path path) throws NumberFormatException, IOException {
		FSDataInputStream data = fs.open(path);
		BufferedReader bf = new BufferedReader(new InputStreamReader(data));
		String line = "";
		while ((line = bf.readLine()) != null) {
			String[] str = line.split(",");
			int[] myData = new int[str.length];
			for(int i=0;i<str.length;i++){
				myData[i] = Integer.parseInt(str[i]);
			}
			testData.add(myData);
		}
		bf.close();
		data.close();
		
	}
	public static String myString(Double[] arr){
		String num = "";
		for(int i=0;i<arr.length;i++){
			if(i==arr.length-1){
				num += String.valueOf(arr[i]);
			}else{
				num += String.valueOf(arr[i])+',';
			}
		}
		return num;
	}
}
    CountAll: 

public class CountAll {
	private Long sum;
	private Double[] value;
	private int k;
	public CountAll(){}
	public CountAll(Long sum, Double[] value,int k){
		this.sum = sum;
		this.value = value;
		this.k = k;
	}
	public Double[] getValue() {
		return value;
	}
	public void setValue(Double[] value) {
		this.value = value;
	}
	public Long getSum() {
		return sum;
	}
	public void setSum(Long sum) {
		this.sum = sum;
	}
	public int getK() {
		return k;
	}
	public void setK(int k) {
		this.k = k;
	}
}

    从Reducer中的getClassify方法中可以看出，考虑了P(ai|c)=0的情况(ai为属性，c为类别)，这里用到了拉普拉斯平滑来解决这个问题，也就是在reduce中初始化属性值和数组myTest时，将其中每个元素的值设定为1，然后将该类别下数据总数sum初始化为2即可。

    由于在计算P(a1|c) * P(a2|c)...*P(an|c)时，如果每个p值都比较小，当属性很多时会出现精度损失的情况，也就是最后每个类别算出的概率都会为0,。这里将其取对数，转换为ln(P(a1|c) * P(a2|c)...*P(an|c)) = ln(P(a1|c)) + ln(P(a2|c)) + ...+ln(P(an|c))，可以避免出现精度损失这种情况。

    

    训练数据中的一部分如下：

1,0,0,0,1,0,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0
1,0,0,1,1,0,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1
1,1,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0
1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,1
1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,0,0
1,0,0,0,1,0,0,0,0,1,0,0,0,1,1,0,1,0,0,0,1,0,1
1,1,0,1,1,0,0,0,1,0,1,0,1,1,0,0,0,0,0,0,0,1,1
1,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1
1,0,0,1,0,0,0,1,1,0,0,0,0,1,0,1,0,0,0,0,0,1,1
1,0,1,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0
1,1,1,0,0,1,0,1,0,0,1,1,1,1,0,0,1,1,1,1,1,0,1
1,1,1,0,0,1,1,1,0,1,1,1,1,0,1,0,0,1,0,1,1,0,0
1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,1
1,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1
1,1,0,1,1,0,0,1,1,1,0,1,1,1,1,1,1,0,1,1,0,1,1
1,0,1,1,0,0,1,1,1,0,0,0,1,1,0,0,1,1,1,0,1,1,1
1,0,0,1,1,0,0,0,1,1,0,0,0,1,1,0,1,0,0,0,0,1,0
1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,0,0,1,0,0,1,1,0
1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0
1,0,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1
1,1,0,0,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,1,1,0,0
1,1,1,0,0,1,1,1,0,0,1,1,1,0,0,0,0,0,0,1,0,0,0
1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0
1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0
1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0
    验证数据中的一部分如下： 

1,1,0,0,1,1,0,0,0,1,1,0,0,0,1,1,1,0,0,1,1,0,0
1,1,0,0,1,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0
1,0,0,0,1,0,1,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,1
1,0,1,1,1,0,0,1,0,1,0,0,1,1,1,0,1,0,0,0,0,1,0
1,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,1,0,0,0,0,0,1
1,0,0,1,1,0,1,0,0,1,0,1,0,1,0,0,1,0,0,0,0,1,1
1,1,0,0,1,0,0,1,1,1,1,0,1,1,1,0,1,0,0,0,1,0,1
1,1,0,0,1,0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0
1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0
1,1,0,0,1,1,1,0,0,1,1,1,0,0,1,0,1,1,0,1,0,0,0
1,1,0,0,0,1,0,0,0,1,1,0,0,1,1,1,0,0,0,1,0,0,0
1,1,0,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0
1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,1
1,1,0,0,0,1,0,0,0,1,1,0,0,0,1,0,0,0,1,1,0,0,0
1,1,0,0,1,1,0,0,0,1,1,0,0,0,0,0,1,0,0,1,1,0,0
1,1,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,1,0
1,1,1,0,0,1,1,1,1,0,1,1,1,1,0,0,0,1,0,0,0,1,1
1,1,0,0,0,0,1,1,0,0,1,1,1,0,0,0,0,1,0,0,0,0,1
1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0
1,1,1,1,0,1,0,1,1,0,1,0,1,1,0,0,1,0,0,0,1,1,0
1,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0
1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,1,1,1
1,0,0,1,1,1,0,0,1,1,1,0,0,1,1,1,1,0,1,0,1,1,0
1,1,1,0,1,1,1,1,0,0,0,1,1,0,0,0,1,1,0,0,1,0,0
1,1,1,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0
1,1,1,0,0,1,1,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0
1,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0
1,1,1,1,1,0,1,1,1,0,1,0,0,1,1,1,1,0,0,1,1,0,0

    由于训练数据只有86条，验证数据有184条，最后预测的正确率为0.8。将训练数据与验证数据调换，预测结果的正确率会更高。

Angelababy_huan
关注
  • 4
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
基于hadoop的朴素贝叶斯分类器
12-19
朴素贝叶斯分类器的代码，还有一些hadoop运行时出现的问题
Hadoop mapreduce 实现NaiveBayes朴素贝叶斯
01-28
Hadoop mapreduce 实现NaiveBayes朴素贝叶斯
机器学习算法及实战——朴素贝叶斯代码实现
weixin_30790841的博客
07-26 380
朴素贝叶斯是经典的机器学习算法之一，也是为数不多的基于概率论的分类算法。朴素贝叶斯原理简单，也很容易实现，多用于文本分类，比如垃圾邮件过滤。 1.算法思想——基于概率的预测 逻辑回归通过拟合曲线（或者学习超平面）实现分类，决策树通过寻找最佳划分特征进而学习样本路径实现分类，支持向量机通过寻找分类超平面进而最大化类别间隔实现分类。相比之下，朴素...
Hadoop介绍：什么是Hadoop？了解Hadoop的应用
最新发布
qq_74350135的博客
04-26 924
Hadoop是一个功能强大、灵活多变的大数据处理框架，它在许多领域都有着广泛的应用前景。随着技术的不断发展和完善，Hadoop将继续为企业和组织提供高效、可靠的大数据解决方案。
【朴素贝叶斯】实战朴素贝叶斯_代码实现_训练算法
云计算?
09-07 168
说一下Train函数的实现。 在上文中，我提到过，朴素贝叶斯也有两种模型：贝努力模型和多项式模型。小弟第一次实现朴素贝叶斯，就老老实实按照基本原理做了一个贝努力模型；多项式模型也不难，变通一下就行。不废话了，直接上代码了，有点长，不过很容易看懂： bool NaiveBayes::Train (const char * sFileSample, int iClassNum, int...
机器学习——朴素贝叶斯代码实现
blinnnnk的博客
11-30 394
代码：链接：https://pan.baidu.com/s/17Cm6Yq99WCT3XB0D19fqGA?pwd=3kfh提取码：3kfh运行结果：判断是正常邮件还是垃圾邮件的概率：判断的结果：反思。
mapreduce 实现朴素贝叶斯算法-源码
06-25
基于hadoop2.0，mapreduce实现朴素贝叶斯算法，源码，NaieBayes 基于hadoop2.0，mapreduce实现朴素贝叶斯算法，源码，NaieBayes
实验题目：基于Hadoop的并行贝叶斯分类算法的设计与实现
03-02
实验题目：基于Hadoop的并行贝叶斯分类算法的设计与实现 实验论文 包括实现方案和截图
基于Hadoop开发实现的朴素贝叶斯文本分类器+源代码+文档说明
12-16
# 基于Hadoop的朴素贝叶斯分类(MapReduce实现) 该项目为Hadoop课程项目，基于MapReduce设计朴素贝叶斯文本分类器，并评估分类结果。 以下简单介绍项目内容与运行说明： ## 项目内容 1. 用MapReduce算法实现贝叶斯...
基于Hadoop架构的文本分类算法.rar
10-14
基于Hadoop的文本分类算法系统，本系统实现了分词处理，停用词处理（IK）；使用朴素贝叶斯分类算法来对文本进行训练和分类，在测试过程中使用词频特征选择作为特征词选择算法，分类准确率达到了78%，包含卡方特征...
朴素贝叶斯代码实现
kaka19880812的专栏
09-18 963
本文讨论了不同类型的朴素贝叶斯模型，并用代码实现了Multinomial Native Bayes
朴素贝叶斯算法matlab代码实现
03-16
关于朴素贝叶斯算法matlab代码实现，简单易懂，有关键注解
基于Hadoop个性化推荐算法设计与实现
06-29
为了提升个性化推荐系统的大数据处理能力,选择基于用户聚类协同过滤的个性化推荐算法,并在Hadoop平台下实现算法的分布式并行化.离线状态下对用户物品矩阵降维,对用户进行聚类得到类别信息列表,对用户在类簇内进行推荐,并在相似度计算内引入物品贡献权重,最后对算法实现并行化得到推荐结果,实现基于用户聚类的分布式协同过滤推荐算法.最后对推荐结果进行测试分析,证明分布式个性化推荐有更好的推荐准确性和实时性.
[MLReview] Naive Bayes 朴素贝叶斯代码实现
gdtop的个人笔记
06-05 1237
朴素贝叶斯
Hadoop平台运用朴素贝叶斯算法进行文档分类总结
行者小朱的博客
05-24 4831
上一篇文章介绍了朴素贝叶斯算法的基本思想，这里主要讲解一下在Hadoop中运用朴素贝叶斯算法进行文档分类的思路。 一、贝叶斯原理 贝叶斯分类算法的理论基于贝叶斯公式，P(B|A)=(P(A|B)P(B))/P(A) ，其中P(A|B)称为条件概率，P(B)先验概率，对应P(B|A)为后验概率。 朴素贝叶斯分类器基于一个简单的假定，即给定的目标值属性之间是相互独立。贝叶斯公式之所以有用是因为在
机器学习——朴素贝叶斯（手动代码实现）
weixin_50348308的博客
06-19 2392
从小菜鸡的试错思考中逐步清晰！ python纯手动实现朴素贝叶斯的算法，对比 sklearn实现的算法，两者结果有差异，但差异不算太大。
朴素贝叶斯算法代码实现（垃圾邮件检测）
qq_52053775的博客
09-23 2497
（1）分词首先需要对文本进行分词操作，转换为list,同时词语全部小写，并去除字母数量小于等于2的单词(2)创建语料表对于每一封邮件，我们需要得到每一封邮件出现的词语，即语料表（3）得到词向量首先初始化一个向量，只要对应词在邮件中出现，相应位置置1，于是我们得到了词向量串联起来：首先读取邮件，得到每个邮件的语料表，然后划分训练集和测试集，得到训练集每个邮件的词向量以及类别（垃圾邮件/非垃圾邮件）
朴素贝叶斯代码实现（超详细）
AI_dataloads的博客
09-18 784
为了可以帮助更好地理解模型的性能，找出模型可能存在的问题，我们要创建一个混淆矩阵的可视。想详细了解贝叶斯算法的，可点击笔者的另一篇文章。导入朴素贝叶斯分类器，实例化贝叶斯分类器分类。使用随机森林分类器进行预测，并打印出分类报告。进行数据预处理，将数据读入，并删除第一行序列。在这里我将写一个简单的贝叶斯代码实现。所以朴素贝叶斯算法使用于大数据样本。训练集与测试集预测，绘制混淆矩阵。样本数量太少，导致结果全为1,。对原始数据集进行切分。
基于hadoop的朴素贝叶斯情感分析
04-11
基于Hadoop的朴素贝叶斯情感分析是一种利用Hadoop技术分析大数据中文文本情感的方法。它主要利用Hadoop的分布式计算能力，通过对大量中文文本数据的分析和运算，得出文本中所表达的情感分类。这种方法可以广泛应用于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值