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个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类 ...
随机推荐
- STL:set的使用
关于set set是以特定的顺序存储相异元素的容器. set是关联式容器,C++ STL中标准关联容器set, multiset, map, multimap内部采用的就是一种非常高效的平衡检索二叉树 ...
- docker 入门学习
一 : docker 安装(linux-centos7) 安装docker要求 1.docker只支持在64位cup架构计算机上运行,目前不支持32位cup. 2.建议系统的linux内核版本在3.1 ...
- https://blog.csdn.net/blmoistawinde/article/details/84329103
背景 很多场景需要考虑数据分布的相似度/距离:比如确定一个正态分布是否能够很好的描述一个群体的身高(正态分布生成的样本分布应当与实际的抽样分布接近),或者一个分类算法是否能够很好地区分样本的特征 ...
- CF919F A Game With Numbers
题目:(luogu翻译错的很多) Alice和Bob玩游戏,每人有8张牌,牌的值为0~4.每一轮当前玩家选择自己的牌A和对手的牌B,然后将A的值变为( A + B )%5,其中A和B都不是0. 当一个 ...
- AutoEncoders变种
目录 PCA V.S. Auto-Encoders Denoising AutoEncoders Dropout AutoEncoders PCA V.S. Auto-Encoders deep au ...
- Python多线程豆瓣影评API接口爬虫
爬虫库 使用简单的requests库,这是一个阻塞的库,速度比较慢. 解析使用XPATH表达式 总体采用类的形式 多线程 使用concurrent.future并发模块,建立线程池,把future对象 ...
- Ubuntu系统搭建django+nginx+uwsgi
1. 在开发机上的准备工作 2. 在服务器上的准备工作 3.安装uwsgi 4.编写uwsgi配置文件,使用配置文件启动uwsgi 5. 安装nginx 6. 收集静态文件 7. 编写nginx配置文 ...
- python 博客开发之散乱笔记
博客开发之旅: # 回滚,数据存储失败时,还原修改操作 from django.db import transaction with transaction.atomic(): do... ... # ...
- 集训第五周动态规划 F题 最大子矩阵和
Given a two-dimensional array of positive and negative integers, a sub-rectangle is any contiguous s ...
- jmap Unable to open socket file解决
pid:Unable to open socket file: target process not responding or HotSport VM not loadedThe -F option ...