朴素贝叶斯分类并行化算法

最新推荐文章于 2022-11-30 15:13:50 发布
最新推荐文章于 2022-11-30 15:13:50 发布
阅读量1.9k 收藏 5
点赞数
分类专栏： 大数据 文章标签： 贝叶斯

NaiveBayesMain.java

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.util.GenericOptionsParser;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;

public class NaiveBayesMain
{
	public static void main(String[] args) throws Exception
	{
		Configuration conf = new Configuration();
		String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
		FileSystem fs = FileSystem.get(conf);
		Path path_train, path_temp, path_test, path_out;
		if(otherArgs.length != 5)
		{
			System.err.println("Usage: NaiveBayesMain <dfs_path> <conf> <train> <test> <out>");
			System.exit(2);
		}

		conf.set("conf", otherArgs[0] + "/" +otherArgs[1]);
		conf.set("train", otherArgs[0] + "/" +otherArgs[2]);
		conf.set("test", otherArgs[0] + "/" +otherArgs[3]);
		conf.set("output", otherArgs[0] + "/" +otherArgs[4]);
		
    	put2HDFS(otherArgs[1], otherArgs[0] + "/" + otherArgs[1], conf);
    	put2HDFS(otherArgs[2], otherArgs[0] + "/" + otherArgs[2], conf);
    	put2HDFS(otherArgs[3], otherArgs[0] + "/" + otherArgs[3], conf);
		
		path_train = new Path(otherArgs[0] + "/" + otherArgs[2]);
    	path_temp = new Path(otherArgs[0] + "/" + otherArgs[2] + ".train");
    	path_test = new Path(otherArgs[0] + "/" +otherArgs[3]);
    	path_out = new Path(otherArgs[0] + "/" + otherArgs[4]);
    	
		{
		Job job_train = new Job(conf, "naive bayse training");
		job_train.setJarByClass(NaiveBayesMain.class);
		job_train.setMapperClass(NaiveBayesTrain.TrainMapper.class);
		job_train.setCombinerClass(NaiveBayesTrain.TrainReducer.class);
		job_train.setReducerClass(NaiveBayesTrain.TrainReducer.class);
		job_train.setOutputKeyClass(Text.class);
    	job_train.setOutputValueClass(IntWritable.class);
     	
    	FileInputFormat.setInputPaths(job_train, path_train);
    	if(fs.exists(path_temp))
    		fs.delete(path_temp, true);
    	FileOutputFormat.setOutputPath(job_train, path_temp);
    	if(job_train.waitForCompletion(true) == false)
    		System.exit(1);
    		
    	conf.set("train_result", otherArgs[0] + "/" +otherArgs[2] + ".train");
    	}
    	{
    	Job job_test = new Job(conf, "naive bayse testing");
    	job_test.setJarByClass(NaiveBayesTest.class);
    	job_test.setMapperClass(NaiveBayesTest.TestMapper.class);
    	job_test.setOutputKeyClass(Text.class);
    	job_test.setOutputValueClass(Text.class);
    	
    	FileInputFormat.setInputPaths(job_test, path_test);
    	if(fs.exists(path_out))
    		fs.delete(path_out, true);
    	FileOutputFormat.setOutputPath(job_test, path_out);
    	if(job_test.waitForCompletion(true) == false)
    		System.exit(1);
    	fs.delete(path_temp, true);
    	}
    	
    	getFromHDFS(otherArgs[0] + "/" + otherArgs[4], ".", conf);
    	
    	fs.close();
    	System.exit(0);
	}
	
	
	public static void put2HDFS(String src, String dst, Configuration conf) throws Exception
	{
		Path dstPath = new Path(dst);
		FileSystem hdfs = dstPath.getFileSystem(conf);
		
		hdfs.copyFromLocalFile(false, true, new Path(src), new Path(dst));
		
	}
	
	public static void getFromHDFS(String src, String dst, Configuration conf) throws Exception
	{
		Path dstPath = new Path(dst);
		FileSystem lfs = dstPath.getFileSystem(conf);
		String temp[] = src.split("/");
		Path ptemp = new Path(temp[temp.length-1]);
		if(lfs.exists(ptemp));
			lfs.delete(ptemp, true);
		lfs.copyToLocalFile(true, new Path(src), dstPath);
		
	}
}

NaiveBayesTrain.java 

import java.util.Scanner;
import java.io.IOException;
import java.util.ArrayList;


import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;

public class NaiveBayesTrain
{
	public static class TrainMapper
		extends Mapper<Object, Text, Text, IntWritable>
	{
		public NaiveBayesConf nBConf;
		private final static IntWritable one = new IntWritable(1);
		private Text word;
		
		public void setup(Context context) 
		{
			try{
			nBConf = new NaiveBayesConf();
			Configuration conf = context.getConfiguration();
			nBConf.ReadNaiveBayesConf(conf.get("conf"), conf);
			}
			catch(Exception ex)
			{
				ex.printStackTrace();
				System.exit(1);
			}
			System.out.println("setup");
		}
		public void map(Object key, Text value, Context context)
			throws IOException, InterruptedException 
		{
			Scanner scan = new Scanner(value.toString());
			String str, vals[], temp;
			int i;
			word = new Text();
			while(scan.hasNextLine())
			{
				str = scan.nextLine();
				vals = str.split(" ");
				word.set(vals[0]);
				context.write(word, one);
				for(i = 1; i<vals.length; i++)
				{
					word = new Text();
					temp = vals[0] + "#" + nBConf.proNames.get(i-1);
					temp += "#" + vals[i];
					word.set(temp);					
					context.write(word, one);
				}
			}
		}
	}
	
	public static class TrainReducer
		extends Reducer<Text,IntWritable,Text,IntWritable>
	{
		private IntWritable result = new IntWritable();
		public void reduce(Text key, Iterable<IntWritable> values, 
        	Context context) throws IOException, InterruptedException 
		{
			int sum = 0;
			for (IntWritable val : values) 
			{
				sum += val.get();
			}
			result.set(sum);
			context.write(key, result);
        }
	}
}
NaiveBayesTest.java 

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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;

public class NaiveBayesTest
{
	public static class TestMapper 
		extends Mapper<Object, Text, Text, Text>
	{
		public NaiveBayesConf nBConf;
		public NaiveBayesTrainData nBTData;
		public void setup(Context context)
		{			
			try{
			Configuration conf = context.getConfiguration();
			
			nBConf = new NaiveBayesConf();
			nBConf.ReadNaiveBayesConf(conf.get("conf"), conf);
			nBTData = new NaiveBayesTrainData();
			nBTData.getData(conf.get("train_result"), conf);
			}
			catch(Exception ex)
			{
				ex.printStackTrace();
				System.exit(1);
			}
		}
		
		public void map(Object key, Text value, Context context)
			throws IOException, InterruptedException 
		{
			Scanner scan = new Scanner(value.toString());
			String str, vals[], temp;
			int i,j,k,fxyi,fyi,fyij,maxf,idx;
			Text id;
			Text cls;
			
			while(scan.hasNextLine())
			{
				str = scan.nextLine();
				vals = str.split(" ");
				maxf = -100;
				idx = -1;
				for(i = 0; i<nBConf.class_num; i++)
				{
					fxyi = 1;
					String cl = nBConf.classNames.get(i);
					Integer integer = nBTData.freq.get(cl);
					if(integer == null)
						fyi = 0;
					else
						fyi = integer.intValue();
					for(j = 1; j<vals.length; j++)
					{
						temp = cl + "#" + nBConf.proNames.get(j-1) + "#" + vals[j];
						
						integer = nBTData.freq.get(temp);
						if(integer == null)
							fyij = 0;
						else
							fyij = integer.intValue();
						fxyi = fxyi*fyij;
					}
					if(fyi*fxyi > maxf)
					{
						maxf = fyi*fxyi;
						idx = i;
					}
				}
				id = new Text(vals[0]);
				cls = new Text(nBConf.classNames.get(idx));
				context.write(id, cls);
			}
		}
	}
}

NaiveBayesConf.java 

import java.util.ArrayList;
import java.util.Scanner;
import java.io.File; 
import java.io.FileNotFoundException;

import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.conf.Configuration;

public class NaiveBayesConf
{
	public int dimen;
	public int class_num;
	public ArrayList<String> classNames;
	public ArrayList<String> proNames;
	public ArrayList<Integer>	proRanges;
	
	public NaiveBayesConf()
	{
		dimen = class_num = 0;
		classNames = new ArrayList<String>();
		proNames = new ArrayList<String>();
		proRanges = new ArrayList<Integer>();
	}
	
	public void ReadNaiveBayesConf(String file, Configuration conf) throws Exception
	{	
		Path conf_path = new Path(file);
		FileSystem hdfs = conf_path.getFileSystem(conf);
		FSDataInputStream fsdt = hdfs.open(conf_path);
		Scanner scan = new Scanner(fsdt);
		String str = scan.nextLine();
		String[] vals = str.split(" ");
		
		class_num = Integer.parseInt(vals[0]);
		
		int i;
		
		for(i = 1; i<vals.length; i++)
		{
			classNames.add(vals[i]);
		}
		
		str = scan.nextLine();
		vals = str.split(" ");
		dimen = Integer.parseInt(vals[0]);
		
		for(i = 1; i<vals.length; i+=2)
		{
			proNames.add(vals[i]);
			proRanges.add(new Integer(vals[i+1]));
		}
		fsdt.close();
		scan.close();
	}
}
NaiveBayesTrainData.java 
import java.util.ArrayList;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.File;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.util.HashMap;

import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileStatus;
//功能：读取指定路径下输出文件"part-..."并添加到HashMap
public class NaiveBayesTrainData
{
	public HashMap<String, Integer> freq;

	public NaiveBayesTrainData()
	{
		freq = new HashMap<String, Integer>();
	}

	public void getData(String file, Configuration conf) throws IOException
	{
		int i;
		Path data_path = new Path(file);
		Path file_path;
		String temp[], line;
		FileSystem hdfs = data_path.getFileSystem(conf);
		
		FileStatus[] status = hdfs.listStatus(data_path);
		
		for(i = 0; i<status.length; i++)
		{
			file_path = status[i].getPath();			
			if(hdfs.getFileStatus(file_path).isDir() == true)
				continue;
			line = file_path.toString();
			temp = line.split("/");
			if(temp[temp.length-1].substring(0,5).equals("part-") == false)
				continue;
			System.err.println(line);
			FSDataInputStream fin = hdfs.open(file_path);
			InputStreamReader inr = new InputStreamReader(fin);
			BufferedReader bfr = new BufferedReader(inr);
			while((line = bfr.readLine()) != null)
			{	
				String res[] = line.split("\t");
				freq.put(res[0], new Integer(res[1]));
				System.out.println(line);
			}
			bfr.close();
			inr.close();
			fin.close();
		}
	}
	
}
NBayes.conf 
4 cl1 cl2 cl3 cl4
3 p1 12 p2 16 p3 17

NBayes.train

cl1 5 6 7
cl2 3 8 4
cl1 2 5 2
cl3 7 8 7
cl4 3 8 2
cl4 9 2 7
cl2 1 8 5
cl5 2 9 4
cl3 10 3 4
cl1 4 5 6
cl3 4 6 7


NBayes.test 
1 5 6 7
2 1 8 5
3 2 9 4
4 10 3 4
5 4 5 6
6 3 8 4
7 2 5 2
8 7 8 7
9 3 8 2
10 9 2 7
11 4 6 7
train-map-output.txt 
trainmapinput:cl1 5 6 7
trainmapoutput:<cl1,1>
trainmapoutput:<cl1#p1#5,1>
trainmapoutput:<cl1#p2#6,1>
trainmapoutput:<cl1#p3#7,1>
trainmapinput:cl2 3 8 4
trainmapoutput:<cl2,1>
trainmapoutput:<cl2#p1#3,1>
trainmapoutput:<cl2#p2#8,1>
trainmapoutput:<cl2#p3#4,1>
trainmapinput:cl1 2 5 2
trainmapoutput:<cl1,1>
trainmapoutput:<cl1#p1#2,1>
trainmapoutput:<cl1#p2#5,1>
trainmapoutput:<cl1#p3#2,1>
trainmapinput:cl3 7 8 7
trainmapoutput:<cl3,1>
trainmapoutput:<cl3#p1#7,1>
trainmapoutput:<cl3#p2#8,1>
trainmapoutput:<cl3#p3#7,1>
trainmapinput:cl4 3 8 2
trainmapoutput:<cl4,1>
trainmapoutput:<cl4#p1#3,1>
trainmapoutput:<cl4#p2#8,1>
trainmapoutput:<cl4#p3#2,1>
trainmapinput:cl4 9 2 7
trainmapoutput:<cl4,1>
trainmapoutput:<cl4#p1#9,1>
trainmapoutput:<cl4#p2#2,1>
trainmapoutput:<cl4#p3#7,1>
trainmapinput:cl2 1 8 5
trainmapoutput:<cl2,1>
trainmapoutput:<cl2#p1#1,1>
trainmapoutput:<cl2#p2#8,1>
trainmapoutput:<cl2#p3#5,1>
trainmapinput:cl5 2 9 4
trainmapoutput:<cl5,1>
trainmapoutput:<cl5#p1#2,1>
trainmapoutput:<cl5#p2#9,1>
trainmapoutput:<cl5#p3#4,1>
trainmapinput:cl3 10 3 4
trainmapoutput:<cl3,1>
trainmapoutput:<cl3#p1#10,1>
trainmapoutput:<cl3#p2#3,1>
trainmapoutput:<cl3#p3#4,1>
trainmapinput:cl1 4 5 6
trainmapoutput:<cl1,1>
trainmapoutput:<cl1#p1#4,1>
trainmapoutput:<cl1#p2#5,1>
trainmapoutput:<cl1#p3#6,1>
trainmapinput:cl3 4 6 7
trainmapoutput:<cl3,1>
trainmapoutput:<cl3#p1#4,1>
trainmapoutput:<cl3#p2#6,1>
trainmapoutput:<cl3#p3#7,1>

train-reduce-output.txt

cl1	3
cl1#p1#2	1
cl1#p1#4	1
cl1#p1#5	1
cl1#p2#5	2
cl1#p2#6	1
cl1#p3#2	1
cl1#p3#6	1
cl1#p3#7	1
cl2	2
cl2#p1#1	1
cl2#p1#3	1
cl2#p2#8	2
cl2#p3#4	1
cl2#p3#5	1
cl3	3
cl3#p1#10	1
cl3#p1#4	1
cl3#p1#7	1
cl3#p2#3	1
cl3#p2#6	1
cl3#p2#8	1
cl3#p3#4	1
cl3#p3#7	2
cl4	2
cl4#p1#3	1
cl4#p1#9	1
cl4#p2#2	1
cl4#p2#8	1
cl4#p3#2	1
cl4#p3#7	1
cl5	1
cl5#p1#2	1
cl5#p2#9	1
cl5#p3#4	1
test-mapreduce-output.txt 
1	cl1
10	cl4
11	cl3
2	cl2
3	cl1
4	cl3
5	cl1
6	cl2
7	cl1
8	cl3
9	cl4





爽朗的琪琪
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mpi并行朴素贝叶斯
plmlxy的博客
07-19 190
mpi并行朴素贝叶斯并行朴素贝叶斯 并行朴素贝叶斯 代码如下（示例）： #include <iostream> #include <vector> #include <cstdlib> #include <time.h> #include <mpi.h> #include <cassert> #include <cstring> #include <cmath> #define PI 3.14159265358
数据库中几个常用算法的GPU并行化设计
zhang0311的专栏
11-16 1345
1. Select 2. Sub aggregation 并行对key1进行排序； flag标记：key1的值与上一个值不同时标记为1，相同标记为0； 根据flag的值计算前缀和presum； 根据flag、下标、presum计算出每个sub区域的开始位置，offset； 根据offset分块计算sub aggregation，例如每个CUDA block做一个sub区域的ag...
mapreduce 实现朴素贝叶斯算法-源码
03-27
基于hadoop2.0，mapreduce实现朴素贝叶斯算法，源码，NaieBayes
贝叶斯并行分类分析
nuoline的专栏
11-27 186
1 贝叶斯训练器 所在包：Package org.apache.mahout.classifier.bayes 实现机制 The implementation is divided up into three parts: The Trainer -- responsible for doing the counting of the words and ...
知识点二十九：并行计算
Mr_SCX的博客
02-07 2878
前言 时间复杂度是衡量算法执行效率的一种标准。但是，时间复杂度并不能直接跟性能划等号。在真实的软件开发中，即便在不降低时间复杂度的情况下，也可以通过一些优化手段，提升代码的执行效率。毕竟，对于实际的软件开发来说，即便是像 10%、20% 这样微小的性能提升，也是非常可观的。 算法的目的就是为了提高代码执行的效率。那当算法无法再继续优化的情况下，我们该如何来进一步提高执行效率呢？针对这个问题有一种非...
大数据与商务智能-大数据与商务智能课件-朴素贝叶斯算法的并行化
最新发布
04-10
在大数据的背景下，处理速度和效率成为关键，朴素贝叶斯算法的并行化就显得尤为重要。通过并行计算，我们可以分割大规模数据集，同时在多个处理器或计算机上运行算法，显著提高处理速度，降低计算延迟。 朴素贝叶斯...
基于hadoop的朴素贝叶斯分类器
12-19
朴素贝叶斯分类器是一种基于概率的机器学习算法，它基于贝叶斯定理和特征条件独立假设。在大数据处理领域，结合Hadoop框架可以实现大规模数据集的分类任务。Hadoop是一个开源分布式计算框架，它允许在大量廉价硬件上...
基于Hadoop的朴素贝叶斯分类(MapReduce实现).zip
03-13
本主题聚焦于如何利用Hadoop的MapReduce编程模型实现朴素贝叶斯分类算法，这是一种简单而有效的机器学习方法，尤其适用于文本分类和垃圾邮件过滤等场景。 **Hadoop简介** Hadoop是由Apache基金会开发的一个分布式...
基于Hadoop的分布式朴素贝叶斯文本分类.pdf
08-10
Hadoop的分布式特性使得朴素贝叶斯文本分类可以并行化处理。MapReduce是Hadoop中的并行计算框架，它将大任务分解为多个小任务（Map阶段），然后在分布式集群的各个节点上并行执行，最后再通过Reduce阶段整合结果。在...
基于C#的朴素贝叶斯算法
02-28
朴素贝叶斯算法是一种基于概率理论的分类方法，在机器学习领域广泛应用。它是通过计算每个类别的先验概率和特征条件概率来预测数据属于哪个类别。C#作为.NET框架下的主要编程语言，拥有丰富的数学和统计库，使得实现...
并行算法设计的一般方法
longshengguoji的专栏
12-02 3881
1.串行算法的直接并行化 发掘和利用现有串行算法中的并行性，直接将串行算法改造为并行算法。 由串行算法直接并行化的方法是并行算法设计的最常用方法之一； 不是所有的串行算法都可以直接并行化的； 一个好的串行算法并不能并行化为一个好的并行算法； 许多数值串行算法可以并行化为有效的数值并行算法。 2.重新设计并行算法 从问题本身描述出发，不考虑相应的串行算法，设计一个全新的并行算法 挖掘
关于Hadoop的GenericOptionsParser…
leexurui的专栏
08-29 5849
由于集群为hadoop配置了执行队列，所以如果我们程序写成下面这样的话：           Configuration conf = new Configuration();      String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();       ...........      File
跟我一起学【Hadoop开发】之—— hadoop的GenericOptionsParser类
SunWuKong_Hadoop的博客
07-12 1043
GenericOptionsParser 命令行解析器 是hadoop框架中解析命令行参数的基本类。它能够辨别一些标准的命令行参数，能够使应用程序轻易地指定namenode，jobtracker，以及其他额外的配置资源 有篇日志写的很好，自己就不赘述了：传送门 例子： 最简单的在WordCount中用到了： Configuration conf = new Configuration(...
调用MapReduce对文件各个单词出现的次数进行统计
weixin_56771780的博客
12-30 1339
调用MapReduce对文件各个单词出现的次数进行统计
数据简单处理
好久不见
02-27 931
DEVICE_ID sum(BUSINESS_ID) CLIENT_ID+BUSINESS_ID 101 46 16 101 46 18 101 46 28 102
OpenMP并行优化高斯朴素贝叶斯算法 - 通过身高、体重和肺活量推测性别（机器学习）
admiz的博客
11-20 920
OpenMP并行设计 在串行代码的基础上，OpenMP通过# pragma omp parallel for num_threads(thread_count) 指令，对所有涉及大型数组的for循环进行多线程处理，以此达到并行效果。 用OpenMP进行共享内存并行计算 使用pragma omp parallel for提高训练速度 由于本项目串行需要多次通过for(i=0;i<dataLen;i++)循环遍历整个数组来求值，因此十分适合使用pragma omp parallel for指令来进
搞懂朴素贝叶斯分类算法
糖糖糖豆的博客
09-22 5251
转载- 搞懂朴素贝叶斯分类算法带你搞懂朴素贝叶斯分类算 贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。而朴素朴素贝叶斯分类是贝叶斯分类中最简单，也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到的朴素贝叶斯分类算法，希望有利于他人理解。1 分类问题综述对于分类问题，其实谁都不会陌生，日常生活中我们每天都进行着分类过程。例如，当你
HDFS和MapReduce综合实训（借鉴博主cz学java）
qq_65408326的博客
11-30 1007
HDFS和MapReduce综合实训
Hadoop如何实现关联计算
u012388497的专栏
11-06 753
转贴存档，原帖地址：http://datamachine.iteye.com/admin/blogs/1963256。     选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。      以关联计算为例。      假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单
sparkmllib朴素贝叶斯算法优化
05-24
4. 并行计算：朴素贝叶斯算法的计算过程可以并行化，因此可以使用并行计算技术加速训练过程。 5. 内存优化：在训练过程中，可以使用稀疏矩阵和压缩存储等技术来优化内存使用，以便处理大量特征和数据。 总之，优化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值