同现矩阵

2015-07-27 13:47:29

http://zengzhaozheng.blog.51cto.com/8219051/1557054?utm_source=tuicool

hadoop

更多相关内容
comat:根据空间数据创建同现矩阵
2021-05-04 13:36:35

昏迷的目标是基于空间数据创建共现矩阵，包括加权共现矩阵（ wecoma ）和集成共现矩阵（ incoma ）。安装您可以使用以下方法从安装comat的发行版本： install.packages( " comat " ) 您可以使用以下命令从安装...

收起
coom.rar_同现矩阵
2022-07-15 04:34:21

同现矩阵（或共生矩阵）的求解与显示，输入可以是图像路径，也可以是矩阵，有注释。还有实验报告，伪代码介绍详尽。

收起

为什么*同现矩阵**评分矩阵=推荐结果

千次阅读 2015-10-30 11:17:20

同现矩阵其实就是物品与物品之间的关联度，这个关联度由所有用户对所有物品的评分决定比如第一条，说明同时有3个用户喜欢 101 与 102 物品ID1 物品ID2 物品ID1与物品ID2...

举个用户3对物品102是否感兴趣的例子:
用户3对所有物品的评分，有评分说明用户3喜欢这东西

用户ID	物品ID1	用户评分
3	101	2
3	102	0
3	103	0
3	104	4
3	105	4.5
3	106	0
3	107	5

同现矩阵其实就是物品与物品之间的关联度，这个关联度由所有用户对所有物品的评分决定
比如第一条，说明同时有3个用户喜欢 101 与 102

物品ID1	物品ID2	物品ID1与物品ID2关联权重
101	102	3
102	102	4
103	102	4
104	102	2
105	102	2
106	102	1
107	102	1

计算推荐得分，其意义是：比如第5行，用户3很喜欢物品105（给了得了4.5），同时由其他用户也知道喜欢物品105的对物品102的喜欢程度（得分2），两者相乘表示用户3因为喜欢物品105 推算出同时也喜欢物品102的得分。

用户ID	物品ID1	用户评分	物品ID2	物品ID1与物品ID2关联权重	得分=用户评分*物品ID1与物品ID2关联权重
3	101	2	102	3	2*3=6
3	102	0	102	4	0
3	103	0	102	4	0
3	104	4	102	2	4*2=8
3	105	4.5	102	2	4.5*2=9
3	106	0	102	1	0
3	107	5	102	1	5*1=5

用户3对物品102 兴趣总得分

用户ID	物品ID2	总得分
3	102	28

本帖最后由 pig2 于 2014-6-17 19:43 编辑

问题导读：

1. 推荐系统概述；

2. 推荐系统指标设计；

3. Hadoop并行算法；

4. 推荐系统架构；

5. MapReduce程序实现。

前言

Netflix电影推荐的百万美金比赛，把“推荐”变成了时下最热门的数据挖掘算法之一。也正是由于Netflix的比赛，让企业界和学科界有了更深层次的技术碰撞。引发了各种网站“推荐”热，个性时代已经到来。

一、推荐系统概述

电子商务网站是个性化推荐系统重要地应用的领域之一，亚马逊就是个性化推荐系统的积极应用者和推广者，亚马逊的推荐系统深入到网站的各类商品，为亚马逊带来了至少30%的销售额。

不光是电商类，推荐系统无处不在。QQ，人人网的好友推荐；新浪微博的你可能感觉兴趣的人；优酷，土豆的电影推荐；豆瓣的图书推荐；大从点评的餐饮推荐；世纪佳缘的相亲推荐；天际网的职业推荐等。

推荐算法分类：

按数据使用划分：

协同过滤算法：UserCF, ItemCF, ModelCF

基于内容的推荐: 用户内容属性和物品内容属性

社会化过滤：基于用户的社会网络关系

按模型划分：

最近邻模型:基于距离的协同过滤算法

Latent Factor Mode(SVD)：基于矩阵分解的模型

Graph：图模型，社会网络图模型

基于用户的协同过滤算法UserCF

基于用户的协同过滤，通过不同用户对物品的评分来评测用户之间的相似性，基于用户之间的相似性做出推荐。简单来讲就是：给用户推荐和他兴趣相似的其他用户喜欢的物品。

用例说明：

算法实现及使用介绍，请参考文章：Mahout推荐算法API详解

基于物品的协同过滤算法ItemCF

基于item的协同过滤，通过用户对不同item的评分来评测item之间的相似性，基于item之间的相似性做出推荐。简单来讲就是：给用户推荐和他之前喜欢的物品相似的物品。

用例说明：

算法实现及使用介绍，请参考文章：Mahout推荐算法API详解

注：基于物品的协同过滤算法，是目前商用最广泛的推荐算法。

协同过滤算法实现，分为2个步骤

1. 计算物品之间的相似度
2. 根据物品的相似度和用户的历史行为给用户生成推荐列表

有关协同过滤的另一篇文章，请参考：RHadoop实践系列之三 R实现MapReduce的协同过滤算法

二、需求分析：推荐系统指标设计

下面我们将从一个公司案例出发来全面的解释，如何进行推荐系统指标设计。

案例介绍

Netflix电影推荐百万奖金比赛，http://www.netflixprize.com/
Netflix官方网站：www.netflix.com

Netflix，2006年组织比赛是的时候，是一家以在线电影租赁为生的公司。他们根据网友对电影的打分来判断用户有可能喜欢什么电影，并结合会员看过的电影以及口味偏好设置做出判断，混搭出各种电影风格的需求。

收集会员的一些信息，为他们指定个性化的电影推荐后，有许多冷门电影竟然进入了候租榜单。从公司的电影资源成本方面考量，热门电影的成本一般较高，如果Netflix公司能够在电影租赁中增加冷门电影的比例，自然能够提升自身盈利能力。

Netflix公司曾宣称60%左右的会员根据推荐名单定制租赁顺序，如果推荐系统不能准确地猜测会员喜欢的电影类型，容易造成多次租借冷门电影而并不符合个人口味的会员流失。为了更高效地为会员推荐电影，Netflix一直致力于不断改进和完善个性化推荐服务，在2006年推出百万美元大奖，无论是谁能最好地优化Netflix推荐算法就可获奖励100万美元。到2009年，奖金被一个7人开发小组夺得，Netflix随后又立即推出第二个百万美金悬赏。这充分说明一套好的推荐算法系统是多么重要，同时又是多么困难。

上图为比赛的各支队伍的排名！

补充说明：

1. Netflix的比赛是基于静态数据的，就是给定“训练级”，匹配“结果集”，“结果集”也是提前就做好的，所以这与我们每天运营的系统，其实是不一样的。

2. Netflix用于比赛的数据集是小量的，整个全集才666MB，而实际的推荐系统都要基于大量历史数据的，动不动就会上GB,TB等

Netflix数据下载
部分训练集：http://graphlab.org/wp-content/uploads/2013/07/smallnetflix_mm.train_.gz
部分结果集：http://graphlab.org/wp-content/uploads/2013/07/smallnetflix_mm.validate.gz
完整数据集：http://www.lifecrunch.biz/wp-content/uploads/2011/04/nf_prize_dataset.tar.gz

所以，我们在真实的环境中设计推荐的时候，要全面考量数据量，算法性能，结果准确度等的指标。

推荐算法选型：基于物品的协同过滤算法ItemCF，并行实现

数据量：基于Hadoop架构，支持GB,TB,PB级数据量

算法检验：可以通过准确率，召回率，覆盖率，流行度等指标评判。

结果解读：通过ItemCF的定义，合理给出结果解释

三、算法模型：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: 计算推荐结果列表

四、架构设计：推荐系统架构

上图中，左边是Application业务系统，右边是Hadoop的HDFS, MapReduce。

业务系统记录了用户的行为和对物品的打分
设置系统定时器CRON，每xx小时，增量向HDFS导入数据(userid,itemid,value,time)。
完成导入后，设置系统定时器，启动MapReduce程序，运行推荐算法。
完成计算后，设置系统定时器，从HDFS导出推荐结果数据到数据库，方便以后的及时查询。

五、程序开发：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<String, String> path = new HashMap<String, String>();
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;
}
}

复制代码

</blockquote></div></font></div><div align="left" style="font-size: 13px;"><font color="#4d4d4f"><b>2). Step1.java，按用户分组，计算所有物品出现的组合列表，得到用户对物品的评分矩阵</b></font></div>
<div align="left" style="font-size: 13px;"><font color="#4d4d4f">源代码：</font></div><div align="left" style="font-size: 13px;"><span style="color: rgb(77, 77, 79); line-height: 1.5;"><div class="blockcode"><blockquote>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<Object, Text, IntWritable, Text> {
private final static IntWritable k = new IntWritable();
private final static Text v = new Text();
@Override
public void map(Object key, Text value, OutputCollector<IntWritable, Text> output, Reporter reporter) throws IOException {
String[] tokens = Recommend.DELIMITER.split(value.toString());
int userID = Integer.parseInt(tokens[0]);
String itemID = tokens[1];
String pref = tokens[2];
k.set(userID);
v.set(itemID + ":" + pref);
output.collect(k, v);
}
}
public static class Step1_ToUserVectorReducer extends MapReduceBase implements Reducer<IntWritable, Text, IntWritable, Text> {
private final static Text v = new Text();
@Override
public void reduce(IntWritable key, Iterator values, OutputCollector<IntWritable, Text> output, Reporter reporter) throws IOException {
StringBuilder sb = new StringBuilder();
while (values.hasNext()) {
sb.append("," + values.next());
}
v.set(sb.toString().replaceFirst(",", ""));
output.collect(key, v);
}
}
public static void run(Map<String, String> path) throws IOException {
JobConf conf = Recommend.config();
String input = path.get("Step1Input");
String output = path.get("Step1Output");
HdfsDAO hdfs = new HdfsDAO(Recommend.HDFS, conf);
hdfs.rmr(input);
hdfs.mkdirs(input);
hdfs.copyFile(path.get("data"), input);
conf.setMapOutputKeyClass(IntWritable.class);
conf.setMapOutputValueClass(Text.class);
conf.setOutputKeyClass(IntWritable.class);
conf.setOutputValueClass(Text.class);
conf.setMapperClass(Step1_ToItemPreMapper.class);
conf.setCombinerClass(Step1_ToUserVectorReducer.class);
conf.setReducerClass(Step1_ToUserVectorReducer.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/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<LongWritable, Text, Text, IntWritable> {
private final static Text k = new Text();
private final static IntWritable v = new IntWritable(1);
@Override
public void map(LongWritable key, Text values, OutputCollector<Text, IntWritable> 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<Text, IntWritable, Text, IntWritable> {
private IntWritable result = new IntWritable();
@Override
public void reduce(Text key, Iterator values, OutputCollector<Text, IntWritable> 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<String, String> 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<LongWritable, Text, IntWritable, Text> {
private final static IntWritable k = new IntWritable();
private final static Text v = new Text();
@Override
public void map(LongWritable key, Text values, OutputCollector<IntWritable, Text> 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<String, String> 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<LongWritable, Text, Text, IntWritable> {
private final static Text k = new Text();
private final static IntWritable v = new IntWritable();
@Override
public void map(LongWritable key, Text values, OutputCollector<Text, IntWritable> 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<String, String> 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<LongWritable, Text, IntWritable, Text> {
private final static IntWritable k = new IntWritable();
private final static Text v = new Text();
private final static Map<Integer, List> cooccurrenceMatrix = new HashMap<Integer, List>();
@Override
public void map(LongWritable key, Text values, OutputCollector<IntWritable, Text> 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<IntWritable, Text, IntWritable, Text> {
private final static Text v = new Text();
@Override
public void reduce(IntWritable key, Iterator values, OutputCollector<IntWritable, Text> output, Reporter reporter) throws IOException {
Map<String, Double> result = new HashMap<String, Double>();
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<String, String> 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

复制代码

对Step4过程优化，请参考本文最后的补充内容。

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上面：
https://github.com/bsspirit/maven_hadoop_template/releases/tag/recommend

转自：http://blog.fens.me/hadoop-mapreduce-recommend/

http://f.dataguru.cn/thread-229459-1-1.html

收起

展开全文

建立物品的同现矩阵的过程和 同现矩阵*评分矩阵的意义
千次阅读 2016-02-28 16:29:37
建立同现矩阵的过程在协同过滤算法中同现矩阵的建立是极其关键的一部，而在大多数的博客文章中大多都没有详细说明矩阵的建立过程。在此详细说明一下：原始数据如下所示：1,101,5.0 1,102,3.0 1,103,2.5 2,101,2.0 2,...
建立同现矩阵的过程

在协同过滤算法中同现矩阵的建立是极其关键的一部，而在大多数的博客文章中大多都没有详细说明矩阵的建立过程。在此详细说明一下：

原始数据如下所示：
```
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
```
对这些数据建立的同现矩阵如下：
```
      [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
```
建立过程解释：
1.针对用户 1 对电影101 102 103 进行了评分，那么会在上述的矩阵如下位置写 1 ：
```
（101,101）（101,102）（101,103）
（102,101）（102,102）（102,103）
（103,101）（103,102）（103,103）
```
即对101,102,103进行组合产生3*3个位置点，在对应的位置写1就行。
针对所有的用户进行上述操作，然后将所有的结果相加，最后就可以得到同现矩阵。

同现矩阵*评分矩阵的意义

举个用户3对物品102是否感兴趣的例子:
用户3对所有物品的评分，有评分说明用户3喜欢这东西

同现矩阵其实就是物品与物品之间的关联度，这个关联度由所有用户对所有物品的评分决定。

同现的意思就是同时出现的意思，就是说，喜欢 101 的时候同时喜欢 102 。

比如第一条，说明同时有3个用户喜欢 101 与 102。意思就是说，在3个用户的各自喜好列表中 101 和 102 同时出现了。

计算推荐得分，其意义是：比如第5行，用户3很喜欢物品105（给了得了4.5），同时由其他用户也知道喜欢物品105的对物品102的喜欢程度（得分2），两者相乘表示用户3因为喜欢物品105 推算出同时也喜欢物品102的得分。

用户3对物品102 兴趣总得分
收起
展开全文
协同过滤算法

MapReduce实现推荐算法（*同现矩阵**评分矩阵=推荐结果）

千次阅读 2015-08-29 14:54:03

该讲主要是基于ItemCF的物品推荐。

1，常用的两大协同过滤算法。

a,基于物品的协同过滤算法

基于 item 的协同过滤，通过用户对不同 item 的评分来评测 item 之间的相似性，基于 item 之间的相似性做出推荐。简单来讲就是：给用户推荐和他之前喜欢的物品相似的物品。

b, 基于用户的协同过滤算法 UserCF

数据源：

评分矩阵：

举个用户3对物品102是否感兴趣的例子:
用户3对所有物品的评分，有评分说明用户3喜欢这东西

用户ID
物品ID1

用户评分

3

101

2

3

102

0

3

103

0

3

104

4

3

105

4.5

3

106

0

3

107

5

同现矩阵：
同现矩阵其实就是物品与物品之间的关联度，这个关联度由所有用户对所有物品的评分决定
比如第一条，说明同时有3个用户喜欢 101 与 102

物品ID1
物品ID2

物品ID1与物品ID2关联权重

101

102

3

102

102

4

103

102

4

104

102

2

105

102

2

106

102

1

107

102

1

2，mapreduce代码一共分为5部分：

1，去除数据中的重复记录：

package com.laoxiao.tuijian;

import java.io.IOException;
import java.util.Map;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
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;

/**
 * 去重复
 * @author root
 *
 */
public class Step1 {

	
	public static boolean run(Configuration config,Map<String, String> paths){
		try {
			FileSystem fs =FileSystem.get(config);
			Job job =Job.getInstance(config);
			job.setJobName("step1");
			job.setJarByClass(Step1.class);
			job.setMapperClass(Step1_Mapper.class);
			job.setReducerClass(Step1_Reducer.class);
//			
			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(NullWritable.class);
			
			
			
			FileInputFormat.addInputPath(job, new Path(paths.get("Step1Input")));
			Path outpath=new Path(paths.get("Step1Output"));
			if(fs.exists(outpath)){
				fs.delete(outpath,true);
			}
			FileOutputFormat.setOutputPath(job, outpath);
			
			boolean f= job.waitForCompletion(true);
			return f;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}
	
	 static class Step1_Mapper extends Mapper<LongWritable, Text, Text, NullWritable>{

		protected void map(LongWritable key, Text value,
				Context context)
				throws IOException, InterruptedException {
			if(key.get()!=0){//为了去掉表头
				context.write(value, NullWritable.get());
			}
		}
	}
	
	 
	 static class Step1_Reducer extends Reducer<Text, IntWritable, Text, NullWritable>{

			protected void reduce(Text key, Iterable<IntWritable> i,
					Context context)
					throws IOException, InterruptedException {
				context.write(key,NullWritable.get());
			}
		}
}

2，按照用户分组，得出用户对物品的推荐得分矩阵

package com.laoxiao.tuijian;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.MapWritable;
import org.apache.hadoop.io.NullWritable;
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.log4j.Logger;

/**
 * 按用户分组，计算所有物品出现的组合列表，得到用户对物品的推荐得分矩阵
u13	i160:1,
u14	i25:1,i223:1,
u16	i252:1,
u21	i266:1,
u24	i64:1,i218:1,i185:1,
u26	i276:1,i201:1,i348:1,i321:1,i136:1,
 * @author root
 *
 */
public class Step2 {

	
	public static boolean run(Configuration config,Map<String, String> paths){
		try {
//			config.set("mapred.jar", "C:\\Users\\Administrator\\Desktop\\wc.jar");
			FileSystem fs =FileSystem.get(config);
			Job job =Job.getInstance(config);
			job.setJobName("step2");
			job.setJarByClass(StartRun.class);
			job.setMapperClass(Step2_Mapper.class);
			job.setReducerClass(Step2_Reducer.class);
//			
			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(Text.class);
			
			
			
			FileInputFormat.addInputPath(job, new Path(paths.get("Step2Input")));
			Path outpath=new Path(paths.get("Step2Output"));
			if(fs.exists(outpath)){
				fs.delete(outpath,true);
			}
			FileOutputFormat.setOutputPath(job, outpath);
			
			boolean f= job.waitForCompletion(true);
			return f;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}
	
	 static class Step2_Mapper extends Mapper<LongWritable, Text, Text, Text>{

		protected void map(LongWritable key, Text value,
				Context context)
				throws IOException, InterruptedException {
			String[]  tokens=value.toString().split(",");
			String item=tokens[0];//取得物品id
			String user=tokens[1];//取得用户id
			String action =tokens[2];//取得用户行为
			Text k= new Text(user);
			Integer rv =StartRun.R.get(action);//从一个map集合中得出某种行为应该得到的分数权重
//			if(rv!=null){
			Text v =new Text(item+":"+ rv.intValue());
			context.write(k, v);//按照userid分组，values是物品id:分数
		}
	}
	
	 
	 static class Step2_Reducer extends Reducer<Text, Text, Text, Text>{

			protected void reduce(Text key, Iterable<Text> i,
					Context context)
					throws IOException, InterruptedException {
				Map<String, Integer> r =new HashMap<String, Integer>();//为了累加对同样一件物品的多次评分
				
				for(Text value :i){//循环每个用户，对不同物品的打分情况
					String[] vs =value.toString().split(":");
					String item=vs[0];//这个是物品Id
					Integer action=Integer.parseInt(vs[1]);//这个是该物品的得分
					action = ((Integer) (r.get(item)==null?  0:r.get(item))).intValue() + action;
					r.put(item,action);
				}
				StringBuffer sb =new StringBuffer();
				for(Entry<String, Integer> entry :r.entrySet() ){
					sb.append(entry.getKey()+":"+entry.getValue().intValue()+",");
				}
				
				context.write(key,new Text(sb.toString()));
			}
		}
}

3，计算物品的同现矩阵

package com.laoxiao.tuijian;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.MapWritable;
import org.apache.hadoop.io.NullWritable;
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.log4j.Logger;
/**
 * 对物品组合列表进行计数，建立物品的同现矩阵
i100:i100	3
i100:i105	1
i100:i106	1
i100:i109	1
i100:i114	1
i100:i124	1
 * @author root
 *
 */
public class Step3 {
	 private final static Text K = new Text();
     private final static IntWritable V = new IntWritable(1);
	
	public static boolean run(Configuration config,Map<String, String> paths){
		try {
			FileSystem fs =FileSystem.get(config);
			Job job =Job.getInstance(config);
			job.setJobName("step3");
			job.setJarByClass(StartRun.class);
			job.setMapperClass(Step3_Mapper.class);
			job.setReducerClass(Step3_Reducer.class);
			job.setCombinerClass(Step3_Reducer.class);
//			
			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(IntWritable.class);
			
			
			
			FileInputFormat.addInputPath(job, new Path(paths.get("Step3Input")));
			Path outpath=new Path(paths.get("Step3Output"));
			if(fs.exists(outpath)){
				fs.delete(outpath,true);
			}
			FileOutputFormat.setOutputPath(job, outpath);
			
			boolean f= job.waitForCompletion(true);
			return f;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}
	
	 static class Step3_Mapper extends Mapper<LongWritable, Text, Text, IntWritable>{

		protected void map(LongWritable key, Text value,
				Context context)
				throws IOException, InterruptedException {
			String[]  tokens=value.toString().split("\t");
			String[] items =tokens[1].split(",");//取得每一个物品id和对应的评分
			for (int i = 0; i < items.length; i++) {
				String itemA = items[i].split(":")[0];//取得物品id
				for (int j = 0; j < items.length; j++) {
					String itemB = items[j].split(":")[0];
					K.set(itemA+":"+itemB);//设置物品之间的同现，次数为1，因为在一次用户行为中
					context.write(K, V);
				}
			}
			
		}
	}
	
	 
	 static class Step3_Reducer extends Reducer<Text, IntWritable, Text, IntWritable>{

			protected void reduce(Text key, Iterable<IntWritable> i,
					Context context)
					throws IOException, InterruptedException {
				int sum =0;
				for(IntWritable v :i ){
					sum =sum+v.get();
				}
				V.set(sum);
				context.write(key, V);
			}
		}
	 
}

4,同现矩阵和得分矩阵相乘

（待续）

收起

展开全文

如何建立物品的同现矩阵
千次阅读 2014-08-20 17:34:30

在协同过滤算法中同现矩阵的建立是极其关键的一部，而在大多数的博客文章中大多都没有详细说明矩阵的建立过程。...针对所有的用户进行上述操作，然后将所有的结果相加，最后就可以得到同现矩阵。

收起

协同过滤算法
灰度图像之同现矩阵的求解算法与实现
千次阅读 2014-05-11 20:54:23

灰度图像之同现矩阵的求解算法与实现一、算法输入：灰度图像矩阵、位移矢量。输出：灰度图像矩阵对应的同现矩阵 。 Step1：统计灰度图像矩阵（以下简称矩阵）的元素的最大值（即灰度图像的...

收起

Matlab
协同过滤与同现矩阵
千次阅读 2018-09-24 23:09:47

协同过滤与同现矩阵：

收起
同现矩阵的概念（待完善）
2018-09-24 23:42:38

同现矩阵：

收起
推荐系统中的同现矩阵问题
千次阅读 2016-12-07 15:35:35

最近在研究Hadoop大数据方面的知识，正巧看到了推荐系统，其中里面有个同现矩阵很是让我蒙圈，查了很多blog之后，写下来与大家分享。 1.建立同现矩阵的过程在协同过滤算法中同现矩阵的建立是极其关键的一部，...

收起
同现矩阵*评分矩阵=推荐结果
千次阅读 2016-05-22 10:38:17

同现矩阵其实就是物品与物品之间的关联度，这个关联度由所有用户对所有物品的评分决定比如第一条，说明同时有3个用户喜欢 101 与 102 物品ID1 物品ID2 物品ID1与物品ID2关联权重 ...

收起
为什么同现矩阵*评分矩阵=推荐结果？
千次阅读 2015-07-25 17:19:56

同现矩阵其实就是物品与物品之间的关联度，这个关联度由所有用户对所有物品的评分决定比如第一条，说明有3个用户既喜欢 101 也喜欢 102 物品ID1 物品ID2 物品ID1与物品ID2...

收起
推荐系统协同过滤算法ItemCF同现矩阵的构建
2020-11-25 14:54:11

推荐系统协同过滤算法ItemCF同现矩阵的构建

收起

推荐系统算法
Spark机器学习：同现相似度矩阵
千次阅读 2016-10-25 11:26:23

同相似度可用于为协调过滤推荐中，查找相似的物品或者用户。下面对同相似度进行简单的定义物品i和物品j的同相似度公式定义：其中，分母是喜欢物品i的用户数，而分子则是同时喜欢物品i和物品j的用户数。因此，...

收起
计算物品之间的相似度矩阵$$基于物品的协同过滤算法
千次阅读 2021-04-25 08:39:44

（1）建立用户物品倒排表 A a b d B a c e C b e null D b d e ( 2 ) 构建同现矩阵 同现矩阵表示同时喜欢两个物品的用户数，根据用户物品倒排表计算出来 (3) 统计每个物品有行为的用户数 (4) 计算物品之间的相似度...

收起

python 推荐系统协同过滤人工智能
共现矩阵
万次阅读 2019-08-02 19:54:52

共现矩阵主要用于发现主题，解决词向量相近关系的表示；将共现矩阵行(列)作为词向量例如：语料库如下： • I like deep learning. • I like NLP. • I enjoy flying. 则共现矩阵表示如下：（使用对称的窗函数...

收起
python 共现矩阵的实现
千次阅读 2020-02-29 15:26:58

文章目录前言什么是共现矩阵共现矩阵的构建思路前言最近在学习python词库的可视化，其中有一个依据共现矩阵制作的可视化，感觉十分炫酷，便以此复刻。什么是共现矩阵比如我们有两句话： ls = ['我永远喜欢三上...

收起

python
glove:使用共现矩阵计算手套向量
2021-05-07 23:22:13

训练是使用语料库中的同现矩阵来完成的。结果表示形式包含对许多其他任务有用的结构。描述模型的论文在。可以在该机器学习模型的原始实现。 @作者乔纳森·赖曼（Jonathan Raiman）例子要使用此软件包，您...

收起

Python
MapReduce算法设计－计算单词共现矩阵
千次阅读 2016-01-10 13:00:35

利用MapReduce计算单词共现矩阵

收起

mapreduce 算法设计
Movielens数据集 -用户物品评分矩阵
千次阅读 2020-04-01 12:04:43

Movielens数据集 -用户物品评分矩阵转化 #代码实现 // An highlighted block file = open("ratings.csv", 'r', encoding='UTF-8') # 记得读取文件时加‘r’， encoding='UTF-8' # 读取data.csv中每行中除了名字的...

收起
最长公共子串问题——矩阵法求解
千次阅读 2019-03-03 21:07:46

最大公共子串长度问题就是：求两个串的所有子串中能够匹配上的最大长度是多少。...2、比较二维矩阵中每个点对应行列字符中否相等，相等的话值设置为1，否则设置为0。 3、通过查找出值为1的最长对角线...

收起
Spark MLlib之矩阵
千次阅读 2016-09-19 13:24:34

将一个分布式矩阵转换为另一种不同格式的分布式矩阵，可能引发全局shuffle操作，开销很大四种分布式矩阵实现 RowMatrix IndexedRowMatrix CoordinateMatrix BlockMatrix 行矩阵(RowMatrix) ...

收起

spark MLlib matrix
词向量发展史-共现矩阵-SVD-NNLM-Word2Vec-Glove-ELMo
万次阅读 多人点赞 2018-12-13 15:47:10

话不多说，直接上干货。首先介绍相关概念：词嵌入：把词映射为实数域上向量的技术也叫词嵌入（word embedding）。...具体来说，我们通过从大量的语料文本中构建一个共现矩阵来定义word representation。 ...

收起

自然语言处理词向量
深度学习自学记录（3）——两种多分类混淆矩阵的Python实现（含代码）
2020-12-21 09:15:37

深度学习自学记录（3）——两种多分类混淆矩阵的Python实现（含代码）1、什么是混淆矩阵2、分类模型评价指标3、两种多分类混淆矩阵3.1直接打印出每一个类别的分类准确率。3.2打印具体的分类结果的数值4、总结 1、...

收起
电源技术中的矩阵式三相／单相电源研究
2020-11-07 04:52:06

目前矩阵式变频器因采用具有输入功率因数可调，输出频率连续，功率双向流动且无直流母线的矩阵式变换器(MC)而倍受关注。虽然三相用电设备广泛应用于生产领域，但是在一些行业(如感应加热和感应熔炼)仍需要单相电源，...

收起
刘丁酉矩阵分析
2019-03-14 19:11:56

1994年1月起任武汉测绘科技大学数理系副主任、主任及武汉大学数学与统计学院公共课部主任，现为武汉大学数学与统计学院基础数学系教授、硕博士生导师、湖北省优秀教师、湖北省高校数学学科跨世纪学科带头人、测绘...

收起
光腔模式的数值矩阵方法
2021-02-25 08:37:22

对腔镜有限分划,基于衍射积分理论构造光腔的传输数值矩阵, 并对其进行特征值和特征向量求解, 从而实现光腔模式计算。计算了非虚共焦非稳腔内的光场特性和远场光斑分布, 并与实际结果吻合。

收起

comat:根据空间数据创建同现矩阵

coom.rar_同现矩阵

为什么*同现矩阵**评分矩阵=推荐结果

建立物品的同现矩阵的过程和 *同现矩阵**评分矩阵的意义

建立同现矩阵的过程

同现矩阵*评分矩阵的意义

MapReduce实现推荐算法（*同现矩阵**评分矩阵=推荐结果）

该讲主要是基于ItemCF的物品推荐。

1，常用的两大协同过滤算法。

评分矩阵：

2，mapreduce代码一共分为5部分：

如何建立物品的同现矩阵

灰度图像之同现矩阵的求解算法与实现

协同过滤与同现矩阵

同现矩阵的概念（待完善）

推荐系统中的同现矩阵问题

*同现矩阵**评分矩阵=推荐结果

为什么*同现矩阵**评分矩阵=推荐结果？

推荐系统协同过滤算法ItemCF同现矩阵的构建

Spark机器学习：同现相似度矩阵

计算物品之间的相似度矩阵$$基于物品的协同过滤算法

共现矩阵

python 共现矩阵的实现

glove:使用共现矩阵计算手套向量

MapReduce算法设计－计算单词共现矩阵

Movielens数据集 -用户物品评分矩阵

最长公共子串问题——矩阵法求解

Spark MLlib之矩阵

词向量发展史-共现矩阵-SVD-NNLM-Word2Vec-Glove-ELMo

深度学习自学记录（3）——两种多分类混淆矩阵的Python实现（含代码）

电源技术中的矩阵式三相／单相电源研究

刘丁酉矩阵分析

光腔模式的数值矩阵方法

同现矩阵

comat:根据空间数据创建同现矩阵

coom.rar_同现矩阵

为什么同现矩阵*评分矩阵=推荐结果

建立物品的同现矩阵的过程 和 同现矩阵*评分矩阵的意义

建立同现矩阵的过程

同现矩阵*评分矩阵的意义

MapReduce实现推荐算法（同现矩阵*评分矩阵=推荐结果）

该讲主要是基于ItemCF的物品推荐。

1，常用的两大协同过滤算法。

评分矩阵：

2，mapreduce代码一共分为5部分：

如何建立物品的同现矩阵

灰度图像之同现矩阵的求解算法与实现

协同过滤与同现矩阵

同现矩阵的概念（待完善）

推荐系统中的同现矩阵问题

同现矩阵*评分矩阵=推荐结果

为什么同现矩阵*评分矩阵=推荐结果？

推荐系统协同过滤算法ItemCF同现矩阵的构建

Spark机器学习：同现相似度矩阵

计算物品之间的相似度矩阵$$基于物品的协同过滤算法

共现矩阵

python 共现矩阵的实现

glove:使用共现矩阵计算手套向量

MapReduce算法设计－计算单词共现矩阵

Movielens数据集 -用户物品评分矩阵

最长公共子串问题——矩阵法求解

Spark MLlib之矩阵

词向量发展史-共现矩阵-SVD-NNLM-Word2Vec-Glove-ELMo

深度学习自学记录（3）——两种多分类混淆矩阵的Python实现（含代码）

电源技术中的矩阵式三相／单相电源研究

刘丁酉矩阵分析

光腔模式的数值矩阵方法

同现矩阵

为什么*同现矩阵**评分矩阵=推荐结果

建立物品的同现矩阵的过程和 *同现矩阵**评分矩阵的意义

MapReduce实现推荐算法（*同现矩阵**评分矩阵=推荐结果）

*同现矩阵**评分矩阵=推荐结果

为什么*同现矩阵**评分矩阵=推荐结果？