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个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类 ...
随机推荐
- Python之三元运算、集合、函数
一.三元运算符 三元运算符就是在赋值变量的时候,可以直接加判断,然后赋值 格式:[on_true] if [expression] else [on_false] res = 值1 if 条件 els ...
- 使用GetLogicalDriveStrings获取卷标
#include <windows.h> #include <stdio.h> #define BUFSIZE 512 int main() { TCHAR szTemp[BU ...
- 手动配置webpack
//注:“__dirname”是node.js中的一个全局变量,它指向当前执行脚本所在的目录.const path = require('path');const webpack = require( ...
- html引用ttf字体文件
在样式表如此定义: @font-face { font-family: MyFontName;//自定义字体名称 src: url(../Gloss_And_Bloom.ttf) } 然后,具体使用: ...
- JavaSE-21 字符编码简介
ASCII ASCII(American Standard Code for Information Interchange,美国信息交换标准代码)是基于拉丁字母的一套电脑编码系统,主要用于显示现代英 ...
- flutter 上传图片 image_picker 的使用
Github地址: https://github.com/flutter/plugins/tree/master/packages/image_picker packages地址: https://p ...
- Java 调用存储过程 返回结果集
这里使用Oracle数据库的thin连接. 下面是存储过程SQL 1 createorreplaceprocedure proc3(stid in student.stuid%type, stname ...
- css float属性详解
定义和用法 float 属性定义元素在哪个方向浮动.以往这个属性总应用于图像,使文本围绕在图像周围,不过在 CSS 中,任何元素都可以浮动.浮动元素会生成一个块级框,而不论它本身是何种元素.如果浮动非 ...
- Python飞机大战实例有感——pygame如何实现“切歌”以及多曲重奏？
目录 pygame如何实现"切歌"以及多曲重奏? 一.pygame实现切歌 初始化路径 尝试一 尝试二 尝试三 成功 总结 二.如何在python多线程顺序执行的情况下实现音乐和音 ...
- [Luogu] P1131 [ZJOI2007]时态同步
题目描述 题目描述 小Q在电子工艺实习课上学习焊接电路板.一块电路板由若干个元件组成,我们不妨称之为节点,并将其用数字1,2,3…进行标号.电路板的各个节点由若干不相交的导线相连接,且对于电路板的任何 ...