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,iVBORw0KGgoAAAANSUhEUgAAAdAAAAFFCAYAAABc9rzwAAAgAElEQVR4Ae2dT6wkx3nY61Gio8CwFJsgs8s/0eagQ0wGXkoIsMvT6kBSQEIuA9B8b3UICIgiTJpB9qADnwREEBD7LWAdVhEtxVojMHzQ7iMgaMkIsiwB0vpg7yIi7TVE5uKDHkkR+7gC9IeOIYUi+VLfTH8zNTVV1dU93T3dM78mHqu76vv765n+pqp7ZjcO7GbYIAABCEAAAhCoROCGStIIQwACEIAABCAwIkAB5YUAAQhAAAIQqEGAAloDGioQgAAEIAABCiivAQhAAAIQgEANAhTQGtBQgQAEIAABCFBAeQ1AAAIQgAAEahCggNaANlb5J3Nm46dm48w/1bbQX8UrNrcNm9uV/oZYO7JVzq02lDVW5PWwxid/4dQpoHURXnnbbJsNc/7RX69rob96Vy7Z3DZtbsf6G2PdyCK5XX/uK+aRZ16qaxW9EgK95Rt5PZSkwzAERgTCBfTKGbMhM5DUX2R2sn9hq9DbMhf2w5SnMoWPrQsmIho2sPTeX5oLZ981ZudGs3Vo6cE0HMC+zW3b5nZ6PXJ7cdc8ctvnzVNPvtkwx2GaGxU6y0OYjP6e+I65vkgqLfNdLN5Vfq0vctLq685d2zfOmNg61tBkg1Tkl4iC27XzB5vG2F8p2jm47Apc3pFfLprvL2Sund8sxjcPzl9zFQP76mPz/EGZaEB7eV2Xf2Zz/MnBzgyY5YXTqOfi/K5Vbm98++DTt/7Rwe9+8QeNohy0MWXye98+eGPRRNRWm3zVR5V4V/m1vug5q6E/vfYXNSNRK4YmG8NhYgMHWtz8AioKTb3w1MegCugvDs5v/uTAbL45rKIfPdHuwDWbm/1wNIDz8dIXbcG79cLBS274yf1EbnrxbfMCn4yth4PKpEpBiqWhttrkqz6y4028HmJ5LKn/8k58wrKkkObd6rXcTq7cD9/j2G38bufQZOeznfSEl3CDc1XbuX/BbNll3TPmaSm85ukVvEUWS33Sf+X/mVO7ssL5G2blVm+v/FmR21bPc7tuXn95ckbydgaTW146SC1IYDCvh32zd3XBXDtQ37900djLorEfvo376MSxEztj79uXJku5Q5NN4atWQPf2xpBSFpc+Zu9rbOn92/j6e70wi3ufm++deZHUs9U3reJ+kPcG6FuUEs/15y6aP32+SmTDya1KVsjWJTCc18P+hdOjD7V1M+1Gb99cujgqn8YcPTL74fvIEfs4omxXzd7oQZehyaYJvjc9LKPb5viGfaikZJMbwodlaqabvRBfs31NzNLmbFsfm+ev2ULZhHUNOKPV2eflwOzzys/NxnH7YJFstsBeuzCW2b/wM8tFbgvbbefXzMHT7lO7tiBv/SL4Btk8/8/t2PvGesX/Z2wVfbNy8tWat+wZ0+0Gc/naDebs4benH3yc2FRq1Oon8suhc/aSOXfbt8x3Jgp3mM/+3W+Zr9799+YftO/B3zHPfPlec4se20dPvv3En88Vug996T+ZPzg5lRqL58m+/MznzeeKD7RjvdfM5+zDLrrd+/ynzCc/okdOm8zNkTPXbMzf8mK2ub6+ae50xa5/x3zGzb0Ym/Hvywifx35innrwtamlOWby4eArcw80VWEmxsPyU7eN7fk5FoZnOMw4y+RrdfI5zDjIO0i9HuQByuPjd9DO5cvGHD/uvJ+s+dB1TVbmDp+avseKKOyqpbNKJ1+XcW3t2PfmEfvedPQc21fObJgijMLa7HV41nZe2qHraEizjm21s2kL5sx26Ig5ajt27X97exeMWxCGJjuTlx5MFnP9nck6tfMQUc69T9XLuY9WKlvcp7Dr6rZgTiKc3IB219Uno23tZNz7vPamffBq/v7otfM/HT10ZHb+rxNcYW/mYaRpX0x28/wvJjbCdmXYsaPxFA8+GfOz2YfCRtZy7we9cfCXvyf3Hos/ud/0woXi2L0f+YODrxQyn76oj6A4ujP3wqrIFqnr/a6se6AZuU3sSV5/cvCXRchvXPyTcW7ufTXN1+070BymuuNItd9hU+hPuRQ52Ud1lK07NolhhtlU9isvzOs38jCUMpnJU33ZtgoHtTV6TUwZTXKb8THNrZyDE4/6mLHljE92M14Pel3yHpacXHfc50L0QZmZ693lA/s5z77nNwMPUk6vafYaPH7eQG24djXeSSzOdVjHpJ3oir/I3yS2qe/R9XRiexznJD+5rlayq/nOXqfHYU7Hxpfr6bF7Te+v7Diy2P+rLeFOpuNafltui0+K9gb0zGzz0NZpM5qIbJ+NflWm8ch09tn4vc8NM/3Q9j6zdeHXxrm5CRS+ZQbrzkoPbd1YcPhVnIPMemU2fOwD9r71b9q/D5i5W9f6ifx0aPbpBuLsb3/MPCszzo9smmdf/5T9m87SXn5mPFudnQndYu778sfMvWJi52/Mt4vvRlSRdbzn71bK7f3msb973NxXTJBvOXnPON7nf2iuFvFe/9HPx77vPOzMtu8y90yn/U5sd5mTX3q/PX7NfPW5sYGx/h3m4/4s/MXvjWe+lqs7Q5/E4DCbOni/+eAdeuTw1a4W22ocNJByvqYWB7Wf0VZ6PdhZ4sHTk/fLoa2zxj5kZ7dtc6n4bsa+3qCcWbo8ZvTWXzIie107kFW6Y+NnSg4cX0k9d3CiezB6LsVe6OfbuZXAHXPaXb3bfMic8BfzKtk9Yo6M12ndyCL7Q5ONpFF0ZyzhOgYO2e92Hmw5He3uTl6c28dNxipyi8G0ce9TiuU7Zm/3LXPq8E/NKYm+WF59+uDX7WNa021/r1gC3n7LcnhrOlC6Z5dwZ5aMQwp17gfZZc2n7goZs30vmb8pllmP3O4v1UqhscV1503zV5evm/tOXq8g69uKuJ/prpjbg//aHJ1xc4v54IPW4PNvmldk5dWO3XLycfPsSXEiy9qfd5a1pW9+u+XkQ+axb9ml7Ce/Z14++VHz+rfs902375ldErZqk4K08y3ziP1Lb+Ni+crzdrn57s+bPxXhYjn4k6/fZT6ZVm5ktCqHkdMMvtU4VE2l4uthzvwhc2S8Hmmuyg29Y4fMIfsd9gP7Z+wjMvLrXcHPUXN2pMMW5xV8CnN3b89ccNdp9/fs3U/ZNp2JwqjDDE12HPXs/6sV0Fnd1o/29op7qvJJbZkvNp19hu59LkTBFkotlvv/aO+jvG0O7/7UWrS/cHTtX0x+yGBPC+jcPdSFnI+V9RN58N5nA/aXaaKN3OSHASb3Maf3R+fvz2rittg9doedXdr7tc98z9z7vJ2FfW7+w8ePXyt+yEFm9tEPJ2pTWlsotVgW9yKfev7vbf/sLM/VaHS/Moc879U55NkdSbXxenDumY6KYjGLnL+HWSHOwYkeMiceslPQXXu9vrpnfxTn2LSE2oI6voofNUdGs9yhyaZPRrUl3LStxkcnj0CPTsqseXmBbnTyC0ZtzD5tLlIw7W/pbl345TixQ79hZ/eyxCpLuAd2VvrzyWPfx04Up+nqu3O/2HTljP093q1/nOufpRU7WvQTecjudDlz70f+b9j4s9MqsiFf077xL9I4D7FZIqNfVFroqeLr5pXR0766VGpnnaPiKUVqdtl6Gklg7yMfNY/JTHbnNTtj/YC5bWaWO5a/83ixFvvytblf/pHi/Ij7i0BSMO3s9zPFsrC55V7zB6NldFkif9POSndN1W/5BKJOdNXkMGfR52tMJQ5z9lIdTbwerphLxRTz6Kga2Fnn6Ekf+7OX12TpdLrcm4pk0bHxL/icWdRMo/qHTjw0ftp295T5s2J5WxxcUWA7J6ZL4QOTTYHqdQE1xx4d33OwJ+Ww89OB8gKS1+1O8J6dfaM0+TWW/V8ZeUI763ufh24YPXFmdt8xl+wKz2izT+dOnsJ1z0Qhu3vqF8ZJzRbWd8dLHps3mCMqf+yfFRzsDNX58Xp5KnfMIfBUsOqm2v1LRW4V7n2m7BVjdz41vtf5D0/++fQiP3oqt3iS186y9GnZKrIT17ccLtj83LwuNdoWlC/IT/FtO8/K1snNzuC+oEXJmtX7s7LkqvdFxzGMl6An8Vj/Xy2Wrf/qs16xGwnZWejnfsd8yO5/6EsfnVu+HYlokbUxPOX8Jq98MJAnj+99zHnCuchf+J57cRKF5XDN7Mnhg79lbna629utyCGHbxUOVRKr83qwC7LHJ29Oua4UT9HOfSjbNRcnb3gblH0qV34NU7aLpxf8oH9o/BTr5Gsg1vbp0RfRT4zs9+Z/9vbe2fENYrN9fPz1Qb1Oj2bm7gri0GQTkDfk6aK58ZllifFo2aPN8Uek5dOZfcx7NH0f26oiKxqh5ZD411jkhX64+GrI7EMAY+/V/i8zvONXp19LKdOe/6rJDeb8eTujnPsqi/+VE9eyvXcZeNhnFEvxxlTp9NdYVEqevp//WsyI69Wcrxv5X2OZ2p19UGjab6/mjX+NxbVuZpYQ7Yj3lZD83KyuzOg+a8zHP/ZD8zn/N3H9JVWRnfsKy/vNvfa8yL3d0ebrSGfh47/MfNVnLO7+P7QUPM84fj6MmS4ru3Zz90NfHxnrekvDVThU4VsEmsfBYg187ScUb6XXQ/G1FLO5aVcl3VUNa9m/nRT8Csum2bEfera3C92RjvG+xlIkapv4tayQ8a/HztddplbK92auu5s7dqVr22iIm+OAi+VWSdP9Ck65bZWY8THqjF+DhyarObptuIC6Euu8X9yXNIHiM3gsepFYxvdp24bXw9xGF/rX7sm8v9k2oDWzX/X1UFV+zXCS7pQABXTKYm5vw96jXNVNvtKSu8m/yjGkTb5Wk7sNLbfcvJCbEqjyerDLXZMfUhhbmF9Bm1pmb90JUEDX/RVA/itKILXMO5ty/JeDZuU4ggAEZglQQGd5cAQBCEAAAhDIItDvp3CzUkAIAhCAAAQg0D0BCmj3zPEIAQhAAAIrQIACugInkRQgAAEIQKB7AhTQ7pnjEQIQgAAEVoAABXQFTiIpQAACEIBA9wQooN0zxyMEIAABCKwAAQroCpxEUoAABCAAge4JUEC7Z45HCEAAAhBYAQIU0BU4iaQAAQhAAALdE6CAds8cjxCAAAQgsAIEKKArcBJJAQIQgAAEuidAAe2eOR4hAAEIQGAFCFBAV+AkkgIEIAABCHRPgALaPXM8QgACEIDAChCggK7ASSQFCEAAAhDongAFtHvmeIQABCAAgRUgQAFdgZNIChCAAAQg0D0BCmj3zPEIAQhAAAIrQIACugInkRQgAAEIQKB7Au8NuTx37lyomz4IQAACEIAABAoCwQIqYw8//DCQIAABCEAAAhCIENg4sFtkjG4IQAACEIAABCIEuAcaAUM3BCAAAQhAIEWAApqiwxgEIAABCEAgQoACGgFDNwQgAAEIQCBFgAKaosMYBCAAAQhAIEKAAhoBQzcEIAABCEAgRYACmqLDGAQgAAEIQCBCgAIaAUM3BCAAAQhAIEWAApqiwxgEIAABCEAgQoACGgFDNwQgAAEIQCBFIPpTfimlVRl79tlnVyUV8ugpgUceeWQmsv39ffPd737XdPUDYOLn/vvvNzfffPNMHBxAAAKLE1jrAir4/Avc4kixAIExgdAHtG9+85vm1KlTnSL6+te/bj7+8Y936hNnEFgHAmtfQNfhJJNjfwjceOONnc0+Net33nlHd2khAIEGCVBAG4SJKQjkEHj33XfNxsbGqJB21ebEhQwEIFCNAA8RVeOFNAQWIiDFU7au24WCRhkCEAgSSM5A5dOxu3X14IPrk30IrBoBWVKV95bORLtoV40h+UCgDwSiM1BdWpKiuTaFc/+C2dq6YPa7PDNd+Zz42TcXtjbMmStdJlnDl8S7ccaUh1kzn2z7NWJPqHQ981R/iZAYggAEahKIFtCa9ubU/FnsnECPOvYvXTTmoRPmUIcxNe4zUhga99Mho1VzJUVNPpR21a7NB+BVe6GQT+8JBAuozj7d6Pv6JpRYmynS+2ZcPzstnx35XEZu7quHfSUg76Nl/Kl/WghAoDkCwQKaa16Ll7auntvn7odkYuOubPv7e2bPPGROSP30Z3H+8ZUzo6I9jnvLXJhZ871izhRFfcNdghQbW2fMGbt8Ou33fPrjI7/jDwgbG56f4Jj1ffiU2TXb5viMvONHQV6a5rDlJjCTm/VdrPVeOTPdVxP7F7Ym48YutgbzFuEZm14eaqysnbExH4uJ5ZOKq8xnC+NSPEtnnte+Zh676SZzk/yd/Zr52iduMme/X+jtf818Qsdu+oT52n65vb5++G0BLyYh0CmB2gVUiof/SVr6dNMxOXb3dbxMX+XK2pDtMp3g+JVLZvvokYzlW1sojl81568VM4nLR82p03rfVO7HHTfm8njs2vmr5rh7T3V325jTMva0OSZB+D5nxsfF8Ghh60D8HNZ7grGxY+bpa+fNptmxIdiCrZNp3491vX31iLk2mg1dNkdPHS7uiUpu22Zn4nPHCp4dfUA49qi1u33JuScps9pds3NCMknlneIlEHK2eFyqHc4nFZdqdtvK61U2vTc53/5v84W7Hjd3fvO6+fGPf2xeuv2b5nF7Z+Fg9PTuC+bsnY+bu/7ix+b6dTv+F3eZx+88a15I2hs/9Ttyyv8gAIFGCWQV0PFMazwTatR7j4xduWQLx6gY5AS1a/b2CrljT5sDOxMb1ar9S+bi7o5RM4e2Tpud3Yvm0mSGummOHJnan/fpjO/vmau2EKotc+yEPbpq9sRWamxqfrI378eYndNFzOaYOSF18pI8rmMLsL3APz2q7nIoPovt0Anz0Oa2GYlJl5uru2+H5vOO8CpMlzeJuArlYD6lcZV7blpCCmhyBvrCX5v/9tD/MJsfGcvd/NDj5jM2CPuxy7y7/4p5yR7d8+HiHuqH77FHL5lX9svvqTadB/YgAAFjsgqofmrWdvXAXTGXtp1ilUxQLuaXjV0jnSzjzj7RKsunOnbcLqa621FzRGeFdi4379MZtxV6d/OIOTJRt/ubRSFKjU3kdSfkR8fG7ZEjm9OOmaVhN/5D5sRDm0Whlfppp0XnH7UlV7dY3mW8VL+kjcY1rzeTz2g5O3Y+5nW76JH3UezvjVdfkmrpjN9u7jhpoxKdV18zF0/eYW6f6MvYRfPaq3F7q/ue7eJM4QMCaQLBAipvOnc5Nm1iBUav2OXbnRNOMSjLaTwjGl0EL++Y7eO6tCp6snzqXtCcpVTXbJlPO1Xd3JV7l7rZ/d1ihpoaU3Fty/xYub29XbMpU2MpUocvmod0edp+UNhRO7YdzSxHy7j7gYefUnmneDkOYrslcflqk3xGA6m4fM32j+U1k5qB3nz7nTYId0b5qnn1uXFBffe228zJ5141r0ye4n3Fjp00t93myoftt58ZHiCwfgSCBXRIGHR5eZGY9/fsYumJ6VzKHDpijtqZiy5XymxrVx2MZkKRB2HmljltQXIfJFIbtp3z6YyNdr0YRvdLbVSjGWxqbKRcLPUm/GyfLe7b2nzO2mnyUTEsM1v1YXWvnHFnoGJYlnstlwt2qVofuJLuVN4pXqKbs5XGJbdqA/mk4srx24KMzgjn730Wv1B09zHz6eeeNBe+Pz7e//pXzB/aOEb3QG+5w/y2Pbr8YnEP9cXL9ui3zR23pO6pcg+0hdOISQiMCEQLqM5CtUDpG1+5+eMi58uIrCunun5/zIcr397+eDYlE7Dpdsw8et4uVxbLtKdtsZjMxA7Z4jl6oKdYFhw9UFQ8FGTvhG5duDxd3h3N5nRsat2Wz9EMbtanOy77dtZmHwi6qkvFM34SY6OisWsfOJIfS4j72Tm6Zw7LUrN9atc+ETW+73nsUXPe3ufUJeizRy7bY+f+pUR1ws647b8mcnRyD1ViTeSd5CW6GVtGXMF8UnFluG1DRN4PqRnowcGHzZN/+8fm5QdvM7feequ5+7U77Ue5B83tt4ve3eb37dhLD9xqZ512/IGXzB//7e+buycz0vBMNPS+bCM3bEJg3Qhs2DfX+LHAdcvc5iv/3BT/nFnFEz9aTt2zDxOHPhhUtLXi4qHX15e//GXzwAMPTD5YyttPP3yG2xfNl/7V/zS3v/CMOfkv6/0A/Te+8Q3zxBNPrDht0oNA9wSiM9DuQ8HjEAiMlrMr3S8eQlbdxSgFMzkDfeM58+QdT5rn3ijk7DLtGfNvzG03l+gl7K7xZ+TuTiye1pIABXQtT3uNpEf3MjfM4VNHzeXJ91xq2FGVwp4u38+2kXvMqjvgVopZ8u/mB8x//aIx//nffdB88IP27z/+H/PF7z9h7i7TKxkfMDJCh0BvCST/NZbeRk1g3ROQe5kH9q8pz03bayquDuzIDDS8XDtezr3p33/B/PA//HdnmVfubdZbvlU/HaSFCwisHQFmoGt3ykl4mQTeeuutkfvoU7ijXxwqf6q2iv7bb7+9zJTxDYGVJbD2M1B50IMNAl0RuO+++8xzzz1n3vOe93TiUv7t0fvvv78TXziBwLoRWOuncNftZJMvBCAAAQg0R4Al3OZYYgkCEIAABNaIAAV0jU42qUIAAhCAQHMEKKDNscQSBCAAAQisEQEK6BqdbFKFAAQgAIHmCFBAm2OJJQhAAAIQWCMCFNA1OtmkCgEIQAACzRGggDbHEksQgAAEILBGBCiga3SySRUCEIAABJojQAFtjiWWIAABCEBgjQgEf8rv3Llza4SAVCEAAQhAAALVCQQLqJh5+OGHq1tDAwIQgAAEILAmBPgt3DU50aQJAQhAAALNEuAeaLM8sQYBCEAAAmtCgAK6JieaNCEAAQhAoFkCFNBmeWINAhCAAATWhAAFdE1ONGlCAAIQgECzBCigzfLEGgQgAAEIrAkBCuianGjShAAEIACBZglQQJvliTUIQAACEFgTAhTQNTnRpAkBCEAAAs0SoIA2yxNrEIAABCCwJgQooGtyokkTAhCAAASaJbA2BfSR2z7fLDmsQQACEIDAWhOoVEClCOlfk9TasOnGN8TiGWLSZh7qL+UjNebyrrvftv26caEHAQhAIEQgq4DqxfXZ1z9l5K+NrS27Gmvb9tVPk60bc9vFRX1p6+fRtv+27fv5cAwBCEBgUQLRf85MDcuFLXZRVZl1aZfJYtnnoAn/KX5N2F+X1yF5QgAC/SCQNQP1Q13Hix0zJP9VUO0YftV4IQ0BCPSfQPLfA03NGNzU/ItjlQKrPlwbvr47pn7LZHRc7Yuea0fH1V6sdXVUxtf1Zfxx1Uu1MRtuv283NKZ9vmzKt4yJXkhH7YlMaFx1pXU3lXX1dVzH5Ngdd/vdMel35WTMlfXH/HE5ZoMABCDQOIGDxPa7t/5RYnQ85Mv4x2UGRN7VcfdF1z/2+3z90Lj0yRayNR4p/39M1+/3j8stz8cVshHqU9sypn/Sl5JVHb8t04mNh/pz+9wYQjoyLv3+mHvs7qu8a5d9CEAAAm0RKL0H6lZs95O+OwNwZersp2zpmOvb96Ey2u8fS7/oh/pVZ1ltU3G5ubn7y8iraf+59ppiuQxm+IQABAZIIFaZ/U/2Iuf3+cchmZj9mKxvU47dvth+yI/qahuSyelzfbryof5Qn6vj7odkc/vUTkhex3LbMhs54yITk4v1a3yx8VC/3yfH+qf2aCEAAQh0QaDSDLTrzwdNzCh09iK22Noh4DJu4pzlRtmlr9yYkIMABNaHQPQpXLkoukXH3Y/hWfSCVqZfFkPZeCzunP4c22Xxl/nJ8VFmY9njWkz9ONrKTey6f75fjiEAAQi0RaB0BqoXvpwLY0wmFLzY9Yt0SF/9h2zE9GM66jNkq26f6ysUf8quH78r69qVfjf21JhrI7VfZqPquPiqkn/Kvj8mtv0+Ofb9+TKixwYBCECgLQLJr7G05RS7EFiUQKyA+kV1UT/oQwACEIgRCBZQPsnHcNE/BAIU0SGcJWKEwPAJBAvo8NMiAwhAAAIQgEC7BKIPEbXrFusQgAAEIACBYROggA77/BE9BCAAAQgsiQAFdEngcQsBCEAAAsMmQAEd9vmbi35j46dzfXRAAAIQgEDzBEoLaO4FWeRyZZtPY3GLbcTfhs1UpuLv4OA3gyLLiKVLn136CgIOdPYxpkCYdEEAAjUJlBbQXLuxC3eu/rLlhh5/Gb+u8xN/Xfrs0lcZa8YhAIH1IJBVQOWTNFt1Al0WETlHFJHq52hRjdR7o8vzv2ge6EMAAtUJJAsoF+XqQNGAAAQgAIH1IFD6W7hlGEKfwN0+nRWV9YkfX1aOQ3puTKlxd8y1H9N3+1P7rl0/ZvUTkvFtujKqJ632a/7aqr761GOR9/vcMd33W/Wj/WpD+9Wvtiqnrd+v+jpe1qoflfP1y8ZFz5dRWzmtr6v+td/NT8fUrsrIse67Mton426/HOvmykifymm/HOu+Ox7TD8moLC0EINA8gawCqm9kfYNrGPLmdvv0zR6S9/t8XbGpfSqrxyl/vn899nVd+yl7OpZqNT71JbJ+n45JHKGtLD7VV13fvvanWt+HG4s/JnbcvjL/IuvK+/qpuGKyrj13X235faFjlS1rfV03JmXtyrj7Iqt8/H71645rn9uG9LQv5F90ddzfV7syzgYBCHRHoLSAxt6U7ps5FK5eBNwLie6LvO7H7LsyIfsh/2pT5VO2Q/qql9OKL9eGu5+jLzKp+KrY8PNW26H+XLs5cm3aV9sxRnV45+TkymgM0if7XfiM+Xf7Y/tuvDEZ+iEAgeYIRAuof7GIXcgWCaVtH32/oJTFp3y0XYR1HV31q20dG4vo+H7lmG1MQAu6y6Ps9eTKsg8BCCxOIFpAfdP6hq3zJvUvhGI71Of7HMrxsnJZlt8uzssq59YUP/+9CLOmyGIHAnkEkk/hpkxoQVUZefP6m8r4b3Rfrs6x2nZ1QzHExn39Ml3Xju6rjaby0xh8u/6x+k+1qqMyaluPU63qSiubf5zS7WpMY1J/VfJTnSqt2FceVfTakm0737bixi4EVolA8J8zc9+cetEI9QkI7RPwkvYAABV3SURBVHcvaKqj4+6xC0913T5/X3VdWe1T+6rj9vtjcuyPuzIypj5CciIb2kQnJK+2XB1fzpdxx327ZceuH3dffYhtd19k9Fjlc/27eqrj97nHIftl/kPjITvqJ5Sfysda1dVxzUWOU2Mqr63KpvRF1h2XY9WTfdl03O2P9bkyY+2pvh7TQgAC7RIIFtB2XWK9CQJyAdWLaxP2sDFLAL6zPDiCAATmCQQLaOjT7bwqPRCAQB8J8MGqj2eFmFaRQLCArmKi5AQBCEAAAhBokkDth4iaDAJbEIAABCAAgaERoIAO7YwRLwQgAAEI9IIABbQXp4EgIAABCEBgaAQooEM7Y8QLAQhAAAK9IEAB7cVpIAgIQAACEBgaAQro0M4Y8UIAAhCAQC8IUEB7cRoIAgIQgAAEhkaAAjq0M0a8EIAABCDQCwLBf43l3LlzvQiOICAAAQhAAAJ9JRAsoBLsww8/3NeYiQsCEIAABCCwdAL8lN/STwEBQAACEIDAEAlwD3SIZ42YIQABCEBg6QQooEs/BQQAAQhAAAJDJEABHeJZI2YIQAACEFg6AQro0k8BAUAAAhCAwBAJUECHeNaIGQIQgAAElk6AArr0U0AAEIAABCAwRAIU0CGeNWKGAAQgAIGlEwj+kAK/RLT080IAEIAABCDQcwLBAiox80tEPT9zhAcBCEAAAkslwC8RLRU/ziEAAQhAYKgEuAc61DNH3BCAAAQgsFQCFNCl4sc5BCAAAQgMlQAFdKhnjrghAAEIQGCpBCigS8WPcwhAAAIQGCoBCuhQzxxxQwACEIDAUglQQJeKH+cQgAAEIDBUAhTQoZ454oYABCAAgaUSoIAuFT/OIQABCEBgqASCv0T0gx8dmB/8aKgpETcEIACB5RB4340H5pe/2liOc7x2TmCugErx/ML/um5uufF658HgEAIQgMCQCbx34x3z9sF7hpwCsVcgECigZlQ8//Cxf1vBDKIQgAAEIACB9SLAPdD1Ot9kCwEIQAACDRGggDYEEjMQgAAEILBeBCig63W+yRYCEIAABBoiQAFtCCRmIAABCEBgvQjMPUQUS39jY/po9sHBQUxsrn/V9TRhybMKF9Xrsh1CjF3ywBcEIACBRQhkFVD/wusfxwLw5fzjoetp/JJX37chxNh3hsQHAQhAwCWwUku4y5gB5n4ocKEvY38ZbJaRJz4hAAEIdEUgawZaN5hlXbR1ttW2/6EUz7rnDz0IQAACEIgT6GwG2mWxkcIpf1pI4+kzAgEIQAACEKhHoJMC2mXxrIehutYq5lSdAhoQgAAE1pdAq0u4gnVVCw0z3PV905A5BCAAASGw8AxUCqT8hbZU8UzphWxpX0ovFofopvTUdqhN6elSsbRsEIAABCCwXgSyZqD+bKtKwfCLWo5uXX9d6+lLRXOUNic/1euyHUKMXfLAFwQgAIFFCWQVUHESKwyx/pSOjulFXY79LWY31q/6sXHpb8Of+I351Jj60A4hxj5wIgYIQAACuQSyC2iuwRw5LWRdXdS79pfDABkIQAACEBg2gaUU0K4Kp56arv2pX1oIQAACEFhdAgs/RLS6aMgMAhCAAAQgECdAAY2zYQQCEIAABCAQJUABjaJhAAIQgAAEIBAnkH0PVB/EEVNV7imm9FJj8ZDH3+nU8SqxqI749fX6Eosbh8brx6r9VdtQ3lVtIA8BCEAAAmMCWQXUv/D6xzGYvpx77O6Lvn9cx2ZMx+0XP/7m+/aPfXk99uX8Y5WLtSIf2poqmK7tmC9Xhn0IQAACEMgn0OoSbhuFID+1eclYgVtGnLFY5qNupmcZOTYTOVYgAAEI9JNA1gx00dB19uNexN39Re3n6OcUrFCcObarypTFonGI3a45Vc0FeQhAAALrSqCTAqpFIFY4Yv1dn5SyOLuKR+MQf31h01Xu+IEABCAwFAKtLuHmQOiiQHThIydXkSmLxS2euTaRgwAEIACB7gl0MgONpVVWTGJ6VfulKImvPmxlsXTFpA8siAECEIDAkAksPAOVC36sOMX6BViqUKRspmCn9KRw6Z9voyzO1LhvS4/rxqL6tBCAAAQg0G8CWTNQf9YkxzlbmZ5fmHLsltksi0t9Sqv+6tqsq6cxNhmL2oy1IV8xWfohAAEIQKCcQFYBFTNabHyTsX6Vi43H+tWXXvDVjtvGdGP9i+iKzb7E4uZRdT+HTVWbyEMAAhBYZwLZBbQrSFqs+nDB71MsXfHHDwQgAAEI5BHoXQHtQ+FUdH2KRWOihQAEIACBfhBY+CGifqRBFBCAAAQgAIFuCVBAu+WNNwhAAAIQWBECFNAVOZGkAQEIQAAC3RLIvgeqD9RIeFXuDab0UmMpDG3otWEzloPrS2VCTEUu1K86Vdum7VX1jzwEIACBVSKQVUD9C69/HAPiy7nH7r7o+8d1bMZ0QvZdf+5+SDZmt66e2CsrjGK7ya1pe03Ghi0IQAACQySwtCXcsgLSNMyUv9RY03Hk2PMLc45OmUzfciyLl3EIQAACfSeQNQOtm0TORVtnRjmydeNw9VL+UmOujSb21ZfYcnOXfve4CV/YgAAEIACB5gm0WkDdcGOFQYtFbNy10cR+yl9qrAnfrg31JX1d5e76Zx8CEIAABBYj0MkSLgVi9iS5xdMdgZNLg30IQAAC/SbQ+gyUojD/AogxkcIqY2wQgAAEINB/AgvPQOWCH7voxwqFYInp6FhqPIZVdGJ6sX71V8dmTEdtpnzGdKWI6l9Mhn4IQAACEFg+gawZqD8zkuPczS8iqlvXZht6bdhM8cnxp9ykFflFt6btLRoP+hCAAASGTiCrgEqSsYt4rD+lo9BiutKvF3yVdduUnivn78f0RC42toxYUvH4OeUex/LL1UcOAhCAAARmCWQX0Fm19o60cPbhgt+nWNojjmUIQAACEKhDoHcFtA+FU0H2KRaNiRYCEIAABPpBYOGHiPqRBlFAAAIQgAAEuiVAAe2WN94gAAEIQGBFCFBAV+REkgYEIAABCHRLIPseqD5QI+HVuTco+lX06vhzdRRjrk9XN1dHfSyiqza6aiXWqvl1FRt+IAABCAyJQFYB9S+6/nFZwm6BKZOVcd++f5yyUac4+Pb945Q/V1b2+7z1Pb4+syM2CEAAAj6B1pdw3QLjOx/6sZ9bneLdFQM/1q784gcCEIDAqhLImoHWLQx1L9p1/clJEp+65drJlVO7fqs+F7Xj223quO55aMo/diAAAQisIoGsAuom3vXFuKo/t4hV1ZU8q+q48u6+y4x9CEAAAhBYPQKVlnCrFIgqsjGsVW24xTNmM9Vf1Z/YWtRnKp4mxurk1IRfbEAAAhBYdQLZM9CqF2IpLKJTd6vqT/zU0dH4FtFVG31sFz0PfcyJmCAAAQj0gUBWAU0VFxmTLTQTc/tUTpPWY1fGHQv1y3hKT/VDbUpPxpr2F4phWX1ubsphWbHgFwIQgMCqEMgqoJKsf+F1L8plMFQ3Vah8G6qj/Tn+RMbVy9FR+66e9OXoLuJP/XbZao7S5uTXZWz4ggAEIDA0AlkFNHWxTY0pjJCM9OkFXeW0DcnnjIlMTLdrfxpvn9oYmz7FSCwQgAAEhkIgq4A2nYwWzq4u6F37a5oX9iAAAQhAoH8EllJAuyqcirtrf+qXFgIQgAAEVpdApa+xrC4GMoMABCAAAQhUI0ABrcYLaQhAAAIQgMCIAAWUFwIEIAABCECgBoHse6D6II74qHJPcdX1hIfkWIWJ6HS91T0PXceJPwhAAAJDIZBVQP0C4R/HkvXl/OOh60n8klPfN5+7f9z3+IkPAhCAQB8JtLqE2/dZWRMnZB1ybIITNiAAAQisGoGsGeiiRUJnabl2cuX8k9G1nu+/r8d1ufQ1H+KCAAQg0AcClWegdZb/5AIuf1pIqyRex5/Y71qvSk7LlK3LZZkx4xsCEIBAHwlUKqBdX3zr+utar48nNhRTXS4hW/RBAAIQWHcC2QW064tvXX9d6w3lBVSXy1DyI04IQAACXRPIKqCpi6+MyV9oi/WLbJle7L5dn/RCOfexT5jFePYxXmKCAAQgMAQCWQ8RSSJ+Mcy5IPv3PXN0FFodf3XjbEKv70WqLk89H7QQgAAEIDBLIKuApgpfakxcxcal37+oa2gxnZS9nLGm/ZX51HyW3aZ4Ljs2/EMAAhAYKoGsAtp0clrIurqwd+2vaV7YgwAEIACB/hFYSgHtqnAq7q79qV9aCEAAAhBYXQJZDxGtbvpkBgEIQAACEKhHgAJajxtaEIAABCCw5gQooGv+AiB9CEAAAhCoRyDrHqg+hOO6qHpfUWzk6iziz9Xtqz+XY5f7Vc5Bl3HhCwIQgMAQCWQVUEkstxiFILhFLTQe6lN/VS76vqx/HPKjfV37U79dtXXOQVex4QcCEIDAEAm0voRbpYgpQC1metx227W/tvMJ2V+HHEN50wcBCECgLQLZM1B3BpN7Ma5TPBdJNDeuRXy4ul37c32zDwEIQAACyyWQXUDdYtFVYVzETx3dOjp6+hbRVRu0EIAABCAwHAJZS7hu8cxNbZkFpWvfXfvLPQfIQQACEIBAewSyZqB1CoQUXdHreqsT6yIxdu1vkVjRhQAEIACB5ghkFdCUOy2SoVmq26dyakuPXRkdS7UpPRmL2UvpteEvZZMxCEAAAhAYPoGsAipFSQuQpBwrUjEcqpsqcDHdqv3qS/Wqxqp6uW3X/nLj8uU0zi7Oge+bYwhAAAKrSCCrgErisUIU63dhhWSkTy/qrqy7H9NzZdz9kLyOd+1P/falTbHpS4zEAQEIQGBIBLILaJNJaeHs6qLetb8mWWELAhCAAAT6SWApBbSrwqnIu/anfmkhAAEIQGB1CWR9jWV10yczCEAAAhCAQD0CFNB63NCCAAQgAIE1J0ABXfMXAOlDAAIQgEA9Aln3QPUhHNdFlfuKrn6OniuvPnP0VNbVz9Wro6P+aCEAAQhAYP0IZBVQwZJbiHyEUphU1y1Svpx/7Orovi8TOq7jz9URm/5xyA99EIAABCCw3gRaXcL1C1FuIcyV809d1/58/xxDAAIQgMD6EMiegUpx0q1qgVPdqnrqr2pb119dvarxIQ8BCEAAAsMnkF1A3eInhcY9TmFwZd39lI6OVZUXPVfH3VebqVZzqqqXsskYBCAAAQisJoGsJVwtLHUQLKI7BH91YkQHAhCAAASGTyCrgMqMjA0CEIAABCAAgSmBrAI6FZ/fk+Jap8B2rTcf+bSnTvxTbfYgAAEIQGAdCWTdA5VlWLfI5C7L1tWreyLq+qurVzdO9CAAAQhAYPgEsgqopBkrmrF+RRMb94uWyrttSLdML6Tj2ozt19WL2aMfAhCAAARWm0B2AW0Sg85mqxatunpNxo4tCEAAAhCAgBBYSgGtWjj1VNXVU31aCEAAAhCAQFMEFn6IqKlAsAMBCEAAAhAYEgEK6JDOFrFCAAIQgEBvCFBAe3MqCAQCEIAABIZEIOseqD684yaWez/S1a2joz5zdUVefFaRVx+LxlrHp/puu62TW9sxYR8CEIDAkAlkFVBJsE5x8AuZf5wCp/6q6Ig9t1Ck7Ptjrp9cG66O+ta4ffvLPB5KnMtkhG8IQAACVQn0cgl3kSJUR9cvMLk2cuWqnpSm5YcSZ9N5Yw8CEIBAmwSyZ6DurCz3gixyWpy0bTOZRW1rjrn5qb+6eqrfVTuUOLvigR8IQAACixDILqBuUalaDPXCXTXQqn6q2nflXV/uvisT21c2VfVi9trqH0qcbeWPXQhAAAJNEsgqoHrhrerYLyj+cVV7bcrXzbHNmLANAQhAAAL9JZB1D1QKHxsEIAABCEAAAlMCWQV0Kj6/J8W1ToFdBb06ec8TbL9nKHG2TwIPEIAABJojkL2E616Ec5c7Ra6O3iLpqT9p245zGfnVYTOUOOvkhg4EIACBZRHIKqASXKwYxfo1odi4f1FXebcN6Yb6ynRkvMxfzG6sX32WjavcstuhxLlsTviHAAQgkEsgu4DmGsyR01liVxf1rv3lMEAGAhCAAASGTWApBbSrwqmnpmt/6pcWAhCAAARWl8DCDxGtLhoygwAEIAABCMQJUEDjbBiBAAQgAAEIRAlQQKNoGIAABCAAAQjECVS6B6oP44i5KvcVq+q58hp6FX+iIzaq6Lg+q+hpfLQQgAAEILBeBLILqFuQ3GJThquu3iJFrEp8Er8bY+i4LEfGIQABCEBg/QhkLeH6BSa3uNXVW+Q0+D4XsYUuBCAAAQhAIEYgewYqBqQ4yZZbQEfC9n919FSnir+6xbNqPpoXLQQgAAEIrC+B7ALqFid3vwydK+vul+m5Ra2KXpndsvEufZXFwjgEIAABCPSXQNYSroTvFrQq6dTRq6PTROFrwkYVNshCAAIQgMBwCWTPQLtMsU4hk6IrenW3Oj7r+kIPAhCAAASGT2DhAqpFq+qssQ09Nwa1n3OKKJ45lJCBAAQgAAGXQFYB9Wd3bqFyjfn7Xeupfy2eVQqj6qiN3BxVnhYCEIAABNaLQFYBFSSxguIXSR9fG3q+D/845tOX0+Oq8qpHCwEIQAAC60sgu4CGEOmsrWoBqqsXioE+CEAAAhCAwDIILFRAqxZOTbCunurTQgACEIAABJZNIPtrLMsOFP8QgAAEIACBPhGggPbpbBALBCAAAQgMhgAFdDCnikAhAAEIQKBPBCoVUH34J5RAaiwkr30xPenXP5XNbduwmeu773IxNn2Pm/ggAAEI9I1A9kNEqQtvaiyVcExP+t0Hjfzjrm2m/A1pLMZ7SDkQKwQgAIG+EMiegboFzQ8+NebLusd19Vwb/n7MZqzf11/V4yofQlaVAXlBAAIQaJJA9gy0SadlttosdjoLa9NHWX5dj1M8uyaOPwhAYB0IZM9AlwWj6Yu/FE7500K6rLzwCwEIQAACwybQ6wLadPEc9qmqFz0M63FDCwIQgEAZgV4u4UrQXPjLTl3eOLPtPE5IQQACEKhKoNUZqBRB+au6pYrnIjarxrEq8rpsLS0bBCAAAQg0QyC7gGoh1NZ1r33aumOpfZXX1pWVPvfPHUvtqy1tVVZnYmpzHYuJMtFW2dBCAAIQgEB1AtlLuKmCExvTohULK6WX0kkVgJhNsZcai/lbpf51z3+VziW5QAACyyeQXUCrhqpFrsmLdhs2q+aFPAQgAAEIQEAItFZAmyyceqrasKm2aSEAAQhAAAJVCGTfA61iFFkIQAACEIDAqhOggK76GSY/CEAAAhBohQAFtBWsGIUABCAAgVUnQAFd9TNMfhCAAAQg0AoBCmgrWDEKAQhAAAKrToACuupnmPwgAAEIQKAVAhTQVrBiFAIQgAAEVp3A/wdsM4wSQYKbkgAAAABJRU5ErkJggg==" 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个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类 ...
随机推荐
- swift派发机制的核心是确定一个函数能否进入动态派发列表
swift派发机制的核心是确定一个函数能否进入动态派发列表
- 对称加密DES加密
DES加密: des是对称加密,加密和解密需要相同的秘钥,它的密码最长56位,必须是8的倍数,秘钥越长,越安全. package com.trm.util.encrypt; import java.s ...
- 几个net命令
A.显示当前工作组服务器列表 net view,当不带选项使用本命令时,它就会显示当前域或网络上的计算机上的列表. 比如:查看这个IP上的共享资源,就可以 C:\\>net view 192 ...
- 谈谈JVM垃圾回收机制及垃圾回收算法
一.垃圾回收机制的意义 Java语言中一个显著的特点就是引入了垃圾回收机制,使c++程序员最头疼的内存管理的问题迎刃而解,它使得Java程序员在编写程序的时候不再需要考虑内存管理.由于有个垃圾回收机制 ...
- 在 XML 中有 5 个预定义的实体引用
- 2.10.4 aside元素
aside元素 <!DOCTYPE html> <html> <head> <meta charset="utf-8" /> < ...
- PHP解惑(一)
PHP给人的印象是入门简单的语言.当你的技术能力达到一定阶段时,会发现情况并非如此. PHP采用"极简主义",就是以入门容易为准则设计的,在十几年的持续发展历程中,它早已成为一个开 ...
- 集训第五周动态规划 C题 编辑距离
Description Let x and y be two strings over some finite alphabet A. We would like to transform x int ...
- windows下mysql使用实录
之前密码忘了,卸载重装,配置好环境变量,登录,成功 操作命令可参考http://www.runoob.com/mysql/mysql-tutorial.html 这里只列举了我需要用到的命令 登录:m ...
- git-svn 简易 操作指南
git-svn 简易 操作指南 本文用以为使用svn的用户提供git操作指导,方便使用git管理用户自己的 本地修改 1:下载 库 下载全部历史记录 git svn clone svn://fhnws ...