基于情感分析的mapreduce

最新推荐文章于 2024-03-23 16:35:37 发布
最新推荐文章于 2024-03-23 16:35:37 发布
阅读量1.2k 收藏 5
点赞数
分类专栏： Hadoopd 文章标签： mapreduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nextstepfans/article/details/76010642
版权 
package dshuju1;

import java.io.IOException;
import java.util.Arrays;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.Reducer.Context;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;



public class dashuju1 {
	
	public static class amapper extends Mapper<LongWritable, Text, Text, Text>{
		@Override
		protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
				throws IOException, InterruptedException {
			String line = value.toString();
			System.out.println(line);
			context.write(new Text(line),new Text("1"));

		
		}
	 }
	
	 public static class amreducer extends Reducer<Text, Text, Text, Text>{
		@Override
		protected void reduce(Text key, Iterable<Text> values,Context context)
				throws IOException, InterruptedException {
//			context.write(new Text("-1"),key);
			context.write(new Text("1"),key);
//			StringBuffer sb = new StringBuffer();
//			for (Text text :values){
//			sb.append(values.iterator().next());
				
//			}
//			context.write(key, new Text("1");
//			context.write(new Text("1"), new Text(sb.toString());
			
		}
	 }
	 
	 public static void main(String[] args) throws Exception {
			Configuration conf = new Configuration();
			Job job = Job.getInstance(conf);
			job.setJarByClass(dashuju1.class);
			
			job.setOutputKeyClass(Text.class);
			job.setOutputValueClass(Text.class);
			
			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(Text.class);
			
			job.setMapperClass(amapper.class);
			job.setReducerClass(amreducer.class);
			
//			
			Path in = new Path("C:/good.txt"); 
	        Path out = new Path("C:/goodmodel");
			
			FileInputFormat.setInputPaths(job, in);
			FileOutputFormat.setOutputPath(job, out);
			
			job.waitForCompletion(true);
			
		}
	

}

package dshuju1;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.Reducer.Context;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;


public class dashuju2 {
	
	static class fenleiMapper extends Mapper<LongWritable, Text, Text, Text>{
		@Override
		protected void map(LongWritable key, Text value, Context context)
				throws IOException, InterruptedException {
			String[] line = value.toString().split("\t");
//			System.out.println(line[0]);
			
			String[] line1 = line[1].split(" ");
//			System.out.println(line1[0]);
			
//			context.write(new Text("1"), new Text("1"));
			for(int i = 0;i < line1.length; i ++){
				int n = 0;
			    for(int j = 0; j < line1[i].toString().length(); j++) {
			        n = (int)line1[i].toString().charAt(j);
			        if((19968 <= n && n <40869)) {
			        	context.write(new Text(line[0] +":" + line1[i]), new Text("1"));
			        }
			    }

				
//				if(line1[i].toString().getClass().getName().equals("java.lang.String")){
//				context.write(new Text(line[0] +":" + line1[i]), new Text("1"));
//				}
			}
//			System.out.println("===============================");
//			System.out.println(a);
//			System.out.println("===============================");
			
			
			
		}
	}
	
	
//	static class fenleiMapper extends Mapper<LongWritable, Text, Text, Text>{
//		@Override
//		protected void map(LongWritable key, Text value, Context context)
//				throws IOException, InterruptedException {
//			String[] line = value.toString().split("\t");
			System.out.println(line[0]);
//			
//			String[] line1 = line[1].split(" ");
			System.out.println(line1[0]);
//			
			context.write(new Text("1"), new Text("1"));
//			for(int i = 0;i < line1.length; i ++){
//				if(line1[i].toString().getClass().getName().equals("java.lang.String")){
//				context.write(new Text(line[0] +":" + line1[i]), new Text("1"));
//				}
//			}
			System.out.println("===============================");
			System.out.println(a);
			System.out.println("===============================");
//			
//			
//			
//		}
//	}
//	
	 static class fenleiReducer extends Reducer<Text, Text, Text, IntWritable>{
		@Override
		protected void reduce(Text key, Iterable<Text> values, Context context)
				throws IOException, InterruptedException {
			int sum = 0;
			for (Text val:values){
				//values里面存放的是单词个数
				sum += Integer.parseInt(val.toString());
//				System.out.println("===============================");
//				System.out.println(sum);
//				System.out.println("===============================");
			}
			context.write(key, new IntWritable(sum));
			//输出标签和每个标签下面的单词数
		}
	}
	
	//主函数
//	 public static boolean run() throws IOException,ClassNotFoundException,InterruptedException 
	public static void main(String[] args) throws Exception 
	 {
		Configuration conf = new Configuration();
		Path in = new Path("C:/model.txt");  
        Path out = new Path("C:/wwwwwwwwwwwwwwwwwwwwwww");
//		String input = "C:\fenlei.txt";
//		String output = "C:\fenlei";
        
        //细节
        FileSystem hdfs = FileSystem.get(conf);  
        if(hdfs.exists(out)) hdfs.delete(out); 
		Job job = Job.getInstance(conf,"fenlei");
		job.setJarByClass(dashuju2.class);
		job.setMapperClass(fenleiMapper.class);
    
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(Text.class);
		job.setReducerClass(fenleiReducer.class);
		
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		
		FileInputFormat.setInputPaths(job, in);
		FileOutputFormat.setOutputPath(job, out);
		
//		FileInputFormat.setInputPaths(job, new Path(args[0]));
//		FileOutputFormat.setOutputPath(job, new Path(args[1]));
		
		job.waitForCompletion(true);
		
	}
	
	

}

package dshuju1;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.Reducer.Context;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.LineReader;


public class dashuju3 {
	
	public static class amapper extends Mapper<LongWritable, Text, Text, Text>{
		@Override
		protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
				throws IOException, InterruptedException {
			String line = value.toString();
			String[] line1 = line.split("\t");
//			System.out.println(line1[0]);
			context.write(new Text(line1[0]),new Text("1"));

		
		}
	 }
	
	 public static class amreducer extends Reducer<Text, Text, Text, Text>{
		 public Map<String,Integer> map;
		 @Override
		protected void setup(Reducer<Text, Text, Text, Text>.Context context) throws IOException, InterruptedException {
//			 Map<String,Integer> map = null ;
//				String sss = "C:/goodbadfenlei.txt";
				Configuration conf = context.getConfiguration();
				String ss = conf.get("ss");
				try {
					map=Utilsss.getMapFormHDFS(ss);
				} catch (Exception e) {
//					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			
		}
		@Override
		protected void reduce(Text key, Iterable<Text> values,Context context)
				throws IOException, InterruptedException {
			String[] label = key.toString().split(":");
//			String aaaa = label[1];
//			System.out.println(key);
//			System.out.println(label[0]);
//			System.out.println(label[1]);
			
//			Integer b= 0;
//			Integer a= 0;
			double tiaojian;
			System.out.println(label[0]);
//			if(label[0].equals("1")){
				//如果map中有标签为1的那组
				if(map.containsKey(key)){
			Integer a = map.get(key.toString());
			Integer b = 0;
			//先取出这个单词出现的次数
			if(label[0].equals("1")){
				//若果这个单词的标签是1
				String labelb = new String("-1"+":" +label[1]);
				
				if(map.containsKey(labelb)){
			//如果含有标签为-1的map的那组
					 b = map.get(labelb.toString());
					//获取-1下面的单词数量
		        }
				double a1 = Integer.parseInt(a.toString());
				double b1 = Integer.parseInt(b.toString());
				tiaojian = (a1+1)/(a1+b1+2);
//				tiaojian = (a+1)/(b+1);
//				System.out.println(tiaojian);
				String tiaojians = String.valueOf(tiaojian);
				context.write(key, new Text(tiaojians));
				
			}else{
				//这组标签为-1的单词
				String labelb = new String("1"+":" +label[1]);
				if(map.containsKey(labelb)){
			//如果含有标签为-1的map的那组
					 b = map.get(labelb.toString());
					//获取-1下面的单词数量
		        }
				double a1 = Integer.parseInt(a.toString());
				double b1 = Integer.parseInt(b.toString());
				tiaojian = (a1+1)/(a1+b1+2);
//				tiaojian = (a+1)/(b+1);
//				System.out.println(tiaojian);
				String tiaojians = String.valueOf(tiaojian);
				context.write(key, new Text(tiaojians));
				
			}
				
				//取出这组标签为1的单词数量
//				String labelb = "-1"+":" +label[1];
				//转换标签,看标签为-1的时候的那组
//				System.out.println(labelb);
//				Integer b= 0;
				
//				Boolean aa = map.containsKey(labelb);
//				 if(map.containsKey(labelb)){
					//如果含有标签为-1的map的那组
//					 b = map.get(labelb.toString());
//				 }
//				}
//				}else{
//					//如果不含有就算了
//				}
				Object a;
//				double a1 = Integer.parseInt(a.toString());
//				double b1 = Integer.parseInt(b.toString());
				
//				System.out.println(a+"==========="+b);
				
//				//计算条件概率
//				tiaojian = a/b;
//				tiaojian = (a1+1)/(a1+b1+2);
//				System.out.println(tiaojian);
//				context.write(key, new Text("tiaojian"));
//			}
//			}else{
//				context.write(key, new Text("tiaojian"));
//			}
//				
//			}else{
//				//如果map中有标签为-1的那组
//				Integer a = map.get(key.toString());
//				//取出这组标签为1的单词数量
//				String labelb = "1"+":" +label[1];
//				//转换标签,看标签为-1的时候的那组
				System.out.println(labelb);
//				Integer b= 0;
//				if(map.containsKey(labelb)){
//					//如果含有标签为1的map的那组
//					 b = map.get(labelb);
//				}else{
//					//如果不含有就算了
//				}
//				double a1 = Integer.parseInt(a.toString());
//				double b1 = Integer.parseInt(b.toString());
//				
//				System.out.println(a+"==========="+b);
//				
//				//计算条件概率
				tiaojian = a/b;
//				tiaojian = (a1+1)/(a1+b1+2);
//				System.out.println(tiaojian);
//				context.write(key, new Text("tiaojian"));
//				
//			}
//			context.write(key, new Text("tiaojian"));
//			
//
		}
		
	 }
	 
	 public static void main(String[] args) throws Exception {
			Configuration conf = new Configuration();
			String sss = "C:/goodbadfenlei.txt";
			conf.set("ss", sss);
			Job job = Job.getInstance(conf);
			job.setJarByClass(dashuju3.class);
			
			job.setOutputKeyClass(Text.class);
			job.setOutputValueClass(Text.class);
			
			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(Text.class);
			
			job.setMapperClass(amapper.class);
			job.setReducerClass(amreducer.class);
			
//			
//			Path in = new Path("C:/jiangshanshan.txt"); 
			Path in = new Path("C:/goodbadfenlei.txt");
	        Path out = new Path("C:/goodbadtiaojian");
	        FileSystem hdfs = FileSystem.get(conf);  
	        if(hdfs.exists(out)) hdfs.delete(out); 
			
			FileInputFormat.setInputPaths(job, in);
			FileOutputFormat.setOutputPath(job, out);
			
			job.waitForCompletion(true);
			
		}
	

}




class Utilsss{
	
	public static Map<String,Integer> getMapFormHDFS(String input) throws Exception{
		Configuration conf = new Configuration();
		Path path = new Path(input);
		FileSystem fs = path.getFileSystem(conf);
		FileStatus[] status = fs.listStatus(path);
		Map<String,Integer> map = new HashMap();
		for(int i= 0;i < status.length;i++){
			if(status[i].isFile()){
				FSDataInputStream infs = fs.open(status[i].getPath());
				LineReader reader = new LineReader(infs,conf);
				Text line = new Text();
				while (reader.readLine(line) > 0){
					String[] temp = line.toString().split("\t");
//					System.out.println("bbbbbbbbbbbbbbbbbbbbbbbbb");
//					System.out.println("取map里面的数据的数组");
//					System.out.println(temp);
//					System.out.println("bbbbbbbbbbbbbbbbbbbbbbbbb");
					
					map.put(temp[0].toString(), Integer.parseInt(temp[1]));
//					map.put(new String("1"), 10);
				}
				reader.close();
			}
		}
		
		
		return map;
	}
}


package dshuju1;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.LineReader;


public class dashuju4 {
	
	public static class amapper extends Mapper<LongWritable, Text, Text, Text>{
		@Override
		protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
				throws IOException, InterruptedException {
			String line = value.toString();
//			System.out.println(line);
			context.write(new Text(line),new Text("1"));

		
		}
	 }
	
	
	 public static class amreducer extends Reducer<Text, Text, Text, Text>{
		 public Map<String,String> map;
		 
		 
		 @Override
		protected void setup(Reducer<Text, Text, Text, Text>.Context context) throws IOException, InterruptedException {
			 Configuration conf = context.getConfiguration();
				String ss = conf.get("sss");
				try {
					map=Utilss.getMapFormHDFS(ss);
//					System.out.println(map);
				} catch (Exception e) {
//					
					e.printStackTrace();
				}
		}
		 
		 
		 
		@Override
		protected void reduce(Text key, Iterable<Text> values,Context context)
				throws IOException, InterruptedException {
//              一下 一切 一室
//			System.out.println(key);
			String[] str = key.toString().split(" ");
			double sum1 = 1.0;
			double sum2 = 1.0;
			ArrayList<Double> sum_good= new ArrayList<Double>();
			ArrayList<Double> sum_bad = new ArrayList<Double>();
			for(int i =0;i<str.length;i++){
				System.out.println(str[i]);
				//int a = Integer.parseInt(line[i])
//				//首先拼接字符串
				String label1 = new String("-1"+":" +str[i]);
//				System.out.println(label1);
				String label2 = new String("1" +":" +str[i]);
				
//				System.out.println(map);
				if(map.containsKey(label1)){
					
					
					//如果坏的评论里面有的话
					String a = map.get(label1);
					double ddd = Double.parseDouble(map.get(label1));
					double ccc = ddd;
					System.out.println(ccc);
					try {
					    double bad = Double.parseDouble(a);
					    sum_bad.add(bad);
					} catch (NumberFormatException e) {
						double bad = 1.0;
					    sum_bad.add(bad);
					}
					//取出坏的评论
//					int bad = Integer.parseInt(a);
//					sum_bad.add(bad);
				
				}else if(map.containsKey(label1)){
//					//如果有好的评论
					String a = map.get(label2);
					try {
						double good = Double.parseDouble(a);
					    sum_good.add(good);
					} 
					catch (NumberFormatException e) {
					    double good = 1.0;
					    sum_good.add(good);
					}
//				}
//					int good = Integer.parseInt(a.toString());
//					sum_good.add(good);
				}else{
					sum_good.add(1.0);
					sum_bad.add(1.0);
				}
				for(int j = 0;j<sum_good.size();j++){
					sum1 = ((double)sum_good.get(j) * sum1);
				}
				for(int j = 0;j<sum_bad.size();j++){
					sum2 = ((double)sum_bad.get(j) * sum2);
				}
//				if(sum1 > sum2){
//					context.write(key, new Text("这是好的话"));
//				}else{
//					context.write(key, new Text("这是坏的话"));
//				}
//				
//				
//				
			}
			System.out.println(sum1+"========="+sum2);
			
			if(sum1 > sum2){
				context.write(key, new Text("这是好的话"));
			}else{
				context.write(key, new Text("这是坏的话"));
			}
//			context.write(new Text("1"),key);

		}
	 }
	 
	 public static void main(String[] args) throws Exception {
			Configuration conf = new Configuration();
			String sss = "C:/goodbadtiaojian.txt";
			conf.set("sss", sss);
			Job job = Job.getInstance(conf);
			job.setJarByClass(dashuju1.class);
			
			job.setOutputKeyClass(Text.class);
			job.setOutputValueClass(Text.class);
			
			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(Text.class);
			
			job.setMapperClass(amapper.class);
			job.setReducerClass(amreducer.class);
			
//			
			Path in = new Path("C:/nishi.txt"); 
//			Path in = new Path("C:/good.txt");
//			Path in = new Path("C:/daye/a.txt");
	        Path out = new Path("C:/nnnnnnnnnnnnsssssssssssss");
	        FileSystem hdfs = FileSystem.get(conf);  
	        if(hdfs.exists(out)) hdfs.delete(out);
			
			FileInputFormat.setInputPaths(job, in);
			FileOutputFormat.setOutputPath(job, out);
			
			job.waitForCompletion(true);
			
		}
	
	

}
class Utilss{
	
	public static Map<String,String> getMapFormHDFS(String input) throws Exception{
		Configuration conf = new Configuration();
		Path path = new Path(input);
		FileSystem fs = path.getFileSystem(conf);
		FileStatus[] status = fs.listStatus(path);
		Map<String,String> map = new HashMap();
		for(int i= 0;i < status.length;i++){
			if(status[i].isFile()){
				FSDataInputStream infs = fs.open(status[i].getPath());
				LineReader reader = new LineReader(infs,conf);
				Text line = new Text();
				while (reader.readLine(line) > 0){
					String[] temp = line.toString().split("\t");
//					System.out.println("bbbbbbbbbbbbbbbbbbbbbbbbb");
//					System.out.println("取map里面的数据的数组");
//					System.out.println(temp);
//					System.out.println("bbbbbbbbbbbbbbbbbbbbbbbbb");
					
					map.put(temp[0].toString(), temp[1].toString());
//					map.put(new String("1"), 10);
				}
				reader.close();
			}
		}
		
		
		return map;
	}
}



倪石
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于文本的情感分析总结
边写边学习
05-26 1万+
本文主要对网上能搜索到的、现有的基于文本的情感分析方法进行总结和归纳。文本会比较零碎。在下一篇文章中，将对零散知识进行整理。最终应包含4个内容： 什么是基于文本的情感分析 常用词典和数据库 自然语言处理流程 深度学习情感分析工具 以下开始正文。 什么是情感分析：对带有情感色彩的主观性文本进行分析、处理、归纳和推理的过程。利用机器提取人们对某人或事物的态度，从而发现潜在的问题用于改进或...
Sentiment_Analysis:英文文章Sentiment_基于Hadoop MapReduce的分析
05-19
＃这是用于文章情感分析的网站 该项目使用Hadoop MaoReduce进行情感分析。 该项目基于预先准备好的情感词典“ emotionCategory.txt”，可以分析一篇文章中不同单词感觉（负，积极，中性）的比例。 您可以直接在IntelliJ Maven中运行此项目，也可以构建此项目的jar并在包含hadoop的docker容器中运行它。 图形用户界面： Hadoop MapReduce Java代码目录：src 前端用户界面：Sentiment_visulization
基于MapReduce的加权朴素贝叶斯并行算法在网络信息情感分析中的应用
03-12
基于MapReduce的加权朴素贝叶斯并行算法在网络信息情感分析中的应用
通过java实现mapreduce来对电影评论内容进行情感分析
mr_fangf的博客
01-08 1327
题目简述 通过mapreduce实现电影评论的情感分析，基于hadoop的分布式集群实现。 代码如下： import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.*; import java
MapReduce模型分析
b0207191的博客
03-26 1191
摘要： MapReduce是一个编程模型以及用来处理和生成大数据集的一个相关实现。用户通过描述一个map函数，处理一组key/value对，进而生成一组key/value对的中间结果，然后描述一个reduce函数，将具有相同key的中间结果进行归并。正如论文所表明的，很多现实世界中的任务都可以用这个模型来表达。 以这种函数式风格写出来的程序在一个由普通机器组成的集群上自动的进行并行化和执行。...
爬取微博评论并处理为绘制情感分布地图
low5252的博客
10-13 1432
直接上代码： #coding=utf-8 from weibopy import WeiboOauth2,WeiboClient import webbrowser import time import re from collections import defaultdict import snownlp from pyecharts.charts import Map import echa...
基于Hadoop Mapreduce 实现酒店评价文本情感分析（python源码+项目说明）.zip
03-09
基于Hadoop Mapreduce 实现酒店评价文本情感分析（python源码+项目说明）.zip基于Hadoop Mapreduce 实现酒店评价文本情感分析（python源码+项目说明）.zip基于Hadoop Mapreduce 实现酒店评价文本情感分析（python...
基于Hadoop Mapreduce 实现酒店评价文本情感分析（python开发源码+项目说明）.zip
03-10
基于Hadoop Mapreduce 实现酒店评价文本情感分析（python开发源码+项目说明）.zip基于Hadoop Mapreduce 实现酒店评价文本情感分析（python开发源码+项目说明）.zip基于Hadoop Mapreduce 实现酒店评价文本情感分析...
Hadoop课程设计-基于Java和mapreduce实现的贝叶斯文本分类器设计
10-07
在实际应用中，这种基于Hadoop和MapReduce的贝叶斯文本分类器可以广泛应用于垃圾邮件过滤、情感分析、新闻分类等场景。它展示了大数据处理和机器学习结合的力量，同时也提供了一个很好的平台，让学生深入理解分布式...
大数据 基于mapreduce
08-31
3. 社交网络分析：分析社交网络中的用户关系、情感分析、话题检测等，帮助理解用户行为和兴趣。 4. 生物信息学：在基因序列比对、疾病模式识别等生物数据分析中，MapReduce能快速处理大量基因数据。 总结，基于...
基于 Spark 的文本情感分析
haungtan07的博客
03-20 1725
文本情感分析是指对具有人为主观情感色彩文本材料进行处理、分析和推理的过程。文本情感分析主要的应用场景是对用户关于某个主题的评论文本进行处理和分析。比如，人们在打算去看一部电影之前，通常会去看豆瓣电影板块上的用户评论，再决定是否去看这部电影。另外一方面，电影制片人会通过对专业论坛上的用户评论进行分析，了解市场对于电影的总体反馈。本文中文本分析的对象为网络短评，为非正式场合的短文本语料，在只考虑...
大数据hadoop期末考核-贝叶斯情感分析
橙子的博客
01-08 876
6）基于训练得到的模型参数（即Nc和Ncw，其中，c表示情感标签类别，c∈{好评，差评}，w∈V，V是“学号_上传文件.data”数据集包含的中文词典集合），对“test.txt”数据集中的各条记录进行“情感标签”判别。wordn”，其中wordi表示当前文本描述中的第i个词，n为当前文本描述中包含的总词数。4）基于Eclipse创建Hadoop工程，需提交工程代码，工程的命名：“NB_学号”，工程中应该应包含一个名”NB.java”的程序，该程序是整合工程的执行入口（包括main()，程序可直接运行）
Hadoop情感分析实验该怎么做
weixin_44185176的博客
01-03 619
![这是提供的材料
第四章：Hadoop编程
06-21
MapReduce Shuffle过程使用MRUnit进行单元测试过程MapReduce 数据压缩：Snappy,Gzip,LZOMapReduce Partitioner,Combiner实现及应用MapReduce编程：实现数据去重，数据二次排序，倒排索引使用MapReduce实现微博情感分析与单元测试使用MapReduce用户终端情况分析与单元测试
MapReduce案例11——影评分析2（三表联合查询）
jin6872115的博客
03-18 3021
题目要求：（MapReduce案例11——影评分析1）为基础现有如此三份数据： 1、users.dat 数据格式为： 2::M::56::16::70072 对应字段为：UserID BigInt, Gender String, Age Int, Occupation String, Zipcode String 对应字段中文解释：用户id，性别，年龄，职业，邮政编码 2、movies....
MapReduce 思想解析
xuanjiewu的专栏
11-28 5046
MapReduce采用"分而治之"的思想，把对大规模数据集的操作，分发给一个主节点管理下的各个分节点共同完成，然后通过整合各个节点的中间结果，得到最终结果。简单地说，MapReduce就是"任务的分解与结果的汇总"。 　　在Hadoop中，用于执行MapReduce任务的机器角色有两个：一个是JobTracker；另一个是TaskTracker，JobTracker是用于调度工作的，一般运行
朴素贝叶斯分类器简单实现文本情感分析
wave2587的博客
08-08 7556
朴素贝叶斯的一般过程： ① 收集数据：可以使用任何方法。 ② 准备数据：需要数值型或者布尔型数据。 ③ 分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好。 ④ 训练算法：计算不同的独立特征的条件概率。 ⑤ 测试算法：计算错误率。 ⑥ 使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。 代码如下：
详解：MapReduce 思想解析
qq_43688472的博客
06-19 1978
MapReduce 思想解析 MapReduce采用"分而治之"的思想，把对大规模数据集的操作，分发给一个主节点管理下的各个分节点共同完成，然后通过整合各个节点的中间结果，得到最终结果。简单地说，MapReduce就是"任务的分解与结果的汇总"。 二：在hadoop中 在Hadoop中，用于执行MapReduce任务的机器角色有两个：一个是JobTracker；另一个是TaskTracker，Jo...
#私藏项目实操分享# Java实现基于朴素贝叶斯的情感词分析
最新发布
2401_83641098的博客
03-23 921
谈到面试，其实说白了就是刷题刷题刷题，天天作死的刷。。。。。为了准备这个“金三银四”的春招，狂刷一个月的题，狂补超多的漏洞知识，像这次美团面试问的算法、数据库、Redis、设计模式等这些题目都是我刷到过的并且我也将自己刷的题全部整理成了PDF或者Word文档（含详细答案解析）66个Java面试知识点架构专题（MySQL，Java，Redis，线程，并发，设计模式，Nginx，Linux，框架，微服务等）+大厂面试题详解（百度，阿里，腾讯，华为，迅雷，网易，中兴，北京中软等）算法刷题（PDF）
基于mapreduece的情感分析及商品推荐国内外研究现状
06-10
目前，基于MapReduce的情感分析及商品推荐已经得到了广泛的研究和应用。以下是国内外的研究现状： 1. 情感分析 （1）国外研究现状 美国斯坦福大学的Andrew Ng等人提出了一种基于MapReduce的情感分析框架，该框架将大规模的数据集分布在多个节点上进行处理，并且使用了支持向量机（SVM）对文本数据进行分类。 （2）国内研究现状 中国人民大学的张涛等人提出了一种基于MapReduce的情感分析方法，在该方法中，使用了朴素贝叶斯分类器对文本数据进行分类，并且使用了Hadoop作为分布式计算平台。 2. 商品推荐 （1）国外研究现状 美国加州大学伯克利分校的Michael Franklin等人提出了一种基于MapReduce的商品推荐算法，该算法使用了协同过滤和随机梯度下降算法，对用户行为数据进行学习和预测。 （2）国内研究现状 中国科学院大学的李华等人提出了一种基于MapReduce的商品推荐算法，该算法使用了基于用户的协同过滤算法和基于项目的协同过滤算法，并且使用了Hadoop作为分布式计算平台。 总之，基于MapReduce的情感分析及商品推荐已经成为了当前热门的研究方向之一，相信在不久的将来，会有更多的研究成果得到应用和推广。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值