Hadoop k-means 算法实现

最新推荐文章于 2017-07-09 19:47:18 发布
最新推荐文章于 2017-07-09 19:47:18 发布
阅读量323 收藏
点赞数
文章标签： 大数据 java 数据结构与算法
本文介绍了一种基于Hadoop平台实现K-means聚类算法的方法，详细讲解了从准备阶段到具体实现过程中的map-combine-reduce操作，并附上了完整的代码示例及运行结果分析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

经过昨天的准备工作，今天基本就可以编写整个k-means算法程序了。今天编写的时候遇到了一个问题，是combine操作时遇到的问题。除了这个问题基本都按照原来的思路进行。先说下我的思路吧。

准备工作：在上传数据文件到HDFS上之前，先应该产生一个中心文件，比如我的输入文件如下：

0.0	0.2	0.4
0.3	0.2	0.4
0.4	0.2	0.4
0.5	0.2	0.4
5.0	5.2	5.4
6.0	5.2	6.4
4.0	5.2	4.4
10.3	10.4	10.5
10.3	10.4	10.5
10.3	10.4	10.5
然后要产生中心文件，可以使用如下命令来操作：

（1）、获取文件的总行数： wc data.txt 。可以得到文件的行数是 ：10

（2）、因为我要分为三类，所以10/3=3，那么我取的行数就是1，3，6（这个行数可以自己选择，比如也可以直接去前三行 head -n 3 data.txt >centers.txt）,然后使用如下命令：awk 'NR==1||NR==3||NR==6' data.txt > centers.txt，然后再把centers.txt上传到HDFS上就可以了。

（下面我使用的是前三行作为数据中心文件）

下面的程序中就不用设置要分 的类别和数据文件的维度数了，我在写这篇和前篇文章的时候参考了这篇文章：http://www.cnblogs.com/zhangchaoyang/articles/2634365.html，这篇里面要在代码中自己设置要分的类别以及数据文件的维度数。

下面是map-combine-reduce 操作：

map: map的setup()函数主要是读取中心文件把文件的中心点读入一个double[][]中，然后是map。数据转换为：

Text(包含数据的字符串)--》[index,DataPro(Text(包含数据文件的字符串),IntWritable(1))]

combine:

[index,DataPro(Text(包含数据文件的字符串),IntWritable(1))]-->[index,DataPro(Text(包含数据文件相同index的相加的结果的字符串),IntWritable(sum(1)))]

reduce: reduce的setup()函数主要是读取数据中心文件，然后取出其中的数据维度信息（在reduce操作中需要数组赋值需要知道数据维度），

[index,DataPro(Text(包含数据文件相同index的相加的结果的字符串),IntWritable(sum(1)))]--》[index,DataPro(Text(包含数据文件相同index的相加的结果的字符串),IntWritable(sum(1)))]--》[index,Text(相同index的数据相加的平均值)]

上面的是循环的过程，最后一个job任务是输出分类的结果。

下面贴代码：

KmeansDriver:

package org.fansy.date928;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.Log;
//import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
//import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.NullWritable;
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.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

public class KmeansDriver {

	/**
	 *   k-means algorithm program  
	 */
	private static final String temp_path="hdfs://fansyPC:9000/user/fansy/date928/kmeans/temp_center/";
	private static final String dataPath="hdfs://fansyPC:9000/user/fansy/input/smallkmeansdata";
	private static final int iterTime=300;
	private static int iterNum=1;
	private static final double threadHold=0.01;
	
	private static Log log=LogFactory.getLog(KmeansDriver.class);
	
	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		// TODO Auto-generated method stub
		Configuration conf=new Configuration();
		
		// set the centers data file
		Path centersFile=new Path("hdfs://fansyPC:9000/user/fansy/input/centers");
		DistributedCache.addCacheFile(centersFile.toUri(), conf);
		
		String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
	    if (otherArgs.length != 1) {
	      System.err.println("Usage: KmeansDriver <indatafile> ");
	      System.exit(2);
	    }
	    Job job = new Job(conf, "kmeans job 0");
	    job.setJarByClass(KmeansDriver.class);
	    job.setMapperClass(KmeansM.class);
	    job.setMapOutputKeyClass(IntWritable.class);
		job.setMapOutputValueClass(DataPro.class);
	    job.setNumReduceTasks(1);
	    job.setCombinerClass(KmeansC.class);
	    job.setReducerClass(KmeansR.class);
	    job.setOutputKeyClass(NullWritable.class);
	    job.setOutputValueClass(Text.class);    
	    FileInputFormat.addInputPath(job, new Path(dataPath));
	    FileOutputFormat.setOutputPath(job, new Path(temp_path+0+"/"));  
	    if(!job.waitForCompletion(true)){
	    	System.exit(1); // run error then exit
	    }
	    //  do iteration
	    boolean flag=true;
		while(flag&&iterNum<iterTime){
			Configuration conf1=new Configuration();
			
			// set the centers data file
			Path centersFile1=new Path(temp_path+(iterNum-1)+"/part-r-00000");  //  the new centers file
			DistributedCache.addCacheFile(centersFile1.toUri(), conf1);
			boolean iterflag=doIteration(conf1,iterNum);
			if(!iterflag){
				log.error("job fails");
				System.exit(1);
			}
			//  set the flag based on the old centers and the new centers
			
			Path oldCentersFile=new Path(temp_path+(iterNum-1)+"/part-r-00000");
			Path newCentersFile=new Path(temp_path+iterNum+"/part-r-00000");
			FileSystem fs1=FileSystem.get(oldCentersFile.toUri(),conf1);
			FileSystem fs2=FileSystem.get(oldCentersFile.toUri(),conf1);
			if(!(fs1.exists(oldCentersFile)&&fs2.exists(newCentersFile))){
				log.info("the old centers and new centers should exist at the same time");
				System.exit(1);
			}
			String line1,line2;
			FSDataInputStream in1=fs1.open(oldCentersFile);
			FSDataInputStream in2=fs2.open(newCentersFile);
			InputStreamReader istr1=new InputStreamReader(in1);
			InputStreamReader istr2=new InputStreamReader(in2);
			BufferedReader br1=new BufferedReader(istr1);
			BufferedReader br2=new BufferedReader(istr2);
			double error=0.0;
			while((line1=br1.readLine())!=null&&((line2=br2.readLine())!=null)){
				String[] str1=line1.split("\t");
				String[] str2=line2.split("\t");
				for(int i=0;i<str1.length;i++){
					error+=(Double.parseDouble(str1[i])-Double.parseDouble(str2[i]))*(Double.parseDouble(str1[i])-Double.parseDouble(str2[i]));
				}
			}
			if(error<threadHold){
				flag=false;
			}
			iterNum++;
			
		}
		// the last job , classify the data
		
		Configuration conf2=new Configuration();
		// set the centers data file
		Path centersFile2=new Path(temp_path+(iterNum-1)+"/part-r-00000");  //  the new centers file
		DistributedCache.addCacheFile(centersFile2.toUri(), conf2);
		lastJob(conf2,iterNum);
		System.out.println(iterNum);
	}
	
	public static boolean doIteration(Configuration conf,int iterNum) throws IOException, ClassNotFoundException, InterruptedException{
		boolean flag=false;
		Job job = new Job(conf, "kmeans job"+" "+iterNum);
	    job.setJarByClass(KmeansDriver.class);
	    job.setMapperClass(KmeansM.class);
	    job.setMapOutputKeyClass(IntWritable.class);
		job.setMapOutputValueClass(DataPro.class);
	    job.setNumReduceTasks(1);
	    job.setCombinerClass(KmeansC.class);
	    job.setReducerClass(KmeansR.class);
	    job.setOutputKeyClass(NullWritable.class);
	    job.setOutputValueClass(Text.class);    
	    FileInputFormat.addInputPath(job, new Path(dataPath));
	    FileOutputFormat.setOutputPath(job, new Path(temp_path+iterNum+"/"));  
	    flag=job.waitForCompletion(true);
		return flag;
	}
	public static void lastJob(Configuration conf,int iterNum) throws IOException, ClassNotFoundException, InterruptedException{
		Job job = new Job(conf, "kmeans job"+" "+iterNum);
	    job.setJarByClass(KmeansDriver.class);
	    job.setMapperClass(KmeansLastM.class);
	    job.setMapOutputKeyClass(IntWritable.class);
		job.setMapOutputValueClass(Text.class);
	    job.setNumReduceTasks(4);
	  //  job.setCombinerClass(KmeansC.class);
	    job.setReducerClass(KmeansLastR.class);
	    job.setOutputKeyClass(IntWritable.class);
	    job.setOutputValueClass(Text.class);    
	    FileInputFormat.addInputPath(job, new Path(dataPath));
	    FileOutputFormat.setOutputPath(job, new Path(temp_path+iterNum+"/"));  
	    job.waitForCompletion(true);
	}

}

Mapper: 
package org.fansy.date928;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class KmeansM extends Mapper<LongWritable,Text,IntWritable,DataPro>{
	private static Log log=LogFactory.getLog(KmeansM.class);
	
	private double[][] centers;
	private int dimention_m;  //  this is the k 
	private int dimention_n;   //  this is the features 

	
    static enum Counter{Fansy_Miss_Records};
	@Override
	public void setup(Context context) throws IOException,InterruptedException{
		Path[] caches=DistributedCache.getLocalCacheFiles(context.getConfiguration());
		if(caches==null||caches.length<=0){
			log.error("center file does not exist");
			System.exit(1);
		}
		BufferedReader br=new BufferedReader(new FileReader(caches[0].toString()));
		String line;
		List<ArrayList<Double>> temp_centers=new ArrayList<ArrayList<Double>>();
		ArrayList<Double> center=null;
		//  get the file data
		while((line=br.readLine())!=null){
			center=new ArrayList<Double>();
			String[] str=line.split("\t");
		//	String[] str=line.split("\\s+");
			for(int i=0;i<str.length;i++){
				center.add(Double.parseDouble(str[i]));
			//	center.add((double)Float.parseFloat(str[i]));
			}
			temp_centers.add(center);
		}
		try {
			br.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//  fill the centers 
		@SuppressWarnings("unchecked")
		ArrayList<Double>[] newcenters=temp_centers.toArray(new ArrayList[]{});
		 dimention_m=temp_centers.size();
		 dimention_n=newcenters[0].size();
		centers=new double[dimention_m][dimention_n];
		for(int i=0;i<dimention_m;i++){
			Double[] temp_double=newcenters[i].toArray(new Double[]{});
			for(int j=0;j<dimention_n;j++){
				centers[i][j]=temp_double[j];
		//		System.out.print(temp_double[j]+",");
			}
		//	System.out.println();
		}
	}
		
		
	public void map(LongWritable key,Text value,Context context)throws IOException,InterruptedException{
		String[] values=value.toString().split("\t");
	//	String[] values=value.toString().split("\\s+");
		if(values.length!=dimention_n){
			context.getCounter(Counter.Fansy_Miss_Records).increment(1);
			return;
		}
		double[] temp_double=new double[values.length];
		for(int i=0;i<values.length;i++){
			temp_double[i]=Double.parseDouble(values[i]);
		}
		//  set the index
		double distance=Double.MAX_VALUE;
		double temp_distance=0.0;
		int index=0;
		for(int i=0;i<dimention_m;i++){
			double[] temp_center=centers[i];
			temp_distance=getEnumDistance(temp_double,temp_center);
			if(temp_distance<distance){
				 index=i;
				distance=temp_distance;
			}
		}
		DataPro newvalue=new DataPro();
		newvalue.set(value, new IntWritable(1));
	//	System.out.println("the map out:"+index+","+value);
		context.write(new IntWritable(index), newvalue);
		
	}
	public static double getEnumDistance(double[] source,double[] other){  //  get the distance
		double distance=0.0;
		if(source.length!=other.length){
			return Double.MAX_VALUE;
		}
		for(int i=0;i<source.length;i++){
			distance+=(source[i]-other[i])*(source[i]-other[i]);
		}
		distance=Math.sqrt(distance);
		return distance;
	}
}

Combiner: 
package org.fansy.date928;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class KmeansC extends Reducer<IntWritable,DataPro,IntWritable,DataPro> {
	private static int dimension=0;
	
	private static Log log =LogFactory.getLog(KmeansC.class);
	// the main purpose of the sutup() function is to get the dimension of the original data
	public void setup(Context context) throws IOException{
		Path[] caches=DistributedCache.getLocalCacheFiles(context.getConfiguration());
		if(caches==null||caches.length<=0){
			log.error("center file does not exist");
			System.exit(1);
		}
		BufferedReader br=new BufferedReader(new FileReader(caches[0].toString()));
		String line;
		while((line=br.readLine())!=null){
			String[] str=line.split("\t");
		//	String[] str=line.split("\\s+");
			dimension=str.length;
			break;
		}
		try {
			br.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	
	public void reduce(IntWritable key,Iterable<DataPro> values,Context context)throws InterruptedException, IOException{	
		double[] sum=new double[dimension];
		int sumCount=0;
		// operation two
		for(DataPro val:values){
			String[] datastr=val.getCenter().toString().split("\t");
	//		String[] datastr=val.getCenter().toString().split("\\s+");
			sumCount+=val.getCount().get();
			for(int i=0;i<dimension;i++){
				sum[i]+=Double.parseDouble(datastr[i]);
			}
		}
		//  calculate the new centers
//		double[] newcenter=new double[dimension];
		StringBuffer sb=new StringBuffer();
		for(int i=0;i<dimension;i++){
			sb.append(sum[i]+"\t");
		}
	//	System.out.println("combine text:"+sb.toString());
	//	System.out.println("combine sumCount:"+sumCount);
		DataPro newvalue=new DataPro();
		newvalue.set(new Text(sb.toString()), new IntWritable(sumCount));
		context.write(key, newvalue);
	}
}

Reducer: 
package org.fansy.date928;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class KmeansR extends Reducer<IntWritable,DataPro,NullWritable,Text> {
	private static int dimension=0;
	
	private static Log log =LogFactory.getLog(KmeansC.class);
	// the main purpose of the sutup() function is to get the dimension of the original data
	public void setup(Context context) throws IOException{
		Path[] caches=DistributedCache.getLocalCacheFiles(context.getConfiguration());
		if(caches==null||caches.length<=0){
			log.error("center file does not exist");
			System.exit(1);
		}
		BufferedReader br=new BufferedReader(new FileReader(caches[0].toString()));
		String line;
		while((line=br.readLine())!=null){
			String[] str=line.split("\t");
			dimension=str.length;
			break;
		}
		try {
			br.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public void reduce(IntWritable key,Iterable<DataPro> values,Context context)throws InterruptedException, IOException{
	
		double[] sum=new double[dimension];
		int sumCount=0;
		for(DataPro val:values){
			String[] datastr=val.getCenter().toString().split("\t");
		//	String[] datastr=val.getCenter().toString().split("\\s+");
			sumCount+=val.getCount().get();
			for(int i=0;i<dimension;i++){
				sum[i]+=Double.parseDouble(datastr[i]);
			}
		}
		//  calculate the new centers
//		double[] newcenter=new double[dimension];
		StringBuffer sb=new StringBuffer();
		for(int i=0;i<dimension;i++){
			sb.append(sum[i]/sumCount+"\t");
		//	sb.append(sum[i]/sumCount+"\\s+");
		}
		context.write(null, new Text(sb.toString()));
	}
}

LastMapper: 
package org.fansy.date928;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class KmeansLastM extends Mapper<LongWritable,Text,IntWritable,Text>{
	private static Log log=LogFactory.getLog(KmeansLastM.class);
	
	private double[][] centers;
	private int dimention_m;  //  this is the k 
	private int dimention_n;   //  this is the features 

	
    static enum Counter{Fansy_Miss_Records};
	@Override
	public void setup(Context context) throws IOException,InterruptedException{
		Path[] caches=DistributedCache.getLocalCacheFiles(context.getConfiguration());
		if(caches==null||caches.length<=0){
			log.error("center file does not exist");
			System.exit(1);
		}
		@SuppressWarnings("resource")
		BufferedReader br=new BufferedReader(new FileReader(caches[0].toString()));
		String line;
		List<ArrayList<Double>> temp_centers=new ArrayList<ArrayList<Double>>();
		ArrayList<Double> center=null;
		//  get the file data
		while((line=br.readLine())!=null){
			center=new ArrayList<Double>();
			String[] str=line.split("\t");
			for(int i=0;i<str.length;i++){
				center.add(Double.parseDouble(str[i]));
			}
			temp_centers.add(center);
		}
		//  fill the centers 
		@SuppressWarnings("unchecked")
		ArrayList<Double>[] newcenters=temp_centers.toArray(new ArrayList[]{});
		 dimention_m=temp_centers.size();
		 dimention_n=newcenters[0].size();
		centers=new double[dimention_m][dimention_n];
		for(int i=0;i<dimention_m;i++){
			Double[] temp_double=newcenters[i].toArray(new Double[]{});
			for(int j=0;j<dimention_n;j++){
				centers[i][j]=temp_double[j];
		//		System.out.print(temp_double[j]+",");
			}
	//		System.out.println();
		}
	}
		
		
	public void map(LongWritable key,Text value,Context context)throws IOException,InterruptedException{
		String[] values=value.toString().split("\t");
	//	String[] values=value.toString().split("\\s+");
		if(values.length!=dimention_n){
			context.getCounter(Counter.Fansy_Miss_Records).increment(1);
			return;
		}
		double[] temp_double=new double[values.length];
		for(int i=0;i<values.length;i++){
			temp_double[i]=Double.parseDouble(values[i]);
		}
		//  set the index
		double distance=Double.MAX_VALUE;
		double temp_distance=0.0;
		int index=0;
		for(int i=0;i<dimention_m;i++){
			double[] temp_center=centers[i];
			temp_distance=getEnumDistance(temp_double,temp_center);
			if(temp_distance<distance){
				 index=i;
				distance=temp_distance;
			}
		}
		context.write(new IntWritable(index), value);
		
	}
	public static double getEnumDistance(double[] source,double[] other){  //  get the distance
		double distance=0.0;
		if(source.length!=other.length){
			return Double.MAX_VALUE;
		}
		for(int i=0;i<source.length;i++){
			distance+=(source[i]-other[i])*(source[i]-other[i]);
		}
		distance=Math.sqrt(distance);
		return distance;
	}
}

LastReducer: 
package org.fansy.date928;

import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class KmeansLastR extends Reducer<IntWritable,Text,IntWritable,Text> {
	
	public void reduce(IntWritable key,Iterable<Text> values,Context context)throws InterruptedException, IOException{

		//  output the data directly
		for(Text val:values){
			context.write(key, val);
		}
		
	}
}

上面就是全部的代码了，下面贴出结果： 
0	0.0	0.2	0.4
1	0.3	0.2	0.4
1	0.4	0.2	0.4
1	0.5	0.2	0.4
2	5.0	5.2	5.4
2	6.0	5.2	6.4
2	4.0	5.2	4.4
2	10.3	10.4	10.5
2	10.3	10.4	10.5
2	10.3	10.4	10.5

由最终的结果可以看出分类的结果不是很好，所以说初始的数据中心点一定要选好才行。

下面说下我遇到的问题，刚开始的时候我获取数据维度的方法不是使用读入文件然后再取得相应的信息，而是按照下面的方法：

WrongCombine:

package org.fansy.date927;

import java.io.IOException;
import java.util.Iterator;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class KmeansC extends Reducer<IntWritable,DataPro,IntWritable,DataPro> {
	
	public void reduce(IntWritable key,Iterable<DataPro> values,Context context)throws InterruptedException, IOException{
		// get dimension first
		Iterator<DataPro> iter=values.iterator();
		int dimension=0;
		for(DataPro val:values){
			String[] datastr=val.getCenter().toString().split("\t");
			dimension=datastr.length;
			break;
		}
		
		double[] sum=new double[dimension];
		int sumCount=0;
		//  operation one
		while(iter.hasNext()){
			DataPro val=iter.next();
			String[] datastr=val.getCenter().toString().split("\t");
			sumCount+=val.getCount().get();
			for(int i=0;i<dimension;i++){
				sum[i]+=Double.parseDouble(datastr[i]);
			}
		}
		
		// operation two
		/*for(DataPro val:values){
			String[] datastr=val.getCenter().toString().split("\t");
			sumCount+=val.getCount().get();
			for(int i=0;i<dimension;i++){
				sum[i]+=Double.parseDouble(datastr[i]);
			}
		}*/
		//  calculate the new centers
//		double[] newcenter=new double[dimension];
		StringBuffer sb=new StringBuffer();
		for(int i=0;i<dimension;i++){
			sb.append(sum[i]+"\t");
		}
		System.out.println("combine text:"+sb.toString());
		System.out.println("combine sumCount:"+sumCount);
		DataPro newvalue=new DataPro();
		newvalue.set(new Text(sb.toString()), new IntWritable(sumCount));
		context.write(key, newvalue);
	}
}

从第16到20行是我获得数据维度的方法，但是虽然维度获得了，但是，后面的操作就出问题了，从我加入的调试提示信息可以看出是出了什么问题了： 
12/09/28 14:40:40 INFO mapred.Task:  Using ResourceCalculatorPlugin : org.apache.hadoop.util.LinuxResourceCalculatorPlugin@435e331b
12/09/28 14:40:40 INFO mapred.MapTask: io.sort.mb = 100
12/09/28 14:40:40 INFO mapred.MapTask: data buffer = 79691776/99614720
12/09/28 14:40:40 INFO mapred.MapTask: record buffer = 262144/327680
0.0,0.0,0.0,
5.0,5.0,5.0,
10.0,10.0,10.0,
the map out:0,0.0	0.2	0.4
the map out:0,0.3	0.2	0.4
the map out:0,0.4	0.2	0.4
the map out:0,0.5	0.2	0.4
the map out:1,5.0	5.2	5.4
the map out:1,6.0	5.2	6.4
the map out:1,4.0	5.2	4.4
the map out:2,10.3	10.4	10.5
the map out:2,10.3	10.4	10.5
the map out:2,10.3	10.4	10.5
12/09/28 14:40:40 INFO mapred.MapTask: Starting flush of map output
combine text:1.2	0.6000000000000001	1.2000000000000002	
combine sumCount:3
combine text:10.0	10.4	10.8	
combine sumCount:2
combine text:20.6	20.8	21.0	
combine sumCount:2
12/09/28 14:40:40 INFO mapred.MapTask: Finished spill 0
12/09/28 14:40:40 INFO mapred.Task: Task:attempt_local_0001_m_000000_0 is done. And is in the process of commiting

有上面的信息可以看出首先map操作没有问题，但是combine操作时计算相同的index的个数不对，每个都少了1个，而且计算的总和也不对，所以我这样猜想，是不是通过这样的操作： 
for(DataPro val:values){
			String[] datastr=val.getCenter().toString().split("\t");
			dimension=datastr.length;
			break;
		}
可能改变了values的指针或者其他的什么东西之类的，导致后面我再使用这样的操作读取的时候就会从第二个开始读了。这个就不知到了。





分享，快乐，成长



iteye_4515
关注
Hadoop实现K_means聚类算法（对NBA球队进行聚类分析）
Blssel的博客
07-13 6021
利用Hadoop完成对NBA 30支球队球风的聚类本程序完成了Hadoop下，利用MapReduce思想实现K_means聚类算法。
hadoop k-means算法实现（可直接命令行运行）
05-10
hadoop k-means算法实现java工程的打包类，可直接在terminal中运行，运行命令为： $HADOOP_HOME/bin/hadoop jar ClusterDemo.jar main.Cluster 然后直接确定就可以看到提示的运行参数或者参考下面： +" \n" +"\t:输入文件路径\n" +"\t:输出文件路径\n" +"\t:初始中心路径\n" +"\t:临时输出文件路径\n" +"\t:循环最大次数\n" +"\t:聚类中心变化阈值\n" +"\t:聚类中心数目\n" +"\t:原始数据属性数目\n" +"\t:reduce数目");
用Hadoop1.0.3实现KMeans算法
weixin_34075268的博客
08-12 275
从理论上来讲用MapReduce技术实现KMeans算法是很Natural的想法：在Mapper中逐个计算样本点离哪个中心最近，然后Emit(样本点所属的簇编号，样本点)；在Reducer中属于同一个质心的样本点在一个链表中，方便我们计算新的中心，然后Emit(质心编号，质心)。但是技术上的事并没有理论层面那么简单。 Mapper和Reducer都要用到K个中心（我习惯称之为质心），Mapper...
hadoop下的Kmeans算法实现
Marshall的专栏
06-15 1366
转自： hadoop下的Kmeans算法实现一 前一段时间，从配置hadoop到运行kmeans的mapreduce程序，着实让我纠结了几天，昨天终于把前面遇到的配置问题和程序运行问题搞定。Kmeans算法看起来很简单，但对于第一次接触mapreduce程序来说，还是有些挑战，还好基本都搞明白了。Kmeans算法是从网上下的在此分析一下过程。 Kmeans.java
hadoop k-means实现
05-10
hadoop实现k-means算法的java工程，具体过程参考http://blog.youkuaiyun.com/fansy1990/article/details/8028546这个，此工程和上面页面的思路稍有改动，大致思路一致；
hadoop-kmeans:使用 Hadoop 实现 K-Means 算法
07-14
Hadoop K-Means 使用 Hadoop 的 K-Means 算法实现。 该算法不执行任何初始质心的计算，必须给出这些。 用法 家庭输入集群数量输出增量最大 hadoop jar HadoopKMeans.jar com.jgalilee.hadoop.kmeans.driver.Driver \ input/kmeans.state \ input/points.txt \ input/clusters.txt \ 2 \ output/ \ 0.0 \ 5 home - 每次迭代都可以写入文件名迭代状态的路径。 input - 输入点数据的路径。 集群 - 输入集群数据的路径。 number - 向 Hadoop 作业建议的减速器数量。 output - 为迭代 n 写入输出的路径 - 即 output/n delta - 定义最后一个
Hadoop K-Means 算法实现详解与应用
将K-Means算法在Hadoop上实现，主要是利用Hadoop的MapReduce编程模型。在MapReduce模型中，首先将输入数据分割成若干份，进行map操作，然后通过reduce操作对map的结果进行汇总。在Hadoop-KMeans实现中，map阶段主要...
分布式K-means聚类算法研究与实现.pdf
08-09
在Hadoop平台上实现分布式K-means算法，首先要考虑的是数据的分片存储，即将大数据集分散存储到多个节点上。其次，算法的设计和实现策略也至关重要，包括中心点的选取、数据点与中心点的距离计算以及中心点的更新等...
Hadoop mapreduce 实现KMeans
01-28
Hadoop mapreduce 实现KMeans，可用
基于Hadoop的Kmeans算法实现
11-24
基于Hadoop的Kmeans算法实现：Kmeans算法是很典型的基于距离的聚类算法，采用距离作为相似性的评价指标。即认为两个对象的距离越近，其相似度就越大。该算法认为簇是由距离靠近的对象组成的，因此把得到紧凑且独立的簇作为最终目标。
Hadoop课程实验和报告——K-Means算法并行实现
06-30
Hadoop课程实验和报告——K-Means算法并行实现
K-Means算法的Hadoop实现
想作会飞的鱼的博客
07-09 8163
一、MapReduce实现K-Means算法的基本流程 1、Map每读取一条数据就与所有选定的中心做对比，求出该条记录对应的中心，然后以中心的ID为Key，该条数据为value将数据输出。 2，利用reduce的归并功能将相同的Key归并到一起（因为map把中心的ID作为key，所以在reduce端时数据已经按照各自的中心分好了组，这是MapReduce框架自动完成的），集中与该Key对应的数
KMeans聚类算法Hadoop实现
weixin_30341735的博客
04-17 242
Assistance.java 辅助类，功能详见注释 package KMeans; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FSDataInputStream; import org.apache.hadoop.fs.FSDataOutputStream; import org...
hadoop下kmeans算法实现四
lskyne的专栏
01-26 6535
KMapper.java import java.io.ByteArrayOutputStream; import java.io.IOException; import java.net.URI; import java.util.StringTokenizer; import org.apache.hadoop.conf.Configuration; import org.apache
Hadoop命令行运行KMeans（含源代码）
zhang2010kang的专栏
05-11 4887
这里源代码基本用的是tinycui的，tinycui的源代码下载地址是：http://download.youkuaiyun.com/detail/tinycui/4384750#comment。         为了运行上述的源代码，我主要参考的是Shizhixin的博客 《hadoop之测试KMeans(-):运行源码实例》，该博客地址是：http://blog.youkuaiyun.com/shizhixin/a
基于RHadoop的k-means聚类算法
Mr. Lee的专栏
05-17 515
library(rmr2) ## @knitr kmeans-signature kmeans.mr = function( P, num.clusters, num.iter, combine, in.memory.combine) { ## @knitr kmeans-dist.fun dist.fun = func
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值