Hadoop 实现协同过滤 (example in <Mahout in action> chapter 6) Part 2

最新推荐文章于 2020-05-26 17:24:04 发布
最新推荐文章于 2020-05-26 17:24:04 发布
阅读量113 收藏
点赞数
文章标签： 大数据 java 人工智能
这部分内容接Hadoop 实现协同过滤 (example in <Mahout in action> chapter 6) Part 1 的实现

<style type="text/css"> <!-- @page {margin:2cm} td p {margin-bottom:0cm} pre.cjk {font-family:"文泉驿微米黑",monospace} pre.ctl {font-family:"Lohit Hindi",monospace} p {margin-bottom:0.21cm} pre.cjk {font-family:"文泉驿微米黑",monospace} pre.ctl {font-family:"Lohit Hindi",monospace} p {margin-bottom:0.21cm} --> </style>

第四个MR： MR4的map不做任何事情； MR4 的reduce 输出就是把 MR(31)和 MR(32)的相同的 itemID整合一下而已(注意此处的输入为两个路径)：如下： 

101  {107:1.0,106:2.0,105:2.0,104:4.0,103:4.0,102:3.0,101:5.0} [5 1 4 2 3] [4.0 5.0 5.0 2.0 2.5]
...
WiKiDriver4.java: 

package org.fansy.date1012.mahoutinaction.chapter6.sourcecode;

import static org.fansy.date1012.mahoutinaction.chapter6.sourcecode.WiKiUtils.PATH;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.SequenceFileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.SequenceFileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
import org.apache.mahout.cf.taste.hadoop.item.VectorAndPrefsWritable;
import org.apache.mahout.cf.taste.hadoop.item.VectorOrPrefWritable;

public class WiKiDriver4 {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws InterruptedException 
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		// TODO Auto-generated method stub
		Configuration conf1 = new Configuration();
	    String[] otherArgs = new GenericOptionsParser(conf1, args).getRemainingArgs();      
	    if (otherArgs.length != 3) {
	      System.err.println("Usage: WiKiDriver4 <in1><in2> <out>");
	      System.exit(2);
	    }
	    Job job1 = new Job(conf1, "wiki  job four");
	    job1.setNumReduceTasks(1);
	    job1.setJarByClass(WiKiDriver4.class);
	    job1.setInputFormatClass(SequenceFileInputFormat.class);
	    job1.setMapperClass(WikiMapper4.class);
	    job1.setMapOutputKeyClass(IntWritable.class);
		job1.setMapOutputValueClass(VectorOrPrefWritable.class);	
	    job1.setReducerClass(WiKiReducer4.class);
	    job1.setOutputKeyClass(IntWritable.class);
	   job1.setOutputValueClass(VectorAndPrefsWritable.class);
	    job1.setOutputFormatClass(SequenceFileOutputFormat.class);
	    SequenceFileInputFormat.addInputPath(job1, new Path(PATH+otherArgs[0]));
	    SequenceFileInputFormat.addInputPath(job1, new Path(PATH+otherArgs[1]));
	    SequenceFileOutputFormat.setOutputPath(job1, new Path(PATH+otherArgs[2]));   
	    if(!job1.waitForCompletion(true)){
	    	System.exit(1); // run error then exit
	    }
	}
}
WiKiMapper4.java: 

package org.fansy.date1012.mahoutinaction.chapter6.sourcecode;

import java.io.IOException;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.mahout.cf.taste.hadoop.item.VectorOrPrefWritable;

public class WikiMapper4 extends Mapper<IntWritable ,VectorOrPrefWritable,IntWritable,VectorOrPrefWritable> {

	public void map(IntWritable key,VectorOrPrefWritable value,Context context) throws IOException, InterruptedException{
		context.write(key, value);
	}
}
WiKiReducer4.java: 

package org.fansy.date1012.mahoutinaction.chapter6.sourcecode;

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

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.mahout.cf.taste.hadoop.item.VectorAndPrefsWritable;
import org.apache.mahout.cf.taste.hadoop.item.VectorOrPrefWritable;
import org.apache.mahout.math.Vector;

public class WiKiReducer4 extends Reducer<IntWritable,VectorOrPrefWritable,IntWritable,VectorAndPrefsWritable> {
		public void reduce(IntWritable key, Iterable<VectorOrPrefWritable> values,Context context) throws IOException, InterruptedException{
			List<Long> userfs=new ArrayList<Long>();
			List<Float> prefs=new ArrayList<Float>();
			Vector v=null;
			for(VectorOrPrefWritable value:values){
				if(value.getVector()!=null){
					v=value.getVector();
				}else{
					userfs.add(value.getUserID());
					prefs.add(value.getValue());
				 }
			}
			context.write(key, new VectorAndPrefsWritable(v,userfs,prefs));
	//		System.out.println("key ,itemid:"+key.toString()+", information:"+v+","+userfs+","+prefs);
		} 
}
第五个MR：

<style type="text/css"> <!-- @page {margin:2cm} pre.cjk {font-family:"文泉驿微米黑",monospace} pre.ctl {font-family:"Lohit Hindi",monospace} p {margin-bottom:0.21cm} --> </style>

map:针对MR4的输出的每一行中的每一个用户，用这个用户的评分值(value)去乘以项目之间的相似度向量，比如针对第一条记录中的用户3，则有 
Vectorforuser3=[1.0 2.0 2.0 4.0 4.0 3.0 5.0]* 2.5  
则map的输出为 key : 3    value :  Vectorforuser3;
map的输出应该如下所示： 

alluserids:[5, 1, 4, 2, 3]
,userid:5,vector:{107:4.0,106:8.0,105:8.0,104:16.0,103:16.0,102:12.0,101:20.0}
,userid:1,vector:{107:5.0,106:10.0,105:10.0,104:20.0,103:20.0,102:15.0,101:25.0}
,userid:4,vector:{107:5.0,106:10.0,105:10.0,104:20.0,103:20.0,102:15.0,101:25.0}
,userid:2,vector:{107:2.0,106:4.0,105:4.0,104:8.0,103:8.0,102:6.0,101:10.0}
,userid:3,vector:{107:2.5,106:5.0,105:5.0,104:10.0,103:10.0,102:7.5,101:12.5}
。。。
<style type="text/css"> <!-- @page {margin:2cm} pre.cjk {font-family:"文泉驿微米黑",monospace} pre.ctl {font-family:"Lohit Hindi",monospace} p {margin-bottom:0.21cm} --> </style> 

Combine : 针对map的输出，把相同 key(即userID)的向量对应相加，得到的向量和即为该userID的对各个项目的评分；
combine的输出应该如下所示： 

userid:1,vecotr:{107:5.0,106:18.0,105:15.5,104:33.5,103:39.0,102:31.5,101:44.0}
userid:2,vecotr:{107:4.0,106:20.5,105:15.5,104:36.0,103:41.5,102:32.5,101:45.5}
。。。
<style type="text/css"> <!-- @page {margin:2cm} pre.cjk {font-family:"文泉驿微米黑",monospace} pre.ctl {font-family:"Lohit Hindi",monospace} p {margin-bottom:0.21cm} --> </style> 

Reduce:针对combine的输出，把用户已经评价过分的项目筛选掉，然后按照评分值的大小有大到小排序输出，即为用户推荐项目；
最后的输出为： 

1	[104:33.5,106:18.0,105:15.5,107:5.0]
2	[106:20.5,105:15.5,107:4.0]
3	[103:26.5,102:20.0,106:17.5]
4	[102:37.0,105:26.0,107:9.5]
5	[107:11.5]
WiKiDriver5.java: 

package org.fansy.date1012.mahoutinaction.chapter6.sourcecode;

import static org.fansy.date1012.mahoutinaction.chapter6.sourcecode.WiKiUtils.PATH;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.SequenceFileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
import org.apache.mahout.cf.taste.hadoop.RecommendedItemsWritable;
import org.apache.mahout.math.VarLongWritable;
import org.apache.mahout.math.VectorWritable;

public class WiKiDriver5 {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws InterruptedException 
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		// TODO Auto-generated method stub
		Configuration conf1 = new Configuration();
	    String[] otherArgs = new GenericOptionsParser(conf1, args).getRemainingArgs();      
	    if (otherArgs.length != 2) {
	      System.err.println("Usage: WiKiDriver5 <in> <out>");
	      System.exit(2);
	    }
	    Job job1 = new Job(conf1, "wiki  job five");
	    job1.setNumReduceTasks(1);
	    job1.setJarByClass(WiKiDriver5.class);
	    job1.setInputFormatClass(SequenceFileInputFormat.class);
	    job1.setMapperClass(WikiMapper5.class);
	    job1.setMapOutputKeyClass(VarLongWritable.class);
		job1.setMapOutputValueClass(VectorWritable.class);
		
		job1.setCombinerClass(WiKiCombiner5.class);
	    job1.setReducerClass(WiKiReducer5.class);
	    job1.setOutputKeyClass(VarLongWritable.class);
	    job1.setOutputValueClass(RecommendedItemsWritable.class);
	//   job1.setOutputFormatClass(SequenceFileOutputFormat.class);
	    SequenceFileInputFormat.addInputPath(job1, new Path(PATH+otherArgs[0]));

	    FileOutputFormat.setOutputPath(job1, new Path(PATH+otherArgs[1]));   
	    if(!job1.waitForCompletion(true)){
	    	System.exit(1); // run error then exit
	    }
	}
}
WiKiMapper5.java: 

package org.fansy.date1012.mahoutinaction.chapter6.sourcecode;

import java.io.IOException;
import java.util.List;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.mahout.cf.taste.hadoop.item.VectorAndPrefsWritable;
import org.apache.mahout.math.VarLongWritable;
import org.apache.mahout.math.Vector;
import org.apache.mahout.math.VectorWritable;

public class WikiMapper5 extends Mapper<IntWritable ,VectorAndPrefsWritable,VarLongWritable,VectorWritable>{
	
	public void map(IntWritable key,VectorAndPrefsWritable vectorAndPref,Context context) throws IOException, InterruptedException{
		Vector coo=vectorAndPref.getVector();
		List<Long> userIds=vectorAndPref.getUserIDs();
		List<Float> prefValues=vectorAndPref.getValues();
		//System.out.println("alluserids:"+userIds);
		for(int i=0;i<userIds.size();i++){
			long userID=userIds.get(i);
			float prefValue=prefValues.get(i);
			Vector par=coo.times(prefValue);
			context.write(new VarLongWritable(userID), new VectorWritable(par));
			//System.out.println(",userid:"+userID+",vector:"+par);  //  if the user id = 3 is the same as my paper then is right
		}
	//	System.out.println();	
	}
}
WiKiCombiner5.java: 

package org.fansy.date1012.mahoutinaction.chapter6.sourcecode;

import java.io.IOException;

import org.apache.hadoop.mapreduce.Reducer;
import org.apache.mahout.math.VarLongWritable;
import org.apache.mahout.math.Vector;
import org.apache.mahout.math.VectorWritable;

public class WiKiCombiner5 extends Reducer<VarLongWritable,VectorWritable,VarLongWritable,VectorWritable> {
		public void reduce(VarLongWritable key, Iterable<VectorWritable> values,Context context) throws IOException, InterruptedException{
			Vector partial=null;
			for(VectorWritable v:values){
				partial=partial==null?v.get():partial.plus(v.get());
			}
			context.write(key, new VectorWritable(partial));
			System.out.println("userid:"+key.toString()+",vecotr:"+partial);//   here also should be the same as my paper's result
		}
}
WiKiReducer5.java: 

package org.fansy.date1012.mahoutinaction.chapter6.sourcecode;

import static org.fansy.date1012.mahoutinaction.chapter6.sourcecode.WiKiUtils.*;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.SequenceFile;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.util.ReflectionUtils;
import org.apache.mahout.cf.taste.hadoop.RecommendedItemsWritable;
import org.apache.mahout.cf.taste.impl.common.FastMap;
import org.apache.mahout.cf.taste.impl.recommender.ByValueRecommendedItemComparator;
import org.apache.mahout.cf.taste.impl.recommender.GenericRecommendedItem;
import org.apache.mahout.cf.taste.recommender.RecommendedItem;
import org.apache.mahout.math.VarLongWritable;
import org.apache.mahout.math.Vector;
import org.apache.mahout.math.VectorWritable;

public class WiKiReducer5 extends Reducer<VarLongWritable,VectorWritable,VarLongWritable,RecommendedItemsWritable> {
	
	private int recommendationsPerUser=RECOMMENDATIONSPERUSER;
	private String path=JOB1OUTPATH;
	
	private static FastMap<Integer,String> map=new FastMap<Integer,String>();
	public void setup(Context context) throws IOException{
		Configuration conf=new Configuration();
		FileSystem fs=FileSystem.get(URI.create(path), conf);
		Path tempPath=new Path(path);
		SequenceFile.Reader reader=null;
		try {
			reader=new SequenceFile.Reader(fs, tempPath, conf);
			Writable key=(Writable)ReflectionUtils.newInstance(reader.getKeyClass(),conf);
			Writable value = (Writable) ReflectionUtils.newInstance(reader.getValueClass(), conf); 
		//	long position = reader.getPosition();  
			while (reader.next(key, value)) {  
				map.put(Integer.parseInt(key.toString()), value.toString());
		//	    System.out.println(key.toString()+","+value.toString());
			//    position = reader.getPosition(); // beginning of next record  
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}  
	}
	
	public void reduce(VarLongWritable key, Iterable<VectorWritable> values,Context context) throws IOException, InterruptedException{
		
			int userID=(int)key.get();
			Vector rev=null;
			for(VectorWritable vec:values){
				rev=rev==null? vec.get():rev.plus(vec.get());
			}
			Queue<RecommendedItem>topItems=new PriorityQueue<RecommendedItem>(
					recommendationsPerUser+1,
					Collections.reverseOrder(ByValueRecommendedItemComparator.getInstance())
					);
			Iterator<Vector.Element>recommendationVectorIterator=
					rev.iterateNonZero();
			while(recommendationVectorIterator.hasNext()){
				Vector.Element e=recommendationVectorIterator.next();
				int index=e.index();
				System.out.println("Vecotr.element.indxe:"+index);  //  test here  find the index is item id or not  ** test result : index is item
				if(!hasItem(userID,String.valueOf(index))){
					float value=(float) e.get();
					if(topItems.size()<recommendationsPerUser){
						//  here only set index
						topItems.add(new GenericRecommendedItem(index,value));
					}else if(value>topItems.peek().getValue()){
						topItems.add(new GenericRecommendedItem(index,value));
						topItems.poll();
					}
				}
			}
			List<RecommendedItem>recom=new ArrayList<RecommendedItem>(topItems.size());
			recom.addAll(topItems);
			Collections.sort(recom,ByValueRecommendedItemComparator.getInstance());
			context.write(key, new RecommendedItemsWritable(recom));		
		}
	
	public static boolean hasItem(int user,String item){  // to check whether the user has rate the item
		boolean flag=false;
		String items=map.get(user);
		if(items.contains(item)){
			flag=true;
		}
		return flag;
	}
}

最后一个reducer的编写也是费了一番功夫：基本思路：在Reducer的setup函数中读取SequenceFile的数据，这个数据是MR1的输出数据，用来排除用户已经评价过的项目。

其实在编写这些代码的时候 查了好多mahout的API，因为好多类都是在Mahout上面的，要了解它的用法才行，在最后一个Reducer中我也用了一个FastMap,这个类也是Mahout的，应该用他提供的一些类会运行的更加快吧。

最后说下算法吧：

在《Mahout in Action》中最初的算法是这样的：


用相似度矩阵点乘用户对项目的评价向量得到用户对项目的评分（其中的U3对对101项目的评分应该是2.5，我怀疑书上印错了）；

但用代码实现的时候书上建议这样做：

这样做可以提高效率。





分享，快乐，成长


iteye_12675
关注
Hadoop第一个程序wordcount命令运行jar包报错Usage: wordcount <in> <out>
qq_39306369的博客
05-09 8815
第一次使用命令运行jar包使用Hadoop，然后报错。网上百度了好多都是在eclipse里面的解决方案，我是着实头大。 环境 IDEA centos 7 hadoop 2.7.7 jdk1.8.0 报错 代码那些我就不贴了，网上很多。 先说一下，Hadoop1.x和Hadoop2.x的命令有所不同，Hadoop1.x命令是hadoop fs…，Hadoop2.x进入Hadoop目录，然后命令为bin/hdfs dfs …。 首先我是使用命令 hadoop jar word_count_class/wordC
Hadoop 实现协同过滤算法（1）
fansy1990的专栏
10-12 8471
最近一直在研究《Mahout in Action》，今天才算是把第一部分看完。在Chapter 6中有一个例子，是实现协同过滤进行推荐的例子，不过书上的是针对布尔值的输入数据，在mahout的安装目录里面也有这个算法的详细源码，但是毕竟是源码，读起来有点晦涩，所以就参考了书上的例子编写了（书上的例子思路比较清楚）不仅仅是布尔值的输入数据的代码； 下面就详细说下思路及代码： 输入数据： 第一列
大数据学习-Hadoop生态章---协同过滤算法
fg19941101的博客
01-08 314
协同过滤算法 参考： https://www.cnblogs.com/one--way/p/5648165.html (一)基于物品的协同过滤 基于物品的协同过滤算法ItemCF 基于item的协同过滤，通过用户对不同item的评分来评测item之间的相似性，基于item之间的相似性做出推荐。 简单来讲就是：给用户推荐和他之前喜欢的物品相似的物品。 用例说明： 注：基于物品的协同过滤算法，是目...
hadoop-2.4.0（part3【final】）
05-06
hadoop最新版，权限不足，分三部分上传
Hadoop 实现协同过滤 (example in <Mahout in action> chapter 6) Part 1
云计算?
10-12 217
最近一直在研究《Mahout in Action》，今天才算是把第一部分看完。在Chapter 6中有一个例子，是实现协同过滤进行推荐的例子，不过书上的是针对布尔值的输入数据，在mahout的安装目录里面也有这个算法的详细源码，但是毕竟是源码，读起来有点晦涩，所以就参考了书上的例子编写了（书上的例子思路比较清楚）不仅仅是布尔值的输入数据的代码； 下面就详细说下思路及代码： 输入数据： 第一列...
Hadoop实现协同过滤算法
u013939918的博客
03-10 759
Step1 /**  *第一步去重  * @author Administrator  *  */ public class Step1 { static class Step1_Mapper extends Mapper{ protected void map(LongWritable key, Text value, Context context) throws
使用hadoop dfsadmin -report命令查看集群运行,结果全为0，解决方法
wangxizhen123的博客
06-14 1万+
使用hadoop dfsadmin -report命令查看集群运行,结果全为0结果如下： [hadoop@mini1 hadoop-2.4.1]$ hadoop dfsadmin -report DEPRECATED: Use of this script to execute hdfs command is deprecated. Instead use the hdfs command fo
基于Mahout分布式协同过滤推荐算法分析与实现.pdf
08-09
为了解决这一问题，Apache Mahout在Hadoop平台上实现了基于项目的分布式协同过滤推荐算法。Mahout是一个开源的机器学习框架，它利用Hadoop强大的存储和计算能力，将协同过滤推荐算法向分布式方向进行了扩展。该算法...
Mahout协同过滤
爱偷吃香蕉的萌猴子
01-20 5624
Mahout协同过滤1.Mahout是什么Mahout是一个算法库，集成了很多算法 Apache Mahout是Apache Software Foundation(ASF)旗下的一个开源项目，提供一些可拓展的机器学习领域经典算法的实现， 旨在帮助开发人员更加方便快捷地创建智能应用程序 Mahout项目目前已经有了多个公共发行版本。Mahout包含许多实现，包括聚类、分类、推荐过滤、频繁子项目挖掘
hadoop的Context简单使用
鲍礼彬的CSDN博客 ~_~
03-29 5918
hadoop的Context简单使用 作业输入： hadoop@hadoop:/home/hadoop/blb$ hdfs dfs -text /user/hadoop/libin/input/inputpath1.txt hadoop a spark a hive a hbase a tachyon a storm a redis a hadoop@hadoo
hadoop中 hadoop fs -getmerge 命令合并多个文件
热门推荐
chenyuangege的专栏
06-18 2万+
hadoop中 hadoop fs -getmerge 命令合并多个文件
hadoop中带后缀的多路输出part文件
panhongan的专栏
10-03 2701
package com.cmcm.hadoop.mapred.lib; import org.apache.hadoop.mapred.lib.MultipleTextOutputFormat; import org.apache.hadoop.io.Text; public class SuffixMultipleTextOutputFormat extends MultipleTextOu
Hadoop源代码分析(完整图文版) part 1
集成显卡的开源主页 https://github.com/0604hx
11-26 1万+
Hadoop源代码分析（一） 关键字: 分布式 云计算  Google的核心竞争技术是它的计算平台。Google的大牛们用了下面5篇文章，介绍了它们的计算设施。  GoogleCluster： http://research.google.com/archive/googlecluster.html  Chubby：http://labs.google.com/papers/chubb
hadoop pipes
nuoline的专栏
02-25 659
Introduction     Using Package org.apache.hadoop.mapred.pipes,Hadoop Pipes allows C++ code to use Hadoop DFS and map/reduce. Hadoop Pipes use Writable serialization to convert the types into bytes th
协同过滤算法(基于用户)
sxsAffable的博客
05-26 2465
协同过滤算法1. 流程图2. 算法详细步骤 背景: 使用基于用户的协同过滤算法进行网站预测 1. 流程图 2. 算法详细步骤 读取文件，处理每一行数据，把用户id和网址id转化为long类型(因为协同过滤模型这两列为long类)，并转化为DataModel(模型输入数据)。 转化出用户评分矩阵(没有的填充0)。如下表所示(部分)： 用户id\网址id 1 10 100 101 102 103 104 105 106 0 1 4 0 1 0 0 1 4 3 1 0 3
hadoop fs -getmerge命令的使用
qiezikuaichuan的专栏
05-10 2万+
假设在你的hdfs集群上有一个/user/hadoop/output目录 里面有作业执行的结果（多个文件组成）part-000000,part-000001,part-000002 然后你想把所有的文件合拢来一起看 可以使用命令：hadoop fs -getmerge /user/hadoop/output local_file 然后就可以在本地使用vi loca
day12-spark RDD
shenjinrui的博客
01-02 141
day11，我们学习了Spark HA模式、Spark submit及spark shell的演示。今天学习Spark RDD。
Hadoop编程作业part1，利用MapReduce计算
weixin_40641725的博客
04-14 475
Map是将输入的一个key-value记录<ik.iv>输出为多个key-value记录<mk,mv>，Reduce函数则是输入一个mk和与之对应的mv，输出为多个key-value记录<ok,ov>，在示例中，老师给了一个WordCount的例子，网上有一篇博客记录的特别好，如下 在这个例子的基础上进行修改，完成如下的目标任务。思路就是 直接map + re...
Hadoop实现协同过滤的商品推荐系统源码及文档
资源摘要信息: "基于协同过滤算法使用hadoop实现商品推荐系统+源代码+文档说明" 该资源为一个完整的商品推荐系统项目，它利用了大数据处理框架Hadoop和协同过滤算法来实现。项目源码经过作者的测试和验证，能够成功...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值