用Hadoop構建電影推薦系統
1. 推薦系統概述
電子商務網站是個性化推薦系統重要地應用的領域之一，亞馬遜就是個性化推薦系統的積極應用者和推廣者，亞馬遜的推薦系統深入到網站的各類商品，為亞馬遜帶來了至少30%的銷售額。
不光是電商類，推薦系統無處不在。QQ，人人網的好友推薦；新浪微博的你可能感覺興趣的人；優酷，土豆的電影推薦；豆瓣的圖書推薦；大從點評的餐飲推薦；世紀佳緣的相親推薦；天際網的職業推薦等。
推薦演算法分類：
按資料使用劃分：
- 協同過濾演算法：UserCF, ItemCF, ModelCF
- 基於內容的推薦: 使用者內容屬性和物品內容屬性
- 社會化過濾：基於使用者的社會網路關係
按模型劃分：
- 最近鄰模型:基於距離的協同過濾演算法
- Latent Factor Mode(SVD)：基於矩陣分解的模型
- Graph：圖模型，社會網路圖模型
基於使用者的協同過濾演算法UserCF
基於使用者的協同過濾，透過不同使用者對物品的評分來評測使用者之間的相似性，基於使用者之間的相似性做出推薦。簡單來講就是：給使用者推薦和他興趣相似的其他使用者喜歡的物品。
用例說明：
基於使用者的 CF 的基本思想相當簡單，基於使用者對物品的偏好找到相鄰鄰居使用者，然後將鄰居使用者喜歡的推薦給當前使用者。計算上，就是將一個使用者對所有物品的偏好作為一個向量 來計算使用者之間的相似度，找到 K 鄰居後，根據鄰居的相似度權重以及他們對物品的偏好，預測當前使用者沒有偏好的未涉及物品，計算得到一個排序的物品列表作為推薦。圖 2 給出了一個例子，對於使用者 A，根據使用者的歷史偏好，這裡只計算得到一個鄰居 – 使用者 C，然後將使用者 C 喜歡的物品 D 推薦給使用者 A。
基於物品的協同過濾演算法ItemCF
基於item的協同過濾，透過使用者對不同item的評分來評測item之間的相似性，基於item之間的相似性做出推薦。簡單來講就是：給使用者推薦和他之前喜歡的物品相似的物品。
用例說明：
基於物品的 CF 的原理和基於使用者的 CF 類似，只是在計算鄰居時採用物品本身，而不是從使用者的角度，即基於使用者對物品的偏好找到相似的物品，然後根據使用者的歷史偏好，推薦相似的物品給他。從計算 的角度看，就是將所有使用者對某個物品的偏好作為一個向量來計算物品之間的相似度，得到物品的相似物品後，根據使用者歷史的偏好預測當前使用者還沒有表示偏好的 物品，計算得到一個排序的物品列表作為推薦。圖 3 給出了一個例子，對於物品 A，根據所有使用者的歷史偏好，喜歡物品 A 的使用者都喜歡物品 C，得出物品 A 和物品 C 比較相似，而使用者 C 喜歡物品 A，那麼可以推斷出使用者 C 可能也喜歡物品 C。
上文中圖片和對應圖片解釋，摘自：https://www.ibm.com/developerworks/cn/web/1103_zhaoct_recommstudy2/
注：基於物品的協同過濾演算法，是目前商用最廣泛的推薦演算法。
協同過濾演算法實現，分為2個步驟
- 1. 計算物品之間的相似度
- 2. 根據物品的相似度和使用者的歷史行為給使用者生成推薦列表
有關協同過濾的另一篇文章，請參考：RHadoop實踐系列之三 R實現MapReduce的協同過濾演算法
2. 需求分析：推薦系統指標設計
下面我們將從一個公司案例出發來全面的解釋，如何進行推薦系統指標設計。
案例介紹
Netflix電影推薦百萬獎金比賽，
Netflix官方網站：
Netflix，2006年組織比賽是的時候，是一家以線上電影租賃為生的公司。他們根據網友對電影的打分來判斷使用者有可能喜歡什麼電影，並結合會員看過的電影以及口味偏好設定做出判斷，混搭出各種電影風格的需求。
收集會員的一些資訊，為他們指定個性化的電影推薦後，有許多冷門電影竟然進入了候租榜單。從公司的電影資源成本方面考量，熱門電影的成本一般較高，如果Netflix公司能夠在電影租賃中增加冷門電影的比例，自然能夠提升自身盈利能力。
Netflix公司曾宣稱60%左右的會員根據推薦名單定製租賃順序，如果推薦系統不能準確地猜測會員喜歡的電影型別，容易造成多次租借冷門電影而 並不符合個人口味的會員流失。為了更高效地為會員推薦電影，Netflix一直致力於不斷改進和完善個性化推薦服務，在2006年推出百萬美元大獎，無論 是誰能最好地最佳化Netflix推薦演算法就可獲獎勵100萬美元。到2009年，獎金被一個7人開發小組奪得，Netflix隨後又立即推出第二個百萬美 金懸賞。這充分說明一套好的推薦演算法系統是多麼重要，同時又是多麼困難。
上圖為比賽的各支隊伍的排名！
補充說明：
- 1. Netflix的比賽是基於靜態資料的，就是給定“訓練級”，匹配“結果集”，“結果集”也是提前就做好的，所以這與我們每天運營的系統，其實是不一樣的。
- 2. Netflix用於比賽的資料集是小量的，整個全集才666MB，而實際的推薦系統都要基於大量歷史資料的，動不動就會上GB,TB等
Netflix資料下載
部分訓練集：
部分結果集：
完整資料集：
所以，我們在真實的環境中設計推薦的時候，要全面考量資料量，演算法效能，結果準確度等的指標。
- 推薦演算法選型：基於物品的協同過濾演算法ItemCF，並行實現
- 資料量：基於Hadoop架構，支援GB,TB,PB級資料量
- 演算法檢驗：可以透過 準確率，召回率，覆蓋率，流行度 等指標評判。
- 結果解讀：透過ItemCF的定義，合理給出結果解釋
3. 演算法模型：Hadoop並行演算法
這裡我使用”Mahout In Action”書裡，第一章第六節介紹的分步式基於物品的協同過濾演算法進行實現。Chapter 6: Distributing recommendation computations
測試資料集:small.csv
1,101,5.0 1,102,3.0 1,103,2.5 2,101,2.0 2,102,2.5 2,103,5.0 2,104,2.0 3,101,2.0 3,104,4.0 3,105,4.5 3,107,5.0 4,101,5.0 4,103,3.0 4,104,4.5 4,106,4.0 5,101,4.0 5,102,3.0 5,103,2.0 5,104,4.0 5,105,3.5 5,106,4.0
每行3個欄位，依次是使用者ID,電影ID,使用者對電影的評分(0-5分，每0.5為一個評分點！)
演算法的思想：
- 1. 建立物品的同現矩陣
- 2. 建立使用者對物品的評分矩陣
- 3. 矩陣計算推薦結果
1). 建立物品的同現矩陣
按使用者分組，找到每個使用者所選的物品，單獨出現計數及兩兩一組計數。
[101] [102] [103] [104] [105] [106] [107] [101] 5 3 4 4 2 2 1 [102] 3 3 3 2 1 1 0 [103] 4 3 4 3 1 2 0 [104] 4 2 3 4 2 2 1 [105] 2 1 1 2 2 1 1 [106] 2 1 2 2 1 2 0 [107] 1 0 0 1 1 0 1
2). 建立使用者對物品的評分矩陣
按使用者分組，找到每個使用者所選的物品及評分
U3 [101] 2.0 [102] 0.0 [103] 0.0 [104] 4.0 [105] 4.5 [106] 0.0 [107] 5.0
3). 矩陣計算推薦結果
同現矩陣*評分矩陣=推薦結果
圖片摘自”Mahout In Action”
MapReduce任務設計
圖片摘自”Mahout In Action”
解讀MapRduce任務：
- 步驟1: 按使用者分組，計算所有物品出現的組合列表，得到使用者對物品的評分矩陣
- 步驟2: 對物品組合列表進行計數，建立物品的同現矩陣
- 步驟3: 合併同現矩陣和評分矩陣
- 步驟4: 計算推薦結果列表
4. 架構設計：推薦系統架構
上圖中，左邊是Application業務系統，右邊是Hadoop的HDFS, MapReduce。
- 業務系統記錄了使用者的行為和對物品的打分
- 設定系統定時器CRON，每xx小時，增量向HDFS匯入資料(userid,itemid,value,time)。
- 完成匯入後，設定系統定時器，啟動MapReduce程式，執行推薦演算法。
- 完成計算後，設定系統定時器，從HDFS匯出推薦結果資料到資料庫，方便以後的及時查詢。
5. 程式開發：MapReduce程式實現
win7的開發環境 和 Hadoop的執行環境 ，請參考文章：用Maven構建Hadoop專案
新建Java類：
- Recommend.java，主任務啟動程式
- Step1.java，按使用者分組，計算所有物品出現的組合列表，得到使用者對物品的評分矩陣
- Step2.java，對物品組合列表進行計數，建立物品的同現矩陣
- Step3.java，合併同現矩陣和評分矩陣
- Step4.java，計算推薦結果列表
- HdfsDAO.java，HDFS操作工具類
1). Recommend.java，主任務啟動程式
原始碼：
package org.conan.myhadoop.recommend;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;
import org.apache.hadoop.mapred.JobConf;
public class Recommend {
public static final String HDFS = "hdfs://192.168.1.210:9000";
public static final Pattern DELIMITER = Pattern.compile("[\t,]");
public static void main(String[] args) throws Exception {
Map path = new HashMap();
path.put("data", "logfile/small.csv");
path.put("Step1Input", HDFS + "/user/hdfs/recommend");
path.put("Step1Output", path.get("Step1Input") + "/step1");
path.put("Step2Input", path.get("Step1Output"));
path.put("Step2Output", path.get("Step1Input") + "/step2");
path.put("Step3Input1", path.get("Step1Output"));
path.put("Step3Output1", path.get("Step1Input") + "/step3_1");
path.put("Step3Input2", path.get("Step2Output"));
path.put("Step3Output2", path.get("Step1Input") + "/step3_2");
path.put("Step4Input1", path.get("Step3Output1"));
path.put("Step4Input2", path.get("Step3Output2"));
path.put("Step4Output", path.get("Step1Input") + "/step4");
Step1.run(path);
Step2.run(path);
Step3.run1(path);
Step3.run2(path);
Step4.run(path);
System.exit(0);
}
public static JobConf config() {
JobConf conf = new JobConf(Recommend.class);
conf.setJobName("Recommend");
conf.addResource("classpath:/hadoop/core-site.xml");
conf.addResource("classpath:/hadoop/hdfs-site.xml");
conf.addResource("classpath:/hadoop/mapred-site.xml");
return conf;
}
}
2). Step1.java，按使用者分組，計算所有物品出現的組合列表，得到使用者對物品的評分矩陣
原始碼：
package org.conan.myhadoop.recommend;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.RunningJob;
import org.apache.hadoop.mapred.TextInputFormat;
import org.apache.hadoop.mapred.TextOutputFormat;
import org.conan.myhadoop.hdfs.HdfsDAO;
public class Step1 {
public static class Step1_ToItemPreMapper extends MapReduceBase implements Mapper
計算結果：
~ hadoop fs -cat /user/hdfs/recommend/step1/part-00000 1 102:3.0,103:2.5,101:5.0 2 101:2.0,102:2.5,103:5.0,104:2.0 3 107:5.0,101:2.0,104:4.0,105:4.5 4 101:5.0,103:3.0,104:4.5,106:4.0 5 101:4.0,102:3.0,103:2.0,104:4.0,105:3.5,106:4.0
3). Step2.java，對物品組合列表進行計數，建立物品的同現矩陣
原始碼：
package org.conan.myhadoop.recommend;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
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.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.RunningJob;
import org.apache.hadoop.mapred.TextInputFormat;
import org.apache.hadoop.mapred.TextOutputFormat;
import org.conan.myhadoop.hdfs.HdfsDAO;
public class Step2 {
public static class Step2_UserVectorToCooccurrenceMapper extends MapReduceBase implements Mapper {
private final static Text k = new Text();
private final static IntWritable v = new IntWritable(1);
@Override
public void map(LongWritable key, Text values, OutputCollector output, Reporter reporter) throws IOException {
String[] tokens = Recommend.DELIMITER.split(values.toString());
for (int i = 1; i < tokens.length; i++) {
String itemID = tokens[i].split(":")[0];
for (int j = 1; j < tokens.length; j++) {
String itemID2 = tokens[j].split(":")[0];
k.set(itemID + ":" + itemID2);
output.collect(k, v);
}
}
}
}
public static class Step2_UserVectorToConoccurrenceReducer extends MapReduceBase implements Reducer {
private IntWritable result = new IntWritable();
@Override
public void reduce(Text key, Iterator values, OutputCollector output, Reporter reporter) throws IOException {
int sum = 0;
while (values.hasNext()) {
sum += values.next().get();
}
result.set(sum);
output.collect(key, result);
}
}
public static void run(Map path) throws IOException {
JobConf conf = Recommend.config();
String input = path.get("Step2Input");
String output = path.get("Step2Output");
HdfsDAO hdfs = new HdfsDAO(Recommend.HDFS, conf);
hdfs.rmr(output);
conf.setOutputKeyClass(Text.class);
conf.setOutputValueClass(IntWritable.class);
conf.setMapperClass(Step2_UserVectorToCooccurrenceMapper.class);
conf.setCombinerClass(Step2_UserVectorToConoccurrenceReducer.class);
conf.setReducerClass(Step2_UserVectorToConoccurrenceReducer.class);
conf.setInputFormat(TextInputFormat.class);
conf.setOutputFormat(TextOutputFormat.class);
FileInputFormat.setInputPaths(conf, new Path(input));
FileOutputFormat.setOutputPath(conf, new Path(output));
RunningJob job = JobClient.runJob(conf);
while (!job.isComplete()) {
job.waitForCompletion();
}
}
}
計算結果：
~ hadoop fs -cat /user/hdfs/recommend/step2/part-00000 101:101 5 101:102 3 101:103 4 101:104 4 101:105 2 101:106 2 101:107 1 102:101 3 102:102 3 102:103 3 102:104 2 102:105 1 102:106 1 103:101 4 103:102 3 103:103 4 103:104 3 103:105 1 103:106 2 104:101 4 104:102 2 104:103 3 104:104 4 104:105 2 104:106 2 104:107 1 105:101 2 105:102 1 105:103 1 105:104 2 105:105 2 105:106 1 105:107 1 106:101 2 106:102 1 106:103 2 106:104 2 106:105 1 106:106 2 107:101 1 107:104 1 107:105 1 107:107 1
4). Step3.java，合併同現矩陣和評分矩陣
原始碼：
package org.conan.myhadoop.recommend;
import java.io.IOException;
import java.util.Map;
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.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.RunningJob;
import org.apache.hadoop.mapred.TextInputFormat;
import org.apache.hadoop.mapred.TextOutputFormat;
import org.conan.myhadoop.hdfs.HdfsDAO;
public class Step3 {
public static class Step31_UserVectorSplitterMapper extends MapReduceBase implements Mapper {
private final static IntWritable k = new IntWritable();
private final static Text v = new Text();
@Override
public void map(LongWritable key, Text values, OutputCollector output, Reporter reporter) throws IOException {
String[] tokens = Recommend.DELIMITER.split(values.toString());
for (int i = 1; i < tokens.length; i++) {
String[] vector = tokens[i].split(":");
int itemID = Integer.parseInt(vector[0]);
String pref = vector[1];
k.set(itemID);
v.set(tokens[0] + ":" + pref);
output.collect(k, v);
}
}
}
public static void run1(Map path) throws IOException {
JobConf conf = Recommend.config();
String input = path.get("Step3Input1");
String output = path.get("Step3Output1");
HdfsDAO hdfs = new HdfsDAO(Recommend.HDFS, conf);
hdfs.rmr(output);
conf.setOutputKeyClass(IntWritable.class);
conf.setOutputValueClass(Text.class);
conf.setMapperClass(Step31_UserVectorSplitterMapper.class);
conf.setInputFormat(TextInputFormat.class);
conf.setOutputFormat(TextOutputFormat.class);
FileInputFormat.setInputPaths(conf, new Path(input));
FileOutputFormat.setOutputPath(conf, new Path(output));
RunningJob job = JobClient.runJob(conf);
while (!job.isComplete()) {
job.waitForCompletion();
}
}
public static class Step32_CooccurrenceColumnWrapperMapper extends MapReduceBase implements Mapper {
private final static Text k = new Text();
private final static IntWritable v = new IntWritable();
@Override
public void map(LongWritable key, Text values, OutputCollector output, Reporter reporter) throws IOException {
String[] tokens = Recommend.DELIMITER.split(values.toString());
k.set(tokens[0]);
v.set(Integer.parseInt(tokens[1]));
output.collect(k, v);
}
}
public static void run2(Map path) throws IOException {
JobConf conf = Recommend.config();
String input = path.get("Step3Input2");
String output = path.get("Step3Output2");
HdfsDAO hdfs = new HdfsDAO(Recommend.HDFS, conf);
hdfs.rmr(output);
conf.setOutputKeyClass(Text.class);
conf.setOutputValueClass(IntWritable.class);
conf.setMapperClass(Step32_CooccurrenceColumnWrapperMapper.class);
conf.setInputFormat(TextInputFormat.class);
conf.setOutputFormat(TextOutputFormat.class);
FileInputFormat.setInputPaths(conf, new Path(input));
FileOutputFormat.setOutputPath(conf, new Path(output));
RunningJob job = JobClient.runJob(conf);
while (!job.isComplete()) {
job.waitForCompletion();
}
}
}
計算結果：
~ hadoop fs -cat /user/hdfs/recommend/step3_1/part-00000 101 5:4.0 101 1:5.0 101 2:2.0 101 3:2.0 101 4:5.0 102 1:3.0 102 5:3.0 102 2:2.5 103 2:5.0 103 5:2.0 103 1:2.5 103 4:3.0 104 2:2.0 104 5:4.0 104 3:4.0 104 4:4.5 105 3:4.5 105 5:3.5 106 5:4.0 106 4:4.0 107 3:5.0 ~ hadoop fs -cat /user/hdfs/recommend/step3_2/part-00000 101:101 5 101:102 3 101:103 4 101:104 4 101:105 2 101:106 2 101:107 1 102:101 3 102:102 3 102:103 3 102:104 2 102:105 1 102:106 1 103:101 4 103:102 3 103:103 4 103:104 3 103:105 1 103:106 2 104:101 4 104:102 2 104:103 3 104:104 4 104:105 2 104:106 2 104:107 1 105:101 2 105:102 1 105:103 1 105:104 2 105:105 2 105:106 1 105:107 1 106:101 2 106:102 1 106:103 2 106:104 2 106:105 1 106:106 2 107:101 1 107:104 1 107:105 1 107:107 1
5). Step4.java，計算推薦結果列表
原始碼：
package org.conan.myhadoop.recommend;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
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.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.RunningJob;
import org.apache.hadoop.mapred.TextInputFormat;
import org.apache.hadoop.mapred.TextOutputFormat;
import org.conan.myhadoop.hdfs.HdfsDAO;
public class Step4 {
public static class Step4_PartialMultiplyMapper extends MapReduceBase implements Mapper {
private final static IntWritable k = new IntWritable();
private final static Text v = new Text();
private final static Map cooccurrenceMatrix = new HashMap();
@Override
public void map(LongWritable key, Text values, OutputCollector output, Reporter reporter) throws IOException {
String[] tokens = Recommend.DELIMITER.split(values.toString());
String[] v1 = tokens[0].split(":");
String[] v2 = tokens[1].split(":");
if (v1.length > 1) {// cooccurrence
int itemID1 = Integer.parseInt(v1[0]);
int itemID2 = Integer.parseInt(v1[1]);
int num = Integer.parseInt(tokens[1]);
List list = null;
if (!cooccurrenceMatrix.containsKey(itemID1)) {
list = new ArrayList();
} else {
list = cooccurrenceMatrix.get(itemID1);
}
list.add(new Cooccurrence(itemID1, itemID2, num));
cooccurrenceMatrix.put(itemID1, list);
}
if (v2.length > 1) {// userVector
int itemID = Integer.parseInt(tokens[0]);
int userID = Integer.parseInt(v2[0]);
double pref = Double.parseDouble(v2[1]);
k.set(userID);
for (Cooccurrence co : cooccurrenceMatrix.get(itemID)) {
v.set(co.getItemID2() + "," + pref * co.getNum());
output.collect(k, v);
}
}
}
}
public static class Step4_AggregateAndRecommendReducer extends MapReduceBase implements Reducer {
private final static Text v = new Text();
@Override
public void reduce(IntWritable key, Iterator values, OutputCollector output, Reporter reporter) throws IOException {
Map result = new HashMap();
while (values.hasNext()) {
String[] str = values.next().toString().split(",");
if (result.containsKey(str[0])) {
result.put(str[0], result.get(str[0]) + Double.parseDouble(str[1]));
} else {
result.put(str[0], Double.parseDouble(str[1]));
}
}
Iterator iter = result.keySet().iterator();
while (iter.hasNext()) {
String itemID = iter.next();
double score = result.get(itemID);
v.set(itemID + "," + score);
output.collect(key, v);
}
}
}
public static void run(Map path) throws IOException {
JobConf conf = Recommend.config();
String input1 = path.get("Step4Input1");
String input2 = path.get("Step4Input2");
String output = path.get("Step4Output");
HdfsDAO hdfs = new HdfsDAO(Recommend.HDFS, conf);
hdfs.rmr(output);
conf.setOutputKeyClass(IntWritable.class);
conf.setOutputValueClass(Text.class);
conf.setMapperClass(Step4_PartialMultiplyMapper.class);
conf.setCombinerClass(Step4_AggregateAndRecommendReducer.class);
conf.setReducerClass(Step4_AggregateAndRecommendReducer.class);
conf.setInputFormat(TextInputFormat.class);
conf.setOutputFormat(TextOutputFormat.class);
FileInputFormat.setInputPaths(conf, new Path(input1), new Path(input2));
FileOutputFormat.setOutputPath(conf, new Path(output));
RunningJob job = JobClient.runJob(conf);
while (!job.isComplete()) {
job.waitForCompletion();
}
}
}
class Cooccurrence {
private int itemID1;
private int itemID2;
private int num;
public Cooccurrence(int itemID1, int itemID2, int num) {
super();
this.itemID1 = itemID1;
this.itemID2 = itemID2;
this.num = num;
}
public int getItemID1() {
return itemID1;
}
public void setItemID1(int itemID1) {
this.itemID1 = itemID1;
}
public int getItemID2() {
return itemID2;
}
public void setItemID2(int itemID2) {
this.itemID2 = itemID2;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
計算結果：
~ hadoop fs -cat /user/hdfs/recommend/step4/part-00000 1 107,5.0 1 106,18.0 1 105,15.5 1 104,33.5 1 103,39.0 1 102,31.5 1 101,44.0 2 107,4.0 2 106,20.5 2 105,15.5 2 104,36.0 2 103,41.5 2 102,32.5 2 101,45.5 3 107,15.5 3 106,16.5 3 105,26.0 3 104,38.0 3 103,24.5 3 102,18.5 3 101,40.0 4 107,9.5 4 106,33.0 4 105,26.0 4 104,55.0 4 103,53.5 4 102,37.0 4 101,63.0 5 107,11.5 5 106,34.5 5 105,32.0 5 104,59.0 5 103,56.5 5 102,42.5 5 101,68.0
6). HdfsDAO.java，HDFS操作工具類
詳細解釋，請參考文章：Hadoop程式設計呼叫HDFS
原始碼：
package org.conan.myhadoop.hdfs;
import java.io.IOException;
import java.net.URI;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.mapred.JobConf;
public class HdfsDAO {
private static final String HDFS = "hdfs://192.168.1.210:9000/";
public HdfsDAO(Configuration conf) {
this(HDFS, conf);
}
public HdfsDAO(String hdfs, Configuration conf) {
this.hdfsPath = hdfs;
this.conf = conf;
}
private String hdfsPath;
private Configuration conf;
public static void main(String[] args) throws IOException {
JobConf conf = config();
HdfsDAO hdfs = new HdfsDAO(conf);
hdfs.copyFile("datafile/item.csv", "/tmp/new");
hdfs.ls("/tmp/new");
}
public static JobConf config(){
JobConf conf = new JobConf(HdfsDAO.class);
conf.setJobName("HdfsDAO");
conf.addResource("classpath:/hadoop/core-site.xml");
conf.addResource("classpath:/hadoop/hdfs-site.xml");
conf.addResource("classpath:/hadoop/mapred-site.xml");
return conf;
}
public void mkdirs(String folder) throws IOException {
Path path = new Path(folder);
FileSystem fs = FileSystem.get(URI.create(hdfsPath), conf);
if (!fs.exists(path)) {
fs.mkdirs(path);
System.out.println("Create: " + folder);
}
fs.close();
}
public void rmr(String folder) throws IOException {
Path path = new Path(folder);
FileSystem fs = FileSystem.get(URI.create(hdfsPath), conf);
fs.deleteOnExit(path);
System.out.println("Delete: " + folder);
fs.close();
}
public void ls(String folder) throws IOException {
Path path = new Path(folder);
FileSystem fs = FileSystem.get(URI.create(hdfsPath), conf);
FileStatus[] list = fs.listStatus(path);
System.out.println("ls: " + folder);
System.out.println("==========================================================");
for (FileStatus f : list) {
System.out.printf("name: %s, folder: %s, size: %d\n", f.getPath(), f.isDir(), f.getLen());
}
System.out.println("==========================================================");
fs.close();
}
public void createFile(String file, String content) throws IOException {
FileSystem fs = FileSystem.get(URI.create(hdfsPath), conf);
byte[] buff = content.getBytes();
FSDataOutputStream os = null;
try {
os = fs.create(new Path(file));
os.write(buff, 0, buff.length);
System.out.println("Create: " + file);
} finally {
if (os != null)
os.close();
}
fs.close();
}
public void copyFile(String local, String remote) throws IOException {
FileSystem fs = FileSystem.get(URI.create(hdfsPath), conf);
fs.copyFromLocalFile(new Path(local), new Path(remote));
System.out.println("copy from: " + local + " to " + remote);
fs.close();
}
public void download(String remote, String local) throws IOException {
Path path = new Path(remote);
FileSystem fs = FileSystem.get(URI.create(hdfsPath), conf);
fs.copyToLocalFile(path, new Path(local));
System.out.println("download: from" + remote + " to " + local);
fs.close();
}
public void cat(String remoteFile) throws IOException {
Path path = new Path(remoteFile);
FileSystem fs = FileSystem.get(URI.create(hdfsPath), conf);
FSDataInputStream fsdis = null;
System.out.println("cat: " + remoteFile);
try {
fsdis =fs.open(path);
IOUtils.copyBytes(fsdis, System.out, 4096, false);
} finally {
IOUtils.closeStream(fsdis);
fs.close();
}
}
}
這樣我們就自己程式設計實現了MapReduce化基於物品的協同過濾演算法。
RHadoop的實現方案，請參考文章：RHadoop實踐系列之三 R實現MapReduce的協同過濾演算法
Mahout的實現方案，請參考文章：Mahout分步式程式開發 基於物品的協同過濾ItemCF
我已經把整個MapReduce的實現都放到了github上面：
來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/29754888/viewspace-1425182/，如需轉載，請註明出處，否則將追究法律責任。
相關文章
- 系統設計：使用Scala、Spark和Hadoop構建推薦系統SparkHadoop
- 如何構建推薦系統
- 電影推薦系統資料預處理
- 融合 MF 和 RNN 的電影推薦系統RNN
- 電影推薦系統的圖片雲存
- 【推薦系統篇】--推薦系統之之特徵工程部分---構建訓練集流程特徵工程
- 【推薦系統篇】--推薦系統介紹和基本架構流程架構
- 實現基於內容的電影推薦系統—程式碼實現
- 構建高效系統：必備熱門API介面集合的推薦API
- 問題解決：構建基於深度學習架構的推薦系統！深度學習架構
- ［O'Reilly精品圖書推薦］Hadoop生態系統Hadoop
- 推薦系統
- 作者推薦的學習方法——外部體系構建
- Netflix推薦系統(Part two)-系統架構架構
- 【推薦系統篇】--推薦系統之訓練模型模型
- 編輯推薦之《推薦系統》
- 基於Apriori關聯規則的電影推薦系統(附python程式碼)Python
- 推薦系統之業務架構總覽架構
- 基於使用者的協同過濾來構建推薦系統
- 【推薦系統篇】--推薦系統之測試資料
- 《推薦系統學習》之推薦系統那點事
- 推薦系統概述
- 機器學習 — 推薦系統機器學習
- 《Kettle構建Hadoop ETL系統實踐》簡介Hadoop
- 《推薦系統實踐》筆記 01 推薦系統簡介筆記
- 知識圖譜構建與應用推薦學習分享
- 推薦系統論文之序列推薦：KERL
- 推薦系統: 相關推薦方法對比
- 推薦系統一——深入理解YouTube推薦系統演算法演算法
- 機器學習專案 - 使用 Apache Spark 建立電影推薦引擎機器學習ApacheSpark
- 《推薦系統》-DIN模型模型
- 《推薦系統》-PNN模型模型
- python 推薦系統Python
- 推薦系統雜談
- 推薦系統評估
- 推薦：看板系統Trello
- 圖靈推薦系統圖靈
- 【大資料 Spark】利用電影觀看記錄資料,進行電影推薦大資料Spark