基于mapreduce 的 minHash 矩阵压缩

最新推荐文章于 2024-08-28 14:53:34 发布
最新推荐文章于 2024-08-28 14:53:34 发布
阅读量1.4k 收藏 1
点赞数 1
分类专栏： Mahout 文章标签： mapreduce 压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SZU_Hadooper/article/details/53312476
版权

Minhash作用：

   对大矩阵进行降维处理，在进行计算俩个用户之间的相似度。

比如：

   俩个用户手机下载的APP的相似度，在一个矩阵中会有很多很多的用户要比较没俩个用户之间的相似度是一个很大的计算任务

   如果首先对这个矩阵降维处理，会减少很大的计算量，并且将矩阵放到mapreduce中进行分布式计算，会大大缩短计算时间。

   使用minhash降维处理原理：

   将矩阵的行随机打乱,假设下面已经是第一次打乱的结果，从上往下取第一个为1的行,比如 u1 H(switch1)=0/a1,u2第一行是0不取，u2的第二行是1取了，H(switch1)=1/a2,

u3 H(switch1)=0/a1, u4 H(switch1)=1/a2.

得到一个新矩阵：

                        u1               u2               u3                u4                                        

H(switch1)      0/a1           1/a2             0/a1             1/a2

如果随机打乱N次会生成一个N行的矩阵，缩小了原矩阵的行数，然后计算新矩阵的JACCARD相似度。

    

这样看上去简单，但是打乱一个大的矩阵是一个很大的开销，所以我们用一组随机的minhash函数来代替一组随机的的打乱过程。


minhash 是取最小的哈希值，计算过程：

  比如h1根据行号产生的哈希值是1230，u1的第一行是1所以可以取到1，u2是0就不行，u2第二行是1，只能取到2, u3的第一行是1，可以取到1，同样u4是0，只能找第一个为1对应的行的哈希值。@为无穷大，一步步的更新。取最小，小的不更新大的更新。

          u1           u2                u3             u4

h1      1             @                @               1

h2      1             @                @               1


          u1           u2                u3             u4

h1      1             2                   2               1

h2      1             3                   3               1


          u1           u2                u3             u4

h1      1             2                   2               1

h2      1             1                   1               1


          u1           u2                u3             u4

h1      0             0                   2               1

h2      1             1                   1               1


这就是最后的结果然后再算JACCARD相似度

u2,u3相同的行有1行/哈希函数的个数（矩阵的行数）

jaccard=相同的行数/矩阵的函数=相同的行数/hash函数的个数。


在Mapreduce中的实现：

数据类似：



第一个mapreduce:

压缩矩阵

生成用户对

package code;
import hashfunctions.HashFactory;
import hashfunctions.HashFactory.HashType;
import hashfunctions.HashFunction;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import utils.ConfigUtils;
import utils.ErrorLevel;

import utils.Loger;
public class redstone1Step1
{

  public static class maphadoop1 extends Mapper<Object, Text, Text, Text>
  {
	  private HashFunction[] hashFunction; //hash函数数组
	  private int numHashFunctions;        //hash函数个数
	  private HashType hashType;
	  private long[] minHashValues;        //最小hash值
	  private byte[] bytesToHash;

	  protected void setup(Context context)throws IOException, InterruptedException
	  {
		  Configuration conf = context.getConfiguration();
		  this.numHashFunctions = (int)ConfigUtils.getValue(conf, "numHashFuctions", 15);
		  this.minHashValues = new long[this.numHashFunctions];
		  this.bytesToHash = new byte[4];
		  String htype = ConfigUtils.getValue(conf, "HashType", "MURMUR");
		  System.out.println("numHashFunctions1111:" + numHashFunctions);
		  System.out.println("htype:" + htype);
		  try {
			  hashType = HashType.valueOf(htype);
		  } catch (IllegalArgumentException uae) {
			  Loger.logOnScreen(ErrorLevel.ERROR, "No valid hash type found in configuration!");
			  hashType = HashFactory.HashType.valueOf("LINEAR");
		  }
		  hashFunction = HashFactory.createHashFunctions(hashType, numHashFunctions);

		  super.setup(context);
	  }

	  public void map(Object key, Text value, Context context) throws IOException, InterruptedException
	  {
		  List<Long> ls = new ArrayList<Long>();
		  String[] inputTokens = value.toString().split(" ");
		  String nodeId = inputTokens[0];     //用户ID
		  Text outputValue = new Text(nodeId);

		  for (int i = 1; i < inputTokens.length; ++i) {
			  ls.add(Long.parseLong(inputTokens[i].trim()));
		  } //app的ID列表

		  int length = ls.size();
		  for (int j = 0; j < numHashFunctions; ++j) {
			  this.minHashValues[j] = Integer.MAX_VALUE;
		  } //初始化hash函数值

		  for (int i = 0; i < this.numHashFunctions; ++i) {
			  for (int j = 0; j < length; ++j) {
				  long val = ls.get(j);
				  bytesToHash[0] = (byte)(val >> 24);
				  bytesToHash[1] = (byte)(val >> 16);
				  bytesToHash[2] = (byte)(val >> 8);
				  bytesToHash[3] = (byte)val;//转换成字节，每次移出去8位，剩下位组成的数的结果，如果是负数（最高位是1）则取补码加一的方式计算
				  int hashIndex = hashFunction[i].hash(bytesToHash);

				  if (minHashValues[i] > hashIndex) {
					  minHashValues[i] = hashIndex;
				  }
			  }
		  }

		  for (int i = 0; i < numHashFunctions; ++i) {
			  String iMinHashValue = String.valueOf(i) + "_" + this.minHashValues[i];
			  Text outputKey = new Text(iMinHashValue);
			  context.write(outputKey, outputValue); //（0_最小hash值 ，user）
		  }
	  }
  	}

  	public static class reducehadoop1 extends Reducer<Text, Text, Text, Text>
  	{
  		public void reduce(Text key, Iterable<Text> values, Context context)throws IOException, InterruptedException
  		{
  			ArrayList<String>list= new ArrayList<String>();
  			Iterator<Text> itr = values.iterator();

  			while (itr.hasNext()) {
  				list.add(itr.next().toString());
  			}

  			Collections.sort(list);//为了避免一条边表示俩次<u1,u2>,<u2,u1>
  			if (list.size() >= 2){
  				for (int i = 0; i < list.size() - 1; ++i){
  					for (int j = i + 1; j < list.size(); ++j){
  						context.write(new Text(list.get(i)), new Text(list.get(j))); //生成相同 key=哈希函数_最小哈希值 的用户组成的用户对
  					}
  				}
  			}
  		}
  	}
  
  	public static void main(String[] args)throws Exception
  	{
  		Configuration conf = new Configuration();
  		Job job = Job.getInstance(conf, "redstone1Step1");
  		job.setJarByClass(redstone1Step1.class);
  		job.setNumReduceTasks(25);
  		
  		FileInputFormat.addInputPath(job, new Path(args[0]));
  		FileOutputFormat.setOutputPath(job, new Path(args[1]));

  		job.setMapperClass(maphadoop1.class);
  		job.setReducerClass(reducehadoop1.class);
  		job.setOutputFormatClass(TextOutputFormat.class);
  		job.setOutputKeyClass(Text.class);
  		job.setOutputValueClass(Text.class);

  		job.waitForCompletion(true);
  	}
}


第二个mapreduce:

将用户对加

生成jaccard距离=相同用户对的个数/函数个数


package code;
import org.apache.hadoop.io.FloatWritable;
import org.apache.hadoop.io.IntWritable;
import java.io.IOException;
import java.util.Iterator;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import utils.ConfigUtils;
public class redstone1Step2
{
  
	public static class maphadoop2 extends Mapper<Object, Text, Text, IntWritable>
	{
	    public void map(Object key, Text value,Context context)throws IOException, InterruptedException
	    {
	      IntWritable one = new IntWritable(1);
	      String[] str = value.toString().split("\t");

	      context.write(new Text(str[0] + ":" + str[1]), one);
	    }
	}
	

	public static class combinerhadoop2 extends Reducer<Text, IntWritable, Text, IntWritable>
	{
		protected void reduce(Text key, Iterable<IntWritable> values,Context context)throws IOException, InterruptedException
		{
			Iterator<IntWritable> itr = values.iterator();
			int partCount = 0;
			while (itr.hasNext()) {
				String str = itr.next().toString();
				partCount += Integer.parseInt(str);
			}
			context.write(key, new IntWritable(partCount));
		}
	}

  

	public static class reducehadoop2 extends Reducer<Text, IntWritable, FloatWritable, Text>
	{
		private int numHashFunctions;
		private float edgeThreshold;

		protected void setup(Context context)throws IOException, InterruptedException
		{
			Configuration conf = context.getConfiguration();
			this.numHashFunctions = (int)ConfigUtils.getValue(conf, "numHashFuctions", 15);
			this.edgeThreshold = (float)ConfigUtils.getValue(conf, "gp.threshold", 0.7D);
			super.setup(context);
		}

		public void reduce(Text key, Iterable<IntWritable> values,Context context) throws IOException, InterruptedException {
			String[] tokens = key.toString().split(":");
			String value = tokens[0] + "\t" + tokens[1];
			Text outputValue = new Text(value);

			Iterator<IntWritable> itr = values.iterator();
			int count = 0;
			while (itr.hasNext()) {
				String str = itr.next().toString();
				count += Integer.parseInt(str);
			}
			float jaccard = (float)count / numHashFunctions;
			if (jaccard >= edgeThreshold)
				context.write(new FloatWritable(1.0F - jaccard), outputValue);
		}
	}
  
	  	public static void main(String[] args)throws Exception
		{
			Configuration conf = new Configuration();
			Job job = Job.getInstance(conf, "redstone1Step2");
			job.setJarByClass(redstone1Step2.class);
			job.setNumReduceTasks(25);
			FileInputFormat.addInputPath(job, new Path(args[0]));
			FileOutputFormat.setOutputPath(job, new Path(args[1]));
	
			job.setMapperClass(maphadoop2.class);
			job.setReducerClass(reducehadoop2.class);
			job.setCombinerClass(combinerhadoop2.class);
	
			job.setOutputFormatClass(TextOutputFormat.class);
			job.setOutputKeyClass(Text.class);
			job.setOutputValueClass(IntWritable.class);
	
			job.waitForCompletion(true);
		}
}



以上是根据mahout的minhash。

第一个mapreduce中生成用户对可以进行改进。








    


SZU_Hadooper
关注
专栏目录
哈希函数、Map-Reduce与Hadoop
开贰锤
11-09 1013
哈希函数 哈希函数又叫散列函数，哈希函数的输入域可以是非常大的范围，比如任意字符串，但是输出域是固定范围，假设为s。 哈希函数的性质： 1. 典型的哈希函数都拥有无限的输入值域。 2. 输入值相同时，返回值相同，通常将返回值称为哈希值。 3. 输入值不同时，返回值可能相同，也可能不同。 4. 不同输入值得到的哈希值，整体均匀的分布在输出域s上。（重要） 性质1,2,3是哈希函数的基础...
MapReduce 编程 系列十 使用HashPartitioner来调节Reducer的计算负载
Dean Chen的专栏
10-03 5176
example4演示了如何指定Reducer的数量，本节演示如何使用HashPartitioner将Mapper的输出按照key进行分组后交给Reducer来处理。合理的分组策略将使得每个Reducer获得的计算负载差距不大，从而整体reduce的性能更加均衡。Reducer的数量由HashPartitioner函数getPartition返回值来确定。public int getPartitio
Hadoop MapReduce中的压缩
lavimer
01-13 2073
作为输入 当压缩文件作为MapReduce的输入时，MapReduce将自动通过扩展名找到相应的codec对其进行解压。 作为输出 当MapReduce的输出文件需要压缩时，可以更改mapred.output.compress为true，mapred.output.compression.codec为想要使用的codec的类名就可以了，当然你可以再代码中指定，通过调用FileOutputFo
【文本去重】通俗易懂理解Minhash算法
最新发布
a61022706的博客
08-28 1125
minhash算法直观理解
Hadoop MapReduce 数据压缩
lesileqin的博客
04-21 381
文章目录一、数据压缩概述二、MapReduce支持的压缩编码1、压缩算法对比介绍2、压缩性能对比三、压缩方式的选择四、压缩位置选择五、压缩参数配置六、压缩案例实操1、Map端采用压缩2、Reduce端采用压缩 一、数据压缩概述 压缩的好处和坏处： 压缩的优点：减少磁盘IO、减少磁盘存储空间 压缩的缺点：增加CPU开销 压缩原则： 运算密集型的Job，少用压缩 IO密集型的Job，多用压缩 二、MapReduce支持的压缩编码 1、压缩算法对比介绍 2、压缩性能对比 还有一个压缩算法Snappy
MapReduce 默认分区HashPartitioner
gjf362的博客
07-05 2212
简析mapreduce 默认的分区方式 以下就是Hadoop MapReduce中对于默认分区的源码
基于MapReduce的矩阵相乘算法代码及其使用
04-22
### 基于MapReduce的矩阵相乘算法详解 #### 一、背景介绍 在大数据处理领域，MapReduce 是一种非常流行的编程模型，用于并行处理海量数据集。该模型由 Google 首次提出，并被广泛应用于搜索引擎、推荐系统等场景。...
基于Hadoop MapReduce的矩阵乘法
12-28
1、资源内容：基于Hadoop MapReduce的矩阵乘法 2、代码特点：内含运行结果，不会运行可私信，参数化编程、参数可方便更改、代码编程思路清晰、注释明细，都经过测试运行成功，功能ok的情况下才上传的。 3、适用对象...
基于MapReduce+Pandas的电影排名与推荐以及数据分析与可视化展示
04-25
基于MapReduce+Pandas的电影排名与推荐以及数据分析与可视化展示 数据科学与大数据技术领域中，电影排名与推荐系统的开发是非常重要的一部分。该系统可以通过对电影数据的分析和处理，提供电影排名和推荐服务，满足...
基于哈希技术和MapReduce的大数据集K-近邻算法实现代码
04-11
基于哈希技术和MapReduce的大数据集K-近邻算法实现的完整代码
MapReduce详解
m0_58290966的博客
03-28 3970
import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.*; import java.net.URI; public class HDFSapp { //指定默认的HDFS路径 String hdfsURL = "hdfs://localhost:9000"; FileSystem fs = null; Configuration configuration= null; ...
Mapreduce算法二、数据去重（HashSet）
qq_36273293的博客
10-24 546
Mapreduce算法二、数据去重（HashSet）
MapReduce原理解析
code__online的博客
05-15 746
划分方法-最基本的海量技术思想 传统Hash，最基本的划分方法 将大数据、流量均分到N台服务器，找到合理的key，hash(key)尽量分布均匀，如hash(key) mod N == 0则将其分到第0台服务器 随机划分 一致性Hash：支持动态增长，更高级的划分方法 一致性hash：考虑到分布式系统每个节点都有可能失效，并且新的节点很可能动态的增加进来，如何保证当系...
挑战408——数据结构（24）——图的存储与矩阵压缩
redAnt的博客
11-17 2861
图的存储方式 在实践中，存储图最常见的策略是： 将每个节点的连接存储在邻接列表中。 将整个图形的连接存储在邻接矩阵中。 用邻接链表来表示图之间的关系 在图中表示连接的最简单方法是在每个节点的数据结构中存储与其连接的节点的列表。该结构称为邻接列表。 例如，在航空公司图表中 每一个节点连接的相邻节点构成一个邻接表，就像这样： 现在我们来讲将上图的内容抽象化： 假设我们现在有个有向图： 根据定...
总结：详细讲解MapReduce过程(整理补充)
热门推荐
MrLevo520的博客
08-06 2万+
关于整理 此文百分之七十摘自我认为讲的很清楚的博客，我都贴了地址，很感谢这些博主的无私奉献！我再将一些自己的实例代码和知识点的补充加入进去，希望能更好的理解mapreduce的整个过程。 从启动和资源调度来看MapReduce过程首先-先了解一下必知概念 From：MapReduce工作原理图文详解，JobTracker和TaskTracker概述客户端（Client）：编写mapreduc
【机器学习】minHash最小哈希原理及其应用
sxl的博客
01-03 8056
在数据结构中学过哈希概念以及哈希在内存中的应用，在实际的应用问题中哈希技术也应用十分广泛如在推荐系统以及图神经网络技术中，所以在此总结一下哈希的相关概念以及minHash以及其实际应用，其中多有参考别的文献内容，相关参考一并列在参考文献中。Hash（哈希），又称“散列”。散列（hash）英文原意是“混杂”、“拼凑”、“重新表述”的意思。
相似项发现-minhash
小小八卦姐的专栏
08-10 2639
相似项发现中两个重要算法： Broder提出的shingling算法和Charikar的simhash算法 shingle算法的核心思想是为每个文件提取组特征值，以特征值集合来计算相似性，从而降低空间和计算复杂性来提高性能。 相似项数据检测算法大致流程如下： （1）将数据段分解成一组shingle（即子序列或数据块），可以采用定长、变长、单词或段落（文本文件）等分块算法； （2）
MapReduce实现矩阵相乘：MMMapper代码详解
在这个基于MapReduce的矩阵相乘算法中，我们首先关注的是`MMMapper`类，它是Hadoop MapReduce框架中的核心组件之一，用于处理分布式计算任务。该类实现了`Mapper`接口，其主要功能是将输入数据分割并转换为中间键值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值