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个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类 ...
随机推荐
- 前复权是从今天的价格倒推 后复权是从上市价格前推 不复权就是原始K线。
前复权是从今天的价格倒推 后复权是从上市价格前推 不复权就是原始K线.
- redis-3.0.1 sentinel 主从高可用 详细配置
最近项目上线部署,要求redis作高可用,由于redis cluster还不是特别成熟,就选择了redis sentinel做高可用.redis本身有replication,实现主从备份.结合sent ...
- cesium 原理 之 command拼接
VAO VAO(Vertext Array Object),中文是顶点数组对象.之前在<Buffer>一文中,我们介绍了Cesium如何创建VBO的过程,而VAO可以简单的认为是基于VBO ...
- ARP是如何工作的？
我们知道,当我们在浏览器里面输入网址时,DNS服务器会自动把它解析为IP地址,浏览器实际上查找的是IP地址而不是网址.那么IP地址是如何转换为第二层物理地址(即MAC地址)的呢? 在局域网中,这是通过 ...
- js【table】合并行，合并列
eg: function hbh() { var tab = document.getElementById("tableID"); var maxCol = 2, val, co ...
- 第3节 mapreduce高级：10、11、分组求取topN
只要修改OrderReducer.java的reduce方法,修改为: int i = 0;for(NullWritable nullWritable:values){ if(i>=2) bre ...
- vim跳转(一)
参考资料:http://easwy.com/blog/archives/advanced-vim-skills-basic-move-method/ 在normal模式下使用如下命令 1.h, j, ...
- 基于短语的统计机器翻(PBMT) 开源工具 ：Moses
如何运行Moses 1. Moses的历史 Moses是Pharaoh的升级版本,增加了许多功能.它是一个基于短语的统计机器翻译系统,整个系统用C++语言写成,从训练到解码完全开放源代码,可以运行在L ...
- React Components之间的通信方式了解下
先来几个术语: 官方 我的说法 对应代码 React element React元素 let element=<span>A爆了</span> Component 组件 cla ...
- 源码学习-String类
最近在扫描CodeDex时报了一个不能使用String.intern()的字符串来做锁对象的告警,对这个问题有疑问查了些资料,顺便学习一下String类的源码. 1.类定义 String 被final ...