Mahout源码MeanShiftCanopyDriver分析之二MeanShiftCanopyMapper仿造

首先更正一点，昨天处理数据的时候是有问题的，直接从网页中拷贝的文件的空格是有问题的，直接拷贝然后新建的文件中的空格可能有一个两个、三个的，所以要把两个或者三个的都换为一个，在InputMapper中下面的代码：

 

private static final Pattern SPACE = Pattern.compile(" ");

String[] numbers = SPACE.split(values.toString());

可以看到这个代码是以一个空格来区分的，可以在linux的terminal中输入下面的命令来进行替换：

 

 

Sed -I "s/   / /g" `grep    -l synthetic_control.data`   -- 替换三个空格为一个空格

Sed -I "s/  / /g" `grep    -l synthetic_control.data`    -- 替换两个空格为一个空格

通过上面的命令，然后在上传，使用昨天的命令进行meanshiftCanopyDriver的调用。
不过补充一点，因为在InputMapper中对这个数据的处理还有下面的代码：

 

 

 for (String value : numbers) {

      if (!value.isEmpty()) {

        doubles.add(Double.valueOf(value));

      }

    }

这个代码就表示如果是空字符串的话，就不进行添加，所以说输入数据和前面保持一致也是可以的，即昨天的数据和今天修改的数据其结果一样。
MeansShiftCanopyDriver的run方法跳转如下：

 

run（159行）-->buildClusters（282行）-->buildClustersMR(353行)-->runIterationMR(412行)，这里说明几点：

在159行开始run方法进入后，进行第一个判断inputIsCanopies，如下：

 

if (inputIsCanopies) {

      clustersIn = input;

    } else {

      createCanopyFromVectors(conf, input, clustersIn, measure, runSequential);

    }

因为在前面的测试中我们已经使用了InputDriver把输入数据转换为了canopy，所以这里直接进入了clustersIn=input，然后往下面走；

 

在282行的buildClusters方法进入后因为是默认在Hadoop中跑的程序，所以是使用MR算法的，进入到else中，如下：

 

if (runSequential) {

      return buildClustersSeq(clustersIn, output, measure, kernelProfile, t1,

          t2, convergenceDelta, maxIterations, runClustering);

    } else {

      return buildClustersMR(conf, clustersIn, output, measure, kernelProfile,

          t1, t2, convergenceDelta, maxIterations, runClustering);

    }

在353行中的方法buildClustersMR进入后，即开始进行循环，混合的主体是412行的runIterationMR方法。本篇主要分析此Job的Mapper和Reducer类，

 

这两个类分别是MeanShiftCanopyMapper、MeanShiftCanopyReducer。下面的代码是MeanShiftCanopyMapper的仿造代码，可以直接使用此代码进行调试，这样就可以看到MeanShiftCanopyMapper的数据逻辑流了，今晚又太晚了，明天还要早起。就下次再分析了，代码如下：

 

package mahout.fansy.meanshift;



import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;



import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.Path;

import org.apache.hadoop.io.Text;

import org.apache.hadoop.io.Writable;

import org.apache.mahout.clustering.iterator.ClusterWritable;

import org.apache.mahout.clustering.meanshift.MeanShiftCanopy;

import org.apache.mahout.clustering.meanshift.MeanShiftCanopyClusterer;

import org.apache.mahout.clustering.meanshift.MeanShiftCanopyConfigKeys;

import org.apache.mahout.common.iterator.sequencefile.PathFilters;

import org.apache.mahout.common.iterator.sequencefile.PathType;

import org.apache.mahout.common.iterator.sequencefile.SequenceFileDirValueIterable;



import com.google.common.collect.Lists;



public class MeanShiftCanopyMapperFollow {



	/**

	 * MeanShiftCanopyMapper仿造代码

	 * @author fansy

	 * @param args

	 */

	public static void main(String[] args) {

		cleanup();// 调试cleanup函数

	}

	

	/**

	 * 仿造map操作

	 */

	public static Collection<MeanShiftCanopy> map(){

		Collection<MeanShiftCanopy> canopies = Lists.newArrayList();

		List<ClusterWritable> data=getMapData(); // 获取map的输入值

		MeanShiftCanopyClusterer clusterer=setup();  // 获取setup函数中经过设置的值

		for (ClusterWritable clusterWritable : data){  // 这里设置断点，查看程序初始数据

			MeanShiftCanopy canopy = (MeanShiftCanopy)clusterWritable.getValue();

		      clusterer.mergeCanopy(canopy.shallowCopy(), canopies);

		}

		return canopies;

	}

	/**

	 * 仿造setup函数

	 * @return 返回经过设置值的MeanShiftCanopyClusterer

	 */

	public static MeanShiftCanopyClusterer setup(){

		String measureClassName="org.apache.mahout.common.distance.EuclideanDistanceMeasure";

		String kernelProfileClassName="org.apache.mahout.common.kernel.TriangularKernelProfile";

		double convergenceDelta=0.5;

		double t1=47.6;

		double t2=1;

		boolean runClustering=true;

		Configuration conf =new Configuration();

		

		conf.set(MeanShiftCanopyConfigKeys.DISTANCE_MEASURE_KEY, measureClassName);

	    conf.set(MeanShiftCanopyConfigKeys.KERNEL_PROFILE_KEY,

	        kernelProfileClassName);

	    

		conf.set(MeanShiftCanopyConfigKeys.CLUSTER_CONVERGENCE_KEY, String

	        .valueOf(convergenceDelta));

	   

		conf.set(MeanShiftCanopyConfigKeys.T1_KEY, String.valueOf(t1));

	    conf.set(MeanShiftCanopyConfigKeys.T2_KEY, String.valueOf(t2));

	

	    conf.set(MeanShiftCanopyConfigKeys.CLUSTER_POINTS_KEY, String

	        .valueOf(runClustering));

		MeanShiftCanopyClusterer clusterer = new MeanShiftCanopyClusterer(conf);

		

		return clusterer;

	}

	/**

	 * 仿造cleanup函数

	 */

	public static Map<Text,ClusterWritable> cleanup(){

		int numReducers=1; // 自己设定，这里为了方便直接设置为1

		Map<Text,ClusterWritable> map=new HashMap<Text,ClusterWritable>();

		Collection<MeanShiftCanopy> canopies=map(); // 获得map的输出

		MeanShiftCanopyClusterer clusterer =setup();// 获得setup的输出

		int reducer = 0;

	    for (MeanShiftCanopy canopy : canopies) {

	      clusterer.shiftToMean(canopy);

	      ClusterWritable clusterWritable = new ClusterWritable();

	      clusterWritable.setValue(canopy);

	      map.put(new Text(String.valueOf(reducer)), clusterWritable);

	      reducer++;

	      if (reducer >= numReducers) {

	    	  reducer=0;

	      }

	    }

	    return map;

	}

	/**

	 * 获得map的输入数据,输入数据的value是ClusterWritable类型的

	 * @return

	 */

	public static List<ClusterWritable> getMapData(){

		Path input=new Path("hdfs://ubuntu:9000/user/test/input/real_input/part-m-00000"); //路径是经过InputDriver后的输出路径

		Configuration conf=new Configuration();

		conf.set("mapred.job.tracker", "ubuntu:9001");

		List<ClusterWritable> clusters = new ArrayList<ClusterWritable>();

    	for (Writable value : new SequenceFileDirValueIterable<Writable>(input, PathType.LIST,

    	        PathFilters.partFilter(), conf)) {

    	      Class<? extends Writable> valueClass = value.getClass();

    	      if (valueClass.equals(ClusterWritable.class)) {

    	        ClusterWritable clusterWritable = (ClusterWritable) value;

    	        clusters.add( clusterWritable);

    	      } else {

    	        throw new IllegalStateException("can't read " + input);

    	      }

    	    }

    	return clusters;

	}



}

今天培训还听讲师说不要抱怨，额，好吧，现在感觉天天都是1点半之后或者左右的时间睡觉了，严重感觉睡眠不足，哎，难道这就是程序员的名？今天讲师还说确定目标后有四个阶段：初始兴奋期、寂寞期、煎熬期、成功期，我现在还在哪个阶段熬着呀。额，好吧，慢慢来，坚持。。。

 

 

分享，快乐，成长

转载请注明出处：http://blog.csdn.net/fansy1990