Mahout贝叶斯算法拓展篇3---分类无标签数据
代码測试环境：Hadoop2.4+Mahout1.0
前面博客：mahout贝叶斯算法开发思路（拓展篇）1和mahout贝叶斯算法开发思路（拓展篇）2 分析了Mahout中贝叶斯算法针对数值型数据的处理。在前面这两篇博客中并没有关于怎样分类不带标签的原始数据的处理。
以下这篇博客就针对这种数据进行处理。
最新版（适合Hadoop2.4+mahout1.0环境）源代码以及jar包能够在这里下载Mahout贝叶斯分类不含标签数据：
下载后參考使用里面的jar包中的fz.bayes.model.BayesRunner 调用贝叶斯模型建立算法，这里不多介绍，以下是分类无标签数据思路。
输入数据：
0.2,0.3,0.4
0.32,0.43,0.45
0.23,0.33,0.54
2.4,2.5,2.6
2.3,2.2,2.1
5.4,7.2,7.2
5.6,7,6
5.8,7.1,6.3
6,6,5.4
11,12,13
这个数据和原始数据相比就是少了最后一列label而已。
分类主程序：
package fz.bayes; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Map; import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.ToolRunner;
import org.apache.mahout.classifier.naivebayes.AbstractNaiveBayesClassifier;
import org.apache.mahout.classifier.naivebayes.BayesUtils;
import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;
import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;
import org.apache.mahout.classifier.naivebayes.training.WeightsMapper;
import org.apache.mahout.common.AbstractJob;
import org.apache.mahout.common.HadoopUtil;
import org.apache.mahout.math.Vector;
/**
* 用于分类的Job
* 针对
* [
* 2.1,3.2,1.2
2.1,3.2,1.3
]
的数据，进行分类(即不含标签的数据)
* @author fansy
*
*/
public class BayesClassifiedJob extends AbstractJob {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
ToolRunner.run(new Configuration(), new BayesClassifiedJob(),args);
} @Override
public int run(String[] args) throws Exception {
addInputOption();
addOutputOption();
addOption("model","m", "The file where bayesian model store ");
addOption("labelIndex","labelIndex", "The file where the index store ");
addOption("labelNumber","ln", "The labels number ");
addOption("mapreduce","mr", "Whether use mapreduce, true use ,else not use ");
addOption("SV","SV","The input vector splitter ,default is comma",","); if (parseArguments(args) == null) {
return -1;
}
Configuration conf=getConf();
Path input = getInputPath();
Path output = getOutputPath();
String labelNumber=getOption("labelNumber");
String modelPath=getOption("model");
String useMR = getOption("mapreduce");
String SV = getOption("SV");
String labelIndex = getOption("labelIndex");
int returnCode=-1;
if("true".endsWith(useMR)){
returnCode = useMRToClassify(conf,labelNumber,modelPath,input,output,SV,labelIndex);
}else{
returnCode = classify(conf,input, output, labelNumber, modelPath, SV, labelIndex);
}
return returnCode;
}
/**
* 单机版
* @param conf
* @param input
* @param output
* @param labelNumber
* @param modelPath
* @param sv
* @param labelIndex
* @return
* @throws IOException
* @throws IllegalArgumentException
*/
private int classify(Configuration conf, Path input ,Path output ,String labelNumber,String modelPath,
String sv,String labelIndex) {
// 读取模型參数
try{
NaiveBayesModel model = NaiveBayesModel.materialize(new Path(modelPath), conf);
AbstractNaiveBayesClassifier classifier = new StandardNaiveBayesClassifier(model);
Map<Integer, String> labelMap = BayesUtils.readLabelIndex(conf, new Path(labelIndex));
Path outputPath =new Path(output,"result");
// 按行读取文件。并把分类的结果写入另外的文件
FileSystem fs =FileSystem.get(input.toUri(),conf);
FSDataInputStream in=fs.open(input); InputStreamReader istr=new InputStreamReader(in);
BufferedReader br=new BufferedReader(istr);
if(fs.exists(outputPath)){
fs.delete(outputPath, true);
}
FSDataOutputStream out = fs.create(outputPath); String lines;
StringBuffer buff = new StringBuffer();
while((lines=br.readLine())!=null&&!"".equals(lines)){
String[] line = lines.toString().split(sv);
if(line.length<1){
break;
}
Vector original =BayesUtil.transformToVector(line);
Vector result = classifier.classifyFull(original);
String label = BayesUtil.classifyVector(result, labelMap);
buff.append(lines+sv+label+"\n");
// out.writeUTF(lines+sv+label);
// out.
}
out.writeUTF(buff.substring(0, buff.length()-1));
out.flush();
out.close();
br.close();
istr.close();
in.close();
// fs.close();
}catch(Exception e){
e.printStackTrace();
return -1;
}
return 0;
}
/**
* MR 版
* @param conf
* @param labelNumber
* @param modelPath
* @param input
* @param output
* @param SV
* @param labelIndex
* @return
* @throws IOException
* @throws ClassNotFoundException
* @throws InterruptedException
*/
private int useMRToClassify(Configuration conf, String labelNumber, String modelPath, Path input, Path output,
String SV, String labelIndex) throws IOException, ClassNotFoundException, InterruptedException { conf.set(WeightsMapper.class.getName() + ".numLabels",labelNumber);
conf.set("SV", SV);
conf.set("labelIndex", labelIndex);
HadoopUtil.cacheFiles(new Path(modelPath), conf);
HadoopUtil.delete(conf, output);
Job job=Job.getInstance(conf, "");
job.setJobName("Use bayesian model to classify the input:"+input.getName());
job.setJarByClass(BayesClassifiedJob.class); job.setInputFormatClass(TextInputFormat.class);
job.setOutputFormatClass(TextOutputFormat.class); job.setMapperClass(BayesClassifyMapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
job.setNumReduceTasks(0);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
FileInputFormat.setInputPaths(job, input);
FileOutputFormat.setOutputPath(job, output); if(job.waitForCompletion(true)){
return 0;
}
return -1;
} }
假设使用MR，则Mapper例如以下：
package fz.bayes; import java.io.IOException;
import java.util.Map; import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.mahout.classifier.naivebayes.AbstractNaiveBayesClassifier;
import org.apache.mahout.classifier.naivebayes.BayesUtils;
import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;
import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;
import org.apache.mahout.math.Vector; /**
* 自己定义Mapper。输出当前值和分类的结果
* @author Administrator
*
*/
@SuppressWarnings("deprecation")
public class BayesClassifyMapper extends Mapper<LongWritable, Text, Text, Text>{
private AbstractNaiveBayesClassifier classifier;
private String SV;
private Map<Integer, String> labelMap;
private String labelIndex;
@Override
public void setup(Context context) throws IOException, InterruptedException { Configuration conf = context.getConfiguration();
Path modelPath = new Path(DistributedCache.getCacheFiles(conf)[0].getPath());
NaiveBayesModel model = NaiveBayesModel.materialize(modelPath, conf);
classifier = new StandardNaiveBayesClassifier(model);
SV = conf.get("SV");
labelIndex=conf.get("labelIndex");
labelMap = BayesUtils.readLabelIndex(conf, new Path(labelIndex));
} @Override
public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
String values =value.toString();
if("".equals(values)){
context.getCounter("Records", "Bad Record").increment(1);
return;
}
String[] line = values.split(SV); Vector original =BayesUtil.transformToVector(line);
Vector result = classifier.classifyFull(original);
String label = BayesUtil.classifyVector(result, labelMap); //the key is the vector
context.write(value, new Text(label));
}
}
用到的工具类：
package fz.bayes; import java.util.Map; import org.apache.mahout.classifier.ClassifierResult;
import org.apache.mahout.math.RandomAccessSparseVector;
import org.apache.mahout.math.Vector; public class BayesUtil { /**
* 把输入字符串转换为Vector
* @param lines
* @return
*/
public static Vector transformToVector(String[] line){
Vector v=new RandomAccessSparseVector(line.length);
for(int i=0;i<line.length;i++){
double item=0;
try{
item=Double.parseDouble(line[i]);
}catch(Exception e){
return null; // 假设不能够转换，说明输入数据有问题
}
v.setQuick(i, item);
}
return v;
}
/**
* 依据得分值分类
* @param v
* @param labelMap
* @return
*/
public static String classifyVector(Vector v,Map<Integer, String> labelMap){
int bestIdx = Integer.MIN_VALUE;
double bestScore = Long.MIN_VALUE;
for (Vector.Element element : v.all()) {
if (element.get() > bestScore) {
bestScore = element.get();
bestIdx = element.index();
}
}
if (bestIdx != Integer.MIN_VALUE) {
ClassifierResult classifierResult = new ClassifierResult(labelMap.get(bestIdx), bestScore);
return classifierResult.getLabel();
} return null;
}
}
这里略微分析下思路（參考单机版代码或者Mapper代码）：
1. 读取模型。參数模型路径、标签的编码文件（labelIndex.bin）。标签的个数（labelNumber），依据相关路径，初始化模型相关变量；
2. 针对每条记录 。比方 0.2,0.3,0.4 。依据SV（输入路径向量的分隔符）把这条记录向量化，得到Vector（0=0.2,1=0.3,2=0.4）；
3. 使用模型计算每一个标签的得分，得到的也是一个向量，记录了每一个标签的分数Vector result = classifier.classifyFull(original); 即result 向量；
4. 依据标签的得分，得出该条记录属于哪个标签，最后反编码（因为标签是经过编码得到的，所以这里须要经过反编码）。
这里看下输出结果：
MR版：
aaarticlea/png;base64,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" alt="" />
单机版：
aaarticlea/png;base64,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" alt="" />
能够看到单机版。第一行输出有一个乱码，这个事实上是没有影响的。使用hadoop fs -cat 读取是没有问题的。
分享，成长，快乐
转载请注明blog地址：http://blog.csdn.net/fansy1990
Mahout贝叶斯算法拓展篇3---分类无标签数据的更多相关文章
- mahout贝叶斯算法开发思路（拓展篇）1
首先说明一点,此篇blog解决的问题是就下面的数据如何应用mahout中的贝叶斯算法?(这个问题是在上篇(...完结篇)blog最后留的问题,如果想直接使用该工具,可以在mahout贝叶斯算法拓展下载 ...
- mahout贝叶斯算法开发思路（拓展篇）2
如果想直接下面算法调用包,可以直接在mahout贝叶斯算法拓展下载,该算法调用的方式如下: $HADOOP_HOME/bin hadoop jar mahout.jar mahout.fansy.ba ...
- 基于贝叶斯算法实现简单的分类（java）
参考文章:https://blog.csdn.net/qq_32690999/article/details/78737393 项目代码目录结构 模拟训练的数据集 核心代码 Bayes.java pa ...
- 【sklearn朴素贝叶斯算法】高斯分布/多项式/伯努利贝叶斯算法以及代码实例
朴素贝叶斯 朴素贝叶斯方法是一组基于贝叶斯定理的监督学习算法,其"朴素"假设是:给定类别变量的每一对特征之间条件独立.贝叶斯定理描述了如下关系: 给定类别变量\(y\)以及属性值向 ...
- Atitti 文本分类 以及 垃圾邮件 判断原理 以及贝叶斯算法的应用解决方案
Atitti 文本分类 以及 垃圾邮件 判断原理 以及贝叶斯算法的应用解决方案 1.1. 七.什么是贝叶斯过滤器?1 1.2. 八.建立历史资料库2 1.3. 十.联合概率的计算3 1.4. 十一. ...
- Atitit 贝叶斯算法的原理以及垃圾邮件分类的原理
Atitit 贝叶斯算法的原理以及垃圾邮件分类的原理 1.1. 最开始的垃圾邮件判断方法,使用contain包含判断,只能一个关键词,而且100%概率判断1 1.2. 元件部件串联定律1 1.3. 垃 ...
- Naive Bayes(朴素贝叶斯算法)[分类算法]
Naïve Bayes(朴素贝叶斯)分类算法的实现 (1) 简介: (2) 算法描述: (3) <?php /* *Naive Bayes朴素贝叶斯算法(分类算法的实现) */ /* *把. ...
- 【十大算法实现之naive bayes】朴素贝叶斯算法之文本分类算法的理解与实现
关于bayes的基础知识,请参考: 基于朴素贝叶斯分类器的文本聚类算法 (上) http://www.cnblogs.com/phinecos/archive/2008/10/21/1315948.h ...
- 什么是机器学习的分类算法？【K-近邻算法(KNN)、交叉验证、朴素贝叶斯算法、决策树、随机森林】
1.K-近邻算法(KNN) 1.1 定义 (KNN,K-NearestNeighbor) 如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类 ...
随机推荐
- CSS3 四边形 凹角写法
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- pavenet资源
网络结构:http://www.cnblogs.com/fariver/p/7449563.html 源码:https://github.com/sanghoon/pva-faster-rcnn 训练 ...
- 中南大学2019年ACM寒假集训前期训练题集(入门题)
A: 漫无止境的八月 Description 又双叒叕开始漫无止境的八月了,阿虚突然问起长门在这些循环中团长哪几次扎起了马尾,他有多少次抓住了蝉等等问题,长门一共回复n个自然数,每个数均不超过1500 ...
- [bzoj2806][Ctsc2012]Cheat(后缀自动机(SAM)+二分答案+单调队列优化dp)
偷懒直接把bzoj的网页内容ctrlcv过来了 2806: [Ctsc2012]Cheat Time Limit: 20 Sec Memory Limit: 256 MBSubmit: 1943 ...
- 笔试算法题（50）：简介 - 广度优先 & 深度优先 & 最小生成树算法
广度优先搜索&深度优先搜索(Breadth First Search & Depth First Search) BFS优缺点: 同一层的所有节点都会加入队列,所以耗用大量空间: 仅能 ...
- Groovy常用语法汇总
基本语法 1.Grovvy的注释分为//和/**/和java的一样. 2.Grovvy语法可以不已分号结尾. 3.单引号,里面的内容严格的对应java中的String,不对$符号进行转义. def s ...
- 零基础入门学习Python（13）--元组：戴上了枷锁的列表
前言 这节课我们讨论主题是元祖:我们有个小标题戴上了枷锁的列表 我们都知道早在300多年前,孟德斯鸠在变法的时候说过,一切拥有权力的人都容易被滥用权力,这是万古不变的一条经验.但是呢,凡是拥有大权利的 ...
- HTTP实验：分别使用httpd-2.2和httpd-2.4实现
1. 需求描述 1.建立httpd服务,要求: (1) 提供两个基于名称的虚拟主机: www1.stuX.com,页面文件目录为/web/vhosts/www1:错误日志为/var/log/httpd ...
- Bootstrap-Table 总结
Bootstrap-Table 总结 jQuery Java Bootstrap-Table JS文件 传参:直接将需要的参数置于 queryParams 方法中,例如 line:formData注意 ...
- 【02】AMD、CMD、UMD 模块的写法
AMD.CMD.UMD 模块的写法 简介 最近几年,我们可以选择的Javascript组件的生态系统一直在稳步增长.虽然陡增的选择范围是极好的,但当组件混合匹配使用时就会出现很尴尬的局面.开发新手们会 ...