Naive Bayes在mapreduce上的实现

最新推荐文章于 2024-10-31 16:17:19 发布
最新推荐文章于 2024-10-31 16:17:19 发布
阅读量109 收藏
点赞数
文章标签： 大数据 java
原文链接：http://www.cnblogs.com/sunrye/p/4553732.html
版权
Naive Bayes是比较常用的分类器，因为思想比较简单。之所以说是naive，是因为他假设用于分类的特征在类确定的条件下是条件独立的，这个假设使得分类变得很简单，但会损失一定的精度。
具体推导可以看《统计学习方法》
经过推导我们可知y=argMaxP(Y=ck)*P(X=x|Y=ck)。那么我们需要求先验概率也就是P（Y=ck）和求条件概率p(X=x|Y=ck).
具体的例子以：http://blog.163.com/jiayouweijiewj@126/blog/static/1712321772010102802635243/来说明。
我这里一共用了4个mapreduce，因为采用了多项式模型，先验概率P(c)= 类c下单词总数/整个训练样本的单词总数。类条件概率P(tk|c)=(类c下单词tk在各个文档中出现过的次数之和+1)/(类c下单词总数+|V|)（|V|是单词种类数）。输入是：
1:Chinese Beijing Chinese
1:Chinese Chinese Shanghai
1:Chinese Macao
0:Tokyo Japan Chinese
1 一个mapreduce是用于求在各个类别下的单词数，这个是为了后面求先验概率用的。
输出为：
0              3
1              8
 
2 一个mapreduce用于求条件概率，输出为：
0:Chinese               0.2222222222222222
0:Japan   0.2222222222222222
0:Tokyo 0.2222222222222222
1:Beijing 0.14285714285714285
1:Chinese               0.42857142857142855
1:Macao 0.14285714285714285
1:Shanghai            0.14285714285714285
 
3 一个mapreduce用于计算单词种类数，输出为：
num is 6
4 最后一个mapreduce是用于预测的。
 
下面说下各个mapreduce的实现：
1 求各个类别下的单词数，这个比较简单，就是以类别为key，然后进行单词统计就好。
 附上代码： 
 1 package hadoop.MachineLearning.Bayes.Pro;
 2 
 3 
 4 
 5 import org.apache.hadoop.conf.Configuration;
 6 import org.apache.hadoop.fs.Path;
 7 import org.apache.hadoop.io.IntWritable;
 8 import org.apache.hadoop.io.Text;
 9 import org.apache.hadoop.mapreduce.Job;
10 import org.apache.hadoop.mapreduce.Mapper;
11 import org.apache.hadoop.mapreduce.Reducer;
12 import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
13 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
14 
15 public class PriorProbability {//用于求各个类别下的单词数，为后面求先验概率
16 
17     public static void main(String[] args) throws Exception {
18         Configuration conf = new Configuration();
19         String input="hdfs://10.107.8.110:9000/Bayes/Bayes_input/";
20         String output="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Pro/";
21         Job job = Job.getInstance(conf, "ProirProbability");
22         job.setJarByClass(hadoop.MachineLearning.Bayes.Pro.PriorProbability.class);
23         // TODO: specify a mapper
24         job.setMapperClass(MyMapper.class);
25         //job.setMapInputKeyClass(LongWritable.class);
26         // TODO: specify a reducer
27         job.setMapOutputKeyClass(Text.class);
28         job.setMapOutputValueClass(Text.class);
29         job.setReducerClass(MyReducer.class);
30 
31         // TODO: specify output types
32         job.setOutputKeyClass(Text.class);
33         job.setOutputValueClass(IntWritable.class);
34 
35         // TODO: specify input and output DIRECTORIES (not files)
36         FileInputFormat.setInputPaths(job, new Path(input));
37         FileOutputFormat.setOutputPath(job, new Path(output));
38 
39         if (!job.waitForCompletion(true))
40             return;
41     }
42 
43 }
44 
45 
46 package hadoop.MachineLearning.Bayes.Pro;
47 
48 import java.io.IOException;
49 
50 import org.apache.hadoop.io.LongWritable;
51 import org.apache.hadoop.io.Text;
52 import org.apache.hadoop.mapreduce.Mapper;
53 import org.apache.hadoop.mapreduce.Mapper.Context;
54 
55 public class MyMapper extends Mapper<LongWritable, Text, Text, Text> {
56 
57     public void map(LongWritable ikey, Text ivalue, Context context)
58             throws IOException, InterruptedException {
59         String[] line=ivalue.toString().split(":| ");
60         int size=line.length-1;
61         context.write(new Text(line[0]),new Text(String.valueOf(size)));
62     }
63 
64 }
65 
66 
67 package hadoop.MachineLearning.Bayes.Pro;
68 
69 import java.io.IOException;
70 
71 import org.apache.hadoop.io.IntWritable;
72 import org.apache.hadoop.io.Text;
73 import org.apache.hadoop.mapreduce.Reducer;
74 import org.apache.hadoop.mapreduce.Reducer.Context;
75 
76 public class MyReducer extends Reducer<Text, Text, Text, IntWritable> {
77 
78     public void reduce(Text _key, Iterable<Text> values, Context context)
79             throws IOException, InterruptedException {
80         // process values
81         int sum=0;
82         for (Text val : values) {
83             sum+=Integer.parseInt(val.toString());
84         }
85         context.write(_key,new IntWritable(sum));
86     }
87 
88 }

 

 
 
2 求文档中的单词种类数，自己实现的方法不太好，思路是，对每一行的输入都以相同的key输出，然后在combiner中先利用set求得该节点上的不重复的单词，接着在reduce中再利用set，将所有单词求种类数。感觉好一点的话是先按照单词进行规约，最后再利用一个mapreduce对单词种类数进行统计。但是考虑到刚学会mapreduce不久还不会写链式，而且一个bayes已经写了4个mapreduce就不考虑再复杂化了。 
package hadoop.MachineLearning.Bayes.Count;

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

public class Count {//计算文档中的单词种类数目

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "Count");
        String input="hdfs://10.107.8.110:9000/Bayes/Bayes_input";
        String output="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Count";
        job.setJarByClass(hadoop.MachineLearning.Bayes.Count.Count.class);
        // TODO: specify a mapper
        job.setMapperClass(MyMapper.class);
        // TODO: specify a reducer
        job.setCombinerClass(MyCombiner.class);
        job.setReducerClass(MyReducer.class);
        
        // TODO: specify output types
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        // TODO: specify input and output DIRECTORIES (not files)
        FileInputFormat.setInputPaths(job, new Path(input));
        FileOutputFormat.setOutputPath(job, new Path(output));

        if (!job.waitForCompletion(true))
            return;
    }

}


package hadoop.MachineLearning.Bayes.Count;

import java.io.IOException;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class MyMapper extends Mapper<LongWritable, Text, Text, Text> {

    public void map(LongWritable ikey, Text ivalue, Context context)
            throws IOException, InterruptedException {
        String[] line=ivalue.toString().split(":| ");
        String key="1";
        System.out.println("   ");
        System.out.println("   ");
        System.out.println("   ");
        for(int i=1;i<line.length;i++){
            
            System.out.println(line[i]);
            context.write(new Text(key),new Text(line[i]));//以相同的key进行输出，使得能最后输出到一个reduce中
        }
    }

}



package hadoop.MachineLearning.Bayes.Count;

import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class MyCombiner extends Reducer<Text, Text, Text, Text> {//先在本地的节点上利用set删去重复的单词

    public void reduce(Text _key, Iterable<Text> values, Context context)
            throws IOException, InterruptedException {
        // process values
        Set set=new HashSet();
        for (Text val : values) {
            set.add(val.toString());
        }
        for(Iterator it=set.iterator();it.hasNext();){
            context.write(new Text("1"),new Text(it.next().toString()));
        }
    }

}

package hadoop.MachineLearning.Bayes.Count;

import java.io.IOException;
import java.util.HashSet;
import java.util.Set;

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

public class MyReducer extends Reducer<Text, Text, Text, Text> {//通过combiner后，再利用set对单词进行去重，最后得到种类数

    public void reduce(Text _key, Iterable<Text> values, Context context)
            throws IOException, InterruptedException {
        // process values
        Set set=new HashSet();
        for (Text val : values) {
            set.add(val.toString());
        }
        context.write(new Text("num is "),new Text(String.valueOf(set.size())));
    }

}

 

 
 
3 求条件概率.这里需要用到该类别下该单词的数目sum,该类别下的单词总数，文档中的单词种类数。这些都可以在之前的输出文件中获得，我这里都用map去接受这些数据。由于有些单词没有出现在该类别下，例如P(Japan | yes)=P(Tokyo | yes)，如果将他们当作0处理，那么导致该条件概率会是0，所以这里用了平滑的方法可以参考上述的链接。这里有个细节，就是条件概率生成的会比较多，需要一种高效的存储和查找方式，我这里因为水平不够，就直接用map来存放了，如果对于大的数据，这个会很低效。
  
package hadoop.MachineLearning.Bayes.Cond;

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

public class CondiPro {//用于求条件概率

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        String input="hdfs://10.107.8.110:9000/Bayes/Bayes_input";
        String output="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Con";
        String proPath="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Pro";//这是之前求各个类别下单词数目的输出
        String countPath="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Count";//这是之前求的单词种类数
        conf.set("propath",proPath);
        conf.set("countPath",countPath);
        Job job = Job.getInstance(conf, "ConditionPro");
        
        job.setJarByClass(hadoop.MachineLearning.Bayes.Cond.CondiPro.class);
        // TODO: specify a mapper
        job.setMapperClass(MyMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        // TODO: specify a reducer
        job.setReducerClass(MyReducer.class);

        // TODO: specify output types
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        // TODO: specify input and output DIRECTORIES (not files)
        FileInputFormat.setInputPaths(job, new Path(input));
        FileOutputFormat.setOutputPath(job, new Path(output));

        if (!job.waitForCompletion(true))
            return;
    }

}

package hadoop.MachineLearning.Bayes.Cond;

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

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

public class MyMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    
    public void map(LongWritable ikey, Text ivalue, Context context)
            throws IOException, InterruptedException {
        String[] line=ivalue.toString().split(":| ");
        for(int i=1;i<line.length;i++){
            String key=line[0]+":"+line[i];
            context.write(new Text(key),new IntWritable(1));
        }
    }

}

package hadoop.MachineLearning.Bayes.Cond;

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

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

public class MyReducer extends Reducer<Text, IntWritable, Text, DoubleWritable> {
    public Map<String,Integer> map;
    public int count=0;
    public void setup(Context context) throws IOException{
        Configuration conf=context.getConfiguration();
        
        String proPath=conf.get("propath");
        String countPath=conf.get("countPath");//
        map=Utils.getMapFormHDFS(proPath);//获得各个类别下的单词数
        count=Utils.getCountFromHDFS(countPath);//获得单词种类数
    }
    public void reduce(Text _key, Iterable<IntWritable> values, Context context)
            throws IOException, InterruptedException {
        // process values
        int sum=0;
        for (IntWritable val : values) {
            sum+=val.get();
        }
        int type=Integer.parseInt(_key.toString().split(":")[0]);
        double probability=0.0;
        for(Map.Entry<String,Integer> entry:map.entrySet()){
            if(type==Integer.parseInt(entry.getKey())){
                probability=(sum+1)*1.0/(entry.getValue()+count);//条件概率的计算
            }
        }
        context.write(_key,new DoubleWritable(probability));
    }

}

package hadoop.MachineLearning.Bayes.Cond;

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.Text;
import org.apache.hadoop.util.LineReader;

public class Utils {

    /**
     * @param args
     * @throws IOException 
     */
    
    public static Map<String,Integer> getMapFormHDFS(String input) throws IOException{
        Configuration conf=new Configuration();
        Path path=new Path(input);
        FileSystem fs=path.getFileSystem(conf);
        
        FileStatus[] stats=fs.listStatus(path);
        Map<String,Integer> map=new HashMap();
        for(int i=0;i<stats.length;i++){
            if(stats[i].isFile()){
                FSDataInputStream infs=fs.open(stats[i].getPath());
                LineReader reader=new LineReader(infs,conf);
                Text line=new Text();
                while(reader.readLine(line)>0){
                    String[] temp=line.toString().split("    ");
                    //System.out.println(temp.length);
                    map.put(temp[0],Integer.parseInt(temp[1]));
                }
                reader.close();
            }
        }
        
        return map;
    
    }
    
    public static Map<String,Double> getMapFormHDFS(String input,boolean j) throws IOException{
        Configuration conf=new Configuration();
        Path path=new Path(input);
        FileSystem fs=path.getFileSystem(conf);
        
        FileStatus[] stats=fs.listStatus(path);
        Map<String,Double> map=new HashMap();
        for(int i=0;i<stats.length;i++){
            if(stats[i].isFile()){
                FSDataInputStream infs=fs.open(stats[i].getPath());
                LineReader reader=new LineReader(infs,conf);
                Text line=new Text();
                while(reader.readLine(line)>0){
                    String[] temp=line.toString().split("    ");
                    //System.out.println(temp.length);
                    map.put(temp[0],Double.parseDouble(temp[1]));
                }
                reader.close();
            }
        }
        
        return map;
    
    }
    
    
    public static int getCountFromHDFS(String input) throws IOException{
        Configuration conf=new Configuration();
        Path path=new Path(input);
        FileSystem fs=path.getFileSystem(conf);
        
        FileStatus[] stats=fs.listStatus(path);
        
        int count=0;
        for(int i=0;i<stats.length;i++){
            if(stats[i].isFile()){
                FSDataInputStream infs=fs.open(stats[i].getPath());
                LineReader reader=new LineReader(infs,conf);
                Text line=new Text();
                while(reader.readLine(line)>0){
                    String[] temp=line.toString().split("    ");
                    //System.out.println(temp.length);
                    count=Integer.parseInt(temp[1]);
                }
                reader.close();
            }
        }
        return count;
    }
    
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        String proPath="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Pro";
        String countPath="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Count/";
        Map<String,Integer> map=Utils.getMapFormHDFS(proPath);
        for(Map.Entry<String,Integer> entry:map.entrySet()){
            System.out.println(entry.getKey()+"->"+entry.getValue());
        }
        
        int count=Utils.getCountFromHDFS(countPath);
        System.out.println("count is "+count);
    }

}

 

 
4 预测，例如输入Chinese, Chinese, Chinese, Tokyo, Japan。那就分别对每个单词以0，1的类别进行输出，输出为type:words，接着就是在条件概率中查找，进行简单的累乘即可。
  
package hadoop.MachineLearning.Bayes.Predict;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class Predict {

    public static void main(String[] args) throws Exception {//预测
        Configuration conf = new Configuration();
        String input="hdfs://10.107.8.110:9000/Bayes/Predict_input";
        String output="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Predict";
        String condiProPath="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Con";
        String proPath="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Pro";
        String countPath="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Count";
        conf.set("condiProPath",condiProPath);
        conf.set("proPath",proPath);
        conf.set("countPath",countPath);
        Job job = Job.getInstance(conf, "Predict");
        job.setJarByClass(hadoop.MachineLearning.Bayes.Predict.Predict.class);
        // TODO: specify a mapper
        job.setMapperClass(MyMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);
        // TODO: specify a reducer
        job.setReducerClass(MyReducer.class);

        // TODO: specify output types
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(DoubleWritable.class);

        // TODO: specify input and output DIRECTORIES (not files)
        FileInputFormat.setInputPaths(job, new Path(input));
        FileOutputFormat.setOutputPath(job, new Path(output));

        if (!job.waitForCompletion(true))
            return;
    }

}

package hadoop.MachineLearning.Bayes.Predict;



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

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

public class MyMapper extends Mapper<LongWritable, Text, Text, Text> {
    
    public Map<String,Integer> map=new HashMap();
    
    public void setup(Context context) throws IOException{
        Configuration conf=context.getConfiguration();
        String proPath=conf.get("proPath");
        map=Utils.getMapFormHDFS(proPath);
    }
    
    public void map(LongWritable ikey, Text ivalue, Context context)
            throws IOException, InterruptedException {
        for(Map.Entry<String,Integer> entry:map.entrySet()){
            context.write(new Text(entry.getKey()),ivalue);//对每一行数据，打上所有类别，方便后续的求条件概率
        }
    }

}

package hadoop.MachineLearning.Bayes.Predict;


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

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

public class MyReducer extends Reducer<Text, Text, Text, DoubleWritable> {
    
    public Map<String,Double> mapDouble=new HashMap();//存放条件概率
    
    public Map<String,Integer> mapInteger=new HashMap();//存放各个类别下的单词数
    
    public Map<String,Double> noFind=new HashMap();//用于那些单词没有出现在某个类别中的
    
    public Map<String,Double> prePro=new HashMap();//求的后的先验概率
    
    public void setup(Context context) throws IOException{
        Configuration conf=context.getConfiguration();
        
    
        
        String condiProPath=conf.get("condiProPath");
        String proPath=conf.get("proPath");
        String countPath=conf.get("countPath");
        mapDouble=Utils.getMapFormHDFS(condiProPath,true);
        mapInteger=Utils.getMapFormHDFS(proPath);
        int count=Utils.getCountFromHDFS(countPath);
        for(Map.Entry<String,Integer> entry:mapInteger.entrySet()){
            double pro=0.0;
            noFind.put(entry.getKey(),(1.0/(count+entry.getValue())));
        }
        int sum=0;
        for(Map.Entry<String,Integer> entry:mapInteger.entrySet()){
            sum+=entry.getValue();
        }
        
        for(Map.Entry<String,Integer> entry:mapInteger.entrySet()){
            prePro.put(entry.getKey(),(entry.getValue()*1.0/sum));
        }
        
    }
    
    public void reduce(Text _key, Iterable<Text> values, Context context)
            throws IOException, InterruptedException {
        // process values
        String type=_key.toString();
        double pro=1.0;
        for (Text val : values) {
            String[] words=val.toString().split(" ");
            for(int i=0;i<words.length;i++){
                String condi=type+":"+words[i];
                if(mapDouble.get(condi)!=null){//如果该单词出现在该类别中，说明有条件概率
                    pro=pro*mapDouble.get(condi);
                }else{//如果该单词不在该类别中，就采用默认的条件概率
                    pro=pro*noFind.get(type);
                }
            }
        }
        pro=pro*prePro.get(type);
        context.write(new Text(type),new DoubleWritable(pro));
    }

}


package hadoop.MachineLearning.Bayes.Predict;

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.Text;
import org.apache.hadoop.util.LineReader;

public class Utils {

    /**
     * @param args
     * @throws IOException 
     */
    
    public static Map<String,Integer> getMapFormHDFS(String input) throws IOException{
        Configuration conf=new Configuration();
        Path path=new Path(input);
        FileSystem fs=path.getFileSystem(conf);
        
        FileStatus[] stats=fs.listStatus(path);
        Map<String,Integer> map=new HashMap();
        for(int i=0;i<stats.length;i++){
            if(stats[i].isFile()){
                FSDataInputStream infs=fs.open(stats[i].getPath());
                LineReader reader=new LineReader(infs,conf);
                Text line=new Text();
                while(reader.readLine(line)>0){
                    String[] temp=line.toString().split("    ");
                    //System.out.println(temp.length);
                    map.put(temp[0],Integer.parseInt(temp[1]));
                }
                reader.close();
            }
        }
        
        return map;
    
    }
    
    public static Map<String,Double> getMapFormHDFS(String input,boolean j) throws IOException{
        Configuration conf=new Configuration();
        Path path=new Path(input);
        FileSystem fs=path.getFileSystem(conf);
        
        FileStatus[] stats=fs.listStatus(path);
        Map<String,Double> map=new HashMap();
        for(int i=0;i<stats.length;i++){
            if(stats[i].isFile()){
                FSDataInputStream infs=fs.open(stats[i].getPath());
                LineReader reader=new LineReader(infs,conf);
                Text line=new Text();
                while(reader.readLine(line)>0){
                    String[] temp=line.toString().split("    ");
                    //System.out.println(temp.length);
                    map.put(temp[0],Double.parseDouble(temp[1]));
                }
                reader.close();
            }
        }
        
        return map;
    
    }
    
    
    public static int getCountFromHDFS(String input) throws IOException{
        Configuration conf=new Configuration();
        Path path=new Path(input);
        FileSystem fs=path.getFileSystem(conf);
        
        FileStatus[] stats=fs.listStatus(path);
        
        int count=0;
        for(int i=0;i<stats.length;i++){
            if(stats[i].isFile()){
                FSDataInputStream infs=fs.open(stats[i].getPath());
                LineReader reader=new LineReader(infs,conf);
                Text line=new Text();
                while(reader.readLine(line)>0){
                    String[] temp=line.toString().split("    ");
                    //System.out.println(temp.length);
                    count=Integer.parseInt(temp[1]);
                }
                reader.close();
            }
        }
        return count;
    }
    
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        String proPath="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Pro";
        String countPath="hdfs://10.107.8.110:9000/Bayes/Bayes_output/Count/";
        Map<String,Integer> map=Utils.getMapFormHDFS(proPath);
        for(Map.Entry<String,Integer> entry:map.entrySet()){
            System.out.println(entry.getKey()+"->"+entry.getValue());
        }
        
        int count=Utils.getCountFromHDFS(countPath);
        System.out.println("count is "+count);
    }

}

 

 
 
 
 
 
 
 

转载于:https://www.cnblogs.com/sunrye/p/4553732.html

weixin_30641465
关注
Hadoop mapreduce 实现NaiveBayes朴素贝叶斯
01-28
Hadoop mapreduce 实现NaiveBayes朴素贝叶斯
naive bayes在hadoop上的实现
02-02
Naive Bayes在Hadoop上的实现结合了大规模并行计算的能力，使得处理海量数据成为可能，而其朴素的假设（特征之间相互独立）也使得计算复杂度相对较低，因此在大数据场景下具有很高的实用价值。通过持续优化和改进，...
Naive Bayes在mapreduce上的实现(转)
weixin_30645617的博客
10-22 84
Naive Bayes在mapreduce上的实现 原文地址 http://www.cnblogs.com/sunrye/p/4553732.html Naive Bayes是比较常用的分类器，因为思想比较简单。之所以说是naive，是因为他假设用于分类的特征在类确定的条件下是条件独立的，这个假设使得分类变得很简单，但会损失一定的精度。 具体推导可以看《统计学习方法》 经...
使用MapReduce实现Bayes算法
红豆和绿豆的博客
01-22 1538
代码如下： 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
分类算法--贝叶斯分类法（Maprdecue实现）<转>
yongjian_luo的专栏
06-27 631
贝叶斯是一个很有用的算法，可以用在【分词】、【拼写检查】、【分类】、【模式识别】等领域。        附件是基于贝叶斯的简单实现。如果需要有实际需要可以找我进行测试。   贝叶斯分类是统计学分类方法，它是一类利用概率统计知识进行分类的算法。在许多场合，朴素贝叶斯(Naïve Bayes，NB)分类算法可以与决策树和神经网络分类算法相媲美，该算法能运用到大型数据库中，且方法简单、
使用mapreduce用贝叶斯分类器训练
weixin_42615157的博客
12-28 2715
继上一篇配置好hadoop和eclipse环境之后。我开始做我的实验。 实验内容：通过贝叶斯公式对文件分类到某个文件夹中。 实验项目链接： https://download.csdn.net/download/weixin_42615157/10883188 实验原理：贝叶斯分类器，通过其名字我们就可以知道，是以贝叶斯公式为基础。 公式如下： 这里P（B|A）我们称作后验概率，P(B)我们称作先...
naive-bayes:Naive Bayes基本实现以及分布式实现
06-27
Naive Bayes的基本实现以及分布式实现 基于Java实现。 项目内容 项目简介 项目起因 本项目主要实现大规模文本分类，提供快速高效的情感分析框架。 项目框架 simple： 单线程、单机器的Navie Bayes算法的实现。 ...
Naive-Bayes-Hadoop:该项目使用 Hadoop 实现了用于分类问题的分布式朴素贝叶斯方法
06-29
在Hadoop上实现朴素贝叶斯分类，主要是通过MapReduce来实现并行计算。在Map阶段，数据集中的每个样本会被分配到不同的节点，每个节点计算该样本的特征条件概率。Reduce阶段则汇总这些局部概率，形成全局的特征条件...
naivebayes:朴素贝叶斯聚类
07-01
运行 MapReduce 的朴素贝叶斯聚类指令 1.将 .jar 文件复制到 hduser 目录中。 2.复制hw4data.csv到hduser 3.在hdfs中创建5个目录：input1,input2,input3,input4,input5 将文件复制为： input1 : data2.txt, data...
朴素贝叶斯之MapReduce版
热门推荐
余音丶未散的博客
06-28 1万+
1，统计词出现的次数 1/计算类别的先验概率  *输入格式:类别+文档id+文档词(切分成A,b,c)  *输出格式:类别+文档出现次数+文档出现的词的总数 2/计算每个词的条件概率  *输入格式:类别+文档id+文档词(切分成A,b,c)  *输出格式:类别+词+词的总数 3/假设二分类问题-计算概率值   * 1类别+文档出现次数+文档出现的词的总数   * 2类别+
MapReduce之基于符号数据的朴素贝叶斯分类（完）
zhangdy12307的博客
10-03 1564
MapReduce之基于符号数据的朴素贝叶斯分类 在上一篇博客MapReduce之基于符号数据的朴素贝叶斯分类（一）中，简单的介绍了朴素贝叶斯算法的原理，接下来讲述如何使用MapReduce实现朴素贝叶斯算法。 输入数据 还是以《Machine Learning》中的数据为例：如下所示 训练数据 Sunny Hot High Weak No Sunny Hot High Strong No Ove...
基于Java和map/reduce实现的贝叶斯文本分类器设计
毕业作品网站
05-26 919
Project 内容 1：用 MapReduce 算法实现贝叶斯分类器的训练过程，并输出训练模型； 2：用输出的模型对测试集文档进行分类测试。测试过程可基于单机 Java 程序，也可以是 MapReduce 程序。输出每个测试文档的分类结果； 3：利用测试文档的真实类别，计算分类模型的 Precision，Recall 和 F1 值。 一、贝叶斯分类器理论介绍 本次实验用朴素贝叶斯方法给文本文件分类，即给定一个类标签集合 C={c1,c2,…,cj}以及一个文档 d，给文档 d 分配一个最合适的类别标签.
朴素bayes分类器 hadoop实现
远古小山的专栏
10-18 940
1. 介绍篇在这里: 算法杂货铺——分类算法之朴素贝叶斯分类(Naive Bayesian classification): http://www.cnblogs.com/leoo2sk/archive/2010/09/17/naive-bayesian-classifier.html 里面包含 离散和连续型数据两种的处理方式. 连续型数据求概率 可以用正态分布的知识.
贝叶斯分类器的MapReduce实现（VMware + Hadoop）
weixin_42567789的博客
03-11 7386
学校课程要求用 Hadoop 实现朴素贝叶斯分类，这里总结了下大致的操作流程，帮助大家快速入门。 使用的是 windows 10，vmware15.5，ubuntu18.04.1，hadoop2.7.7
人工智能和大数据如何改变企业？
雪兽软件
10-29 317
尽管人工智能和大数据具有显著优势，但在应用它们时也存在挑战。必须考虑伦理问题，例如隐私和人工智能算法中的潜在偏差。总之，人工智能和大数据不仅在改变公司内部的营销方式，还在改变这些实体制定战略决策的方式。这些技术能够更好地了解消费者、定制营销努力并提供量身定制的推荐，从而提高客户满意度并带来销售额的增长。适应这些创新的公司不仅将保持在竞争的前沿，还将最大限度地利用市场机会。本文转载自雪兽软件更多精彩推荐请访问雪兽软件官网。
二百七十三、Kettle——ClickHouse中增量导入数据准确性统计表数据（1天1次）
最新发布
tiantang2renjian的博客
10-31 969
Kettle——ClickHouse中增量导入数据准确性统计表数据（1天1次）
Java 入门系列（1）：总篇
Chen7Chan的博客
10-30 476
新的编程之旅--Java站
中药大数据（四）：数据预处理+管理端的功能实现
roccreed的专栏
10-30 425
中药材产地可视化：内含全国省份的中药材种类分布地图，这个数据是从scrapy爬虫爬取到的数据进行提取之后使用echarts可视化进行提取的。提供主页功能：管理员可以直观查看系统数据情况、用户登录的信息、3D词云。用户可以向后台管理员发送中药药材和药方的纠错申请，管理员可以进行处理。数据爬取功能：基于scrapy爬虫进行中药药材数据和药方数据的爬取。比如我们输入了青酒缸，在中国地图上金色的点位展示了产地的信息。数据预处理：从药材数据中提取药材的产地信息。用户信息管理：可以进行用户增删改查的操作。
大数据治理在企业信息化建设中的应用与挑战
Davina_yu的博客
10-31 636
解释什么是大数据治理，包括数据生命周期管理、数据质量控制等。大数据治理是一种系统化的管理方法，旨在确保组织能够有效地管理和利用其大数据资产。它涉及到一系列策略、政策、标准和程序，以确保数据在整个生命周期中的质量、安全、合规性以及最大化的价值。大数据治理的目标是在保护数据的同时，促进数据的可用性、可靠性和价值创造。本文探讨了大数据治理的基本概念及其重要性，并详细分析了实施大数据治理过程中可能遇到的各种挑战及相应的对策。
MapReduce优化与调试实践：从Hadoop改造到数据挖掘
6. **数据挖掘项目Redpoll**：Redpoll项目中使用了多种数据挖掘算法，如Canopy预聚类算法，k-means聚类，以及Naive Bayes和SVM（支持向量机）进行分类。这些算法在MapReduce框架下可以并行处理大规模数据。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值