基于随机游走的personalRank算法

最新推荐文章于 2022-05-28 20:10:17 发布
最新推荐文章于 2022-05-28 20:10:17 发布
阅读量1.5k 收藏 5
点赞数 1
分类专栏： 大数据 文章标签： personalRank 随机游走 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love_zy0216/article/details/88868071
版权

基于随机游走的personalRank算法是从谷歌的pageRank算法演变来的，使用的比较少，可以说是比较小众。至于pageRank算法在此贴出我认为写得好的博客pageRank算法参考
1、personalRank算法介绍：
在这里插入图片描述
数据集随机分成训练集和测试集，指定训练集中任意点开始进行随机游走，游走的时候根据不同点之间的权重来选择游走方向的概率，到达下一个点以后会根据指定的alpha值随机决定继续游走还是回到起点重新游走，训练集中所有的点都进行游走结束后，每个点会聚集到一个游走的概率值，根据这个值进行相关性推荐。

网上python实现的很多，本人的python编程能力也一般，所以用java实现

Rank类（相关性排序）

public class Rank implements Comparable<Rank>{
	private int twoColumn;
	private double sum_simlatrity=0.0;//设置默认值
	public int getTwoColumn() {
		return twoColumn;
	}
	public void setTwoColumn(int movie) {
		this.twoColumn = movie;
	}
	public Double getSum_simlatrity() {
		return sum_simlatrity;
	}
	public void setSum_simlatrity(double sumSimlatrity) {
		sum_simlatrity = sumSimlatrity;
	}
	//重写equals方法
	public boolean equals(Object obj) {
		return (this.getTwoColumn() == ((Rank) obj).getTwoColumn());
	    }
	public int compareTo(Rank o) {
		return this.getSum_simlatrity().compareTo(o.getSum_simlatrity());
	}

}

对所有推荐结果进行堆排序（数据量偏大的时候堆排序是最快的）

public class Heapsort {
	public <T> void sort(List<T> list,int k) {
		Object[] a = list.toArray();
		sort(a,k);
		ListIterator<T> i = list.listIterator();
//		for (int j=0; j<a.length; j++) {
//		    i.next();
//		    i.set((T)a[j]);
//		}
		for(int j=a.length-1;j>=0;j--){
			i.next();
			i.set((T)a[j]);
		}

	}
	
	public void sort(Object[] a,int k) {
		buildMaxHeapify(a);
		heapSort(a,k);
	}


	private void heapSort(Object[] a, int k) {
		for(int i=a.length-1;i>=(a.length-k);i--){
			Object temp=a[0];
			a[0]=a[i];
			a[i]=temp;
			max_heapify(a,0,i);
		}

	}

	public void buildMaxHeapify(Object[] a){
		for(int j=(a.length>>1)-1;j>=0;j--){
			max_heapify(a,j,a.length);
		}
	}
	public void max_heapify(Object[] a,int index,int heapSize){
		//当前点与左右子节点比较
		int left=(index<<1)+1;
		int right=(index<<1)+2;

		int largest=index;
		if(left<heapSize&& ((Comparable<Object>) a[left]).compareTo(a[index])>0){
			largest=left;
		}
		if(right<heapSize&&((Comparable<Object>) a[right]).compareTo(a[largest])>0){
			largest=right;
		}

		//得到最大值后可能需要交换，如果交换了，其子节点可能就不是最大堆了，需要重新调整
		if(largest!=index){
			//交换
			Object object=a[index];
			a[index]=a[largest];
			a[largest]=object;
			max_heapify(a,largest,heapSize);
		}
	}

	/*public static void main(String[] args) {
		List<Rank> list = new ArrayList<>();
		Rank r1 = new Rank();
		r1.setSum_simlatrity(0.7);
		Rank r2 = new Rank();
		r2.setSum_simlatrity(0.5);
		Rank r3 = new Rank();
		r3.setSum_simlatrity(0.9);
		Rank r4 = new Rank();
		r4.setSum_simlatrity(0.1);
		Rank r5 = new Rank();
		r5.setSum_simlatrity(0.8);
		list.add(r1);
		list.add(r2);
		list.add(r3);
		list.add(r4);
		list.add(r5);
		Heapsort heapsort = new Heapsort();
		heapsort.sort(list,5);
		System.out.println(list.toString());
	}*/
}

算法实现主类

public class PersonalRank {
	HashMap<Integer,Set<Integer>> trainset=new HashMap<Integer,Set<Integer>>();
	HashMap<Integer,Set<Integer>> testset=new HashMap<Integer,Set<Integer>>();
	HashMap<Integer,Set<Integer>> inverse_table=new HashMap<Integer,Set<Integer>>();
	HashMap<Integer,Integer> movie_popular=new HashMap<Integer,Integer>();
	HashMap<Integer,List<Double>> trainset_weight = new HashMap<>();
	HashMap<Integer,List<Double>> inverse_table_weight = new HashMap<>();
	int i=0;
	int maxOneId = 0;
	int maxTwoId = 0;
	int trainset_length;
	int testset_length;
	int two_count=0;//第二列去重后的和（测试数据集中的movie列）

	List<Rank> recommendedList=null;
	List<Ralated_user> ralatedUsersList=null;
    int k=0;
	int n=10;
	Random random=new Random(0);

	public void generate_dataset(int pivot,Map<List<Long>,List<Long>> map) throws IOException{
		map.forEach((l1,l2) -> {
			List<Long> startTempList = l1;
			List<Long> endTempList = l2;
			//todo
			List<Double> weight = new ArrayList<>();

			for (int i = 0; i < startTempList.size(); i++) {
				int startInt = Integer.parseInt(startTempList.get(i).toString());
				int endInt = Integer.parseInt(endTempList.get(i).toString());
				double edgeWeight = weight.get(i);

				if (startInt > maxOneId){
					maxOneId = startInt;
				}
				if (endInt > maxTwoId){
					maxTwoId = endInt;
				}

				if(random.nextInt(8)==pivot){
					if(testset.containsKey(startInt)){
						HashSet<Integer> set =(HashSet<Integer>) testset.get(startInt);
						set.add(endInt);
						testset.put(startInt,set);
					}else{
						Set<Integer> set=new HashSet<Integer>();
						set.add(endInt);
						testset.put(startInt,set);
					}
					testset_length++;
				}else{
					if(trainset.containsKey(startInt)){
						List<Double> w = trainset_weight.get(startInt);
						w.add(edgeWeight);
						trainset_weight.put(startInt,w);
						HashSet<Integer> set =(HashSet<Integer>) trainset.get(startInt);
						set.add(endInt);
						trainset.put(startInt,set);

					}else{
						List<Double> w = new ArrayList<>();
						weight.add(edgeWeight);
						trainset_weight.put(startInt,w);
						Set<Integer> set=new HashSet<Integer>();
						set.add(endInt);
						trainset.put(startInt,set);
					}
					trainset_length++;
				}
				this.i++;
				if (this.i %100000 == 0)
					System.out.println("已装载"+ this.i +"文件");
			}
		});
		/*map.forEach((l0,l1) -> {
			String[] content = new String[2];
			content[0] = l0.toString();
			content[1] = l1.toString();
			int l0Int = Integer.parseInt(content[0]);
			int l1Int = Integer.parseInt(content[1]);
			if (l0Int > maxUserId){
				maxUserId = l0Int;
			}
			if (l1Int > maxMovieId){
				maxMovieId = l1Int;
			}
			if(random.nextInt(8)==pivot){
				if(testset.containsKey(l0Int)){
					HashSet<Integer> set =(HashSet<Integer>) testset.get(Integer.parseInt(content[0]));
					set.add(l1Int);
					testset.put(l0Int,set);
				}else{
					Set<Integer> set=new HashSet<Integer>();
					set.add(l1Int);
					testset.put(l0Int,set);
				}
				testset_length++;

			}else{
				if(trainset.containsKey(l0Int)){
					HashSet<Integer> set =(HashSet<Integer>) trainset.get(Integer.parseInt(content[0]));
					set.add(l1Int);
					trainset.put(l0Int,set);

				}else{
					Set<Integer> set=new HashSet<Integer>();
					set.add(l1Int);
					trainset.put(l0Int,set);
				}

				trainset_length++;

			}
			this.i++;
			if (this.i %100000 == 0)
				System.out.println("已装载"+ this.i +"文件");
		});*/
		/*File file=new File("/home/lyg/下载/ml-latest-small/newRatings.csv");

		if(!file.exists()||file.isDirectory())
			throw new FileNotFoundException();

		BufferedReader br=new BufferedReader(new FileReader(file));
		String temp=null;
		while ((temp=br.readLine())!=null) {
			
			String[] content=temp.replaceAll("\n\t", "").split(",");
			if (Integer.parseInt(content[0]) > maxUserId){
				maxUserId = Integer.parseInt(content[0]);
			}
			if (Integer.parseInt(content[1]) > maxMovieId){
				maxMovieId = Integer.parseInt(content[1]);
			}
			if(random.nextInt(8)==pivot){
				if(testset.containsKey(Integer.parseInt(content[0]))){
					HashSet<Integer> set =(HashSet<Integer>) testset.get(Integer.parseInt(content[0]));
					set.add(Integer.parseInt(content[1]));
					testset.put(Integer.parseInt(content[0]),set);
				}else{
					Set<Integer> set=new HashSet<Integer>();
					set.add(Integer.parseInt(content[1]));
					testset.put(Integer.parseInt(content[0]),set);
				}
				testset_length++;
				
			}else{
				if(trainset.containsKey(Integer.parseInt(content[0]))){
					HashSet<Integer> set =(HashSet<Integer>) trainset.get(Integer.parseInt(content[0]));
					set.add(Integer.parseInt(content[1]));
					trainset.put(Integer.parseInt(content[0]),set);
					
				}else{
					Set<Integer> set=new HashSet<Integer>();
					set.add(Integer.parseInt(content[1]));
					trainset.put(Integer.parseInt(content[0]),set);
				}
				
				trainset_length++;
				
			}
			i++;
			if (i%100000 == 0)
                System.out.println("已装载"+i+"文件");
	   }*/
		System.out.println("测试集和训练集分割完成，测试集长度："+testset_length+",训练集长度："+trainset_length);
	}

	public void calc_user_sim(){

		for(int obj : trainset.keySet()){
			Set<Integer> value = trainset.get(obj);
			Iterator<Integer> it=value.iterator();
			List<Double> weight = trainset_weight.get(obj);
			int i = 0;
			while(it.hasNext()) {
				int o=it.next();
				Double aLong = weight.get(i);
				if(inverse_table.containsKey(o)){
					Set<Integer> set=inverse_table.get(o);
					set.add(obj);
					inverse_table.put(o,set);
					List<Double> list = inverse_table_weight.get(o);
					list.add(aLong);
					inverse_table_weight.put(o,list);
				}else {
					Set<Integer> set=new HashSet<Integer>();
					set.add(obj);
					inverse_table.put(o,set);
					List<Double> list = new ArrayList<>();
					list.add(aLong);
					inverse_table_weight.put(o,list);
				}
				//  count item popularity at the same time
				if(!movie_popular.containsKey(o)){
					movie_popular.put(o,1);
				}else {
					movie_popular.put(o,movie_popular.get(o)+1);
				}
				i++;
			}
		}
		//建立反转表的目的是方便建立co-rated movies 矩阵
		two_count=inverse_table.size();
	}
	double alpah=0.6;

	public void personalRank(int root,int max_step){
		double rank1[]=new double[maxOneId + 1];
		double rank2[]=new double[maxTwoId + 1];
		double temp1[]=new double[maxOneId + 1];
		double temp2[]=new double[maxTwoId + 1];
		
		rank1[root]=1;//从推荐用户开始游走，所以它的相关性初始值是1
		for(int k=0;k<max_step;k++){
			for(int i=0;i<temp1.length;i++) temp1[i]=0.0;
			for(int j=0;j<temp2.length;j++) temp2[j]=0.0;
			Iterator<Integer> u=trainset.keySet().iterator();//u是用户
			while(u.hasNext()){
				int uu=u.next();
				List<Double> list = trainset_weight.get(uu);
				Set<Integer> movies=trainset.get(uu);//movies是电影集合
				Iterator<Integer> it=movies.iterator();
				int i = 0;
				while(it.hasNext()){//遍历电影
					//用数组下标记录电影编号，值记录相关性
					temp2[it.next()]+=alpah*rank1[uu]/(list.get(i) * movies.size());
					i++;
				}
			}
			
			Iterator<Integer> m=inverse_table.keySet().iterator();//m是电影编号
			while(m.hasNext()){
				int mm=m.next();
				List<Double> list = inverse_table_weight.get(mm);
				Set<Integer> us=inverse_table.get(mm);//us是用户集合
				Iterator<Integer> it=us.iterator();
				int i = 0;
				while(it.hasNext()){//遍历用户
					//用数组下标记录用户编号，值记录相关性
					temp1[it.next()]+=alpah*rank2[mm]/(list.get(i) * us.size());
					i++;
				}
			}
			temp1[root]+=1-alpah;
			for(int i=0;i<temp1.length;i++)
				rank1[i]=temp1[i];
			
			for(int i=0;i<temp2.length;i++)
				rank2[i]=temp2[i];
			/*for (int i = 0; i < rank2.length; i++) {
				if (rank2[i] != 0.0){
					System.out.println(i + "---" + rank2[i]);
				}
			}*/
		}
		recommendedList=new ArrayList<Rank>();
		Set<Integer> watched_movies=trainset.get(root);
		for(int i=0;i<rank2.length;i++){
			if(watched_movies.contains(i)||rank2[i]==0.0)
				continue;
			Rank r=new Rank();
			r.setTwoColumn(i);
			r.setSum_simlatrity(rank2[i]);
			recommendedList.add(r);
		}

//		if (recommendedMoviesList.size() != 0){
        Heapsort ss=new Heapsort();
		if (recommendedList.size() < n){
		   n =  recommendedList.size();
        }
		ss.sort(recommendedList, n);
//		}
	}

	public Set<Rank> evaluate(int user){
		int rec_count=0;
		int test_count=0;
		int hit=0;
		double popularSum=0;
		Set<Rank> all_rec=new HashSet<>();
		Set<Integer> test_movies=testset.get(user);
		//被推荐用户，最大迭代次数
		personalRank(user, k);

		if(recommendedList.size() !=0){
			if(recommendedList.size()<n) n=recommendedList.size();
			for(int i=0;i<n;i++){
				Rank rank=recommendedList.get(i);
				all_rec.add(rank);
			}
		}
		/*double precision=hit/(1.0*rec_count);
		double recall=hit/(1.0*test_count);
		double coverage=all_rec.size()/(1.0*two_count);
		double popularity=popularSum/(1.0*rec_count);
		System.out.println("precision=%"+precision*100+"\trecall=%"+recall*100+"\tcoverage=%"+coverage*100+"\tpopularity="+popularity);*/

		return all_rec;
	}

    /**
     *
     * @param map 数据集
     * @param targetNodeId 对照实体
     * @param k 迭代次数
     * @param n 取前n条进行推荐
     */
	public static Set<Rank> go(Map<List<Long>,List<Long>> map,Long targetNodeId,int k,int n){
        Set<Rank> all_rec = null;
		try {
			PersonalRank ss=new PersonalRank();
			//将数据分成测试集和训练集
			ss.generate_dataset(3,map);
			//统计数量并且建立反转表
			ss.calc_user_sim();
			//遍历所有训练集找到每个用户适合推荐的电影
			//while(it.hasNext()){
            ss.k=k;
            ss.n = n;
			all_rec = ss.evaluate(Integer.parseInt(targetNodeId.toString()));
		} catch (IOException e) {
			e.printStackTrace();
		}
		return all_rec;
	}
	/*public static void main(String[] args) throws IOException {
		PersonalRank ss=new PersonalRank();
		ss.generate_dataset(3);//分割数据集
		ss.calc_user_sim();//建立反转表
		Set<Integer> set=new HashSet<Integer>();
		set.add(5);
		set.add(10);
		set.add(20);
		set.add(40);
		set.add(80);
		set.add(160);
		Iterator<Integer> it=set.iterator();
		while(it.hasNext()){
			ss.k=it.next();

		}
		ss.evaluate();
	}*/
}

personalRank算法的时间复杂度较高（处理2Mmovielens数据集大约需要50s），不适合大数据量的数据集使用,更加不适合实时推荐项目使用。

love_zy0216
关注
专栏目录
PersonalRank算法的Python实现
08-18
PersonalRank算法的Python实现
用PersonalRank实现基于图的推荐算法
weixin_34267123的博客
01-08 326
今天我们讲一个下怎么使用随机游走算法PersonalRank实现基于图的推荐。 在推荐系统中，用户行为数据可以表示成图的形式，具体来说是二部图。用户的行为数据集由一个个（u,i）二元组组成，表示为用户u对物品i产生过行为。本文中我们认为用户对他产生过行为的物品的兴趣度是一样的，也就是我们只考虑“感兴趣”OR“不感兴趣”。假设有下图所示的行为数据集。 其中user...
personal rank
Andy_shenzl的博客
07-23 595
算法原理 在paga rank中，计算出的PR值是每个节点相对于全局的重要性程度，而在推荐问题中，我们希望求解的是所有的商品节点相对于某个用户节点的重要性程度。 PersonnalRank算法为pagerank算法的变形形式，用于计算所有商品节点相对于某个用户节点的重要性程度。 example User\Item D_1 D_2 D_3 D_4 D_5 U_1 4 3 - 5 - U_2 5 - 4 4 - U_3 4 - 5 - 3 U_4 2 3 - 1 - U_5 -
PersonalRank推荐算法
进击的小小白
10-24 3015
PersonalRank 0.前提假设： 有三个顾客U1,U2,U3对4种商品P1,P2,P3,P4进行评价（没有评价则为0分）： P1 P2 P3 44 U1 2 1 0 3 U2 1 0 0 2 U3 0 0 4 2 对应的二部图为： 假设，现在需要为U2推荐P2和P3中的一个，哪个更应该推荐给U2呢？有很多推荐算法，在这里，我们介绍，PersonalRank算法来进行推荐。 1.基本思想 PersonalRank算法和PageRank算法思想差不多，但是PageRank
Personal Rank算法的原理及实现
bull521的博客
07-04 2385
1.简介 PageRank[1]是Google创始人拉里·佩奇和谢尔盖·布林于1997提出的用于客观评价网页的重要度的方法，最初的PageRank算法是主题无关的，它不依赖于任何特定的搜索查询。为了得到主题相关的搜索结果，Haveliwala提出主题敏感的PageRank方法，称为PersonalRank[2]，该方法用于在二分图中为用户进行推荐。二分图又称为二部图，是图论中的一种特殊模型，设G=(V,E) 是一个图，如果顶点V可分割为两个互不相交的子集(A, B)，并且图中的每条边(i, j)所关联的两
基于随机游走的PersonalRank算法
12-29
### 基于随机游走的PersonalRank算法详解 #### 一、基本概念与理论基础 **PersonalRank算法**是一种基于图模型的推荐算法，它借鉴了PageRank算法的思想，通过对用户-物品交互数据构建图模型，利用随机游走的方式来...
基于图的PersonalRank算法原理及Python实现
Dive的博客
06-03 690
1 PersonalRank算法简介 2 随机游走多次实现 3 矩阵化实现 参考： https://www.cnblogs.com/hellojamest/p/11763033.html
Python基于随机游走模型的
05-29
1. 基于随机游走的 PersonalRank 算法：PersonalRank 算法是一种基于随机游走的推荐算法，它通过类似 PageRank 的思想将用户和物品映射到同一张图中，然后在图上执行随机游走，最终得到用户对物品的概率分布，根据...
利用matlab 给重启随机游走算法增加成本约束条件
最新发布
06-10
其中，personalrank函数是stochastic blockmodeling工具箱中实现重启随机游走算法的函数，可以通过设置'Cost'和'CostBound'参数来引入成本约束条件，设置'NumRestart'参数来控制重启次数。 通过以上方法，可以在...
机器学习->推荐系统->基于图的推荐算法(PersonalRank)
村头陶员外的博客
03-24 8452
本博文将介绍PersonalRank算法，以及该算法在推荐系统上的应用。 将用户行为数据用二分图表示，例如用户数据是由一系列的二元组组成，其中每个元组(u,i)表示用户u对物品i产生过行为。将个性化推荐放在二分图模型中，那么给用户u推荐物品任务可以转化为度量Uv和与Uv 没有边直接相连 的物品节点在图上的相关度，相关度越高的在推荐列表中越靠前。图中顶点的相关度主要取决与以下因素： 1）两个顶
PersonalRank推荐
胡二妞
06-05 404
详情见github:   https://github.com/huawang123/tools/blob/master/PersonalRank0.py
理解personal Rank算法
NLP与推荐算法
03-06 1592
哈喽，各位好，我是菜鸟小明哥。 personal Rank是random walk的应用，搞了几天也没明白到底是咋回事，其中难以理解的是第2个式子为啥要加1-alpha?? 你肯定会告诉我，来看第1个式子，真不好意思，我第1个式子其实也没理解。 我是看的这个的视频，但是我没看懂，大牛只顾自己讲了，其实我倒带N次了，还是没理解。 既然如此，那我就搜索点资料看看，果然有好点的资料，某个大佬从p...
PersonalRank：一种基于图的推荐算法
飞翔的熊blabla
11-30 2791
上面的二部图表示user A对item a和c感兴趣，B对a b c d都感兴趣，C对c和d感兴趣。本文假设每条边代表的感兴趣程度是一样的。 现在我们要为user A推荐item，实际上就是计算A对所有item的感兴趣程度。在personal rank算法中不区分user节点和item节点，这样一来问题就转化成：对节点A来说，节点A B C a b c d的重要度各是多少。重要度用PR来表示
推荐系统笔记二 Personal rank算法
thormas1996的博客
04-23 1201
Graph-based推荐传统做法是构建二元图（bipartite），分为user和item两个node集合，user-item的interaction构建两个集合之间的连线，见下图，其中圆框是三个user，方形框是四个item。 该方法在2005年前较流行，现在学术界更流行的方法是Graph Convolutional Network(GCN)。 推荐采用personal rank算法，或...
推荐系统4——图模型（PersonalRank）
u012290039的专栏
04-09 1758
在之前我也看了很多人写的推荐系统的博客，理论的、算法的都有，多是个人的理解和感悟，虽然很深刻，但是对于自己而言还是不成系统，于是我参考大牛项亮编著的《推荐系统实践》将该领域知识系统整理一遍，与大家一起学习。 本系列对应的代码请查看https://github.com/wangyuyunmu/Recommended-system-practice 上一篇总结了基于用户行为数据的推荐方法——隐语义，本...
图算法（二）：PersonalRank算法【适用场景：商品推荐、好友推荐和网页推荐等】【继承了经典PageRank算法的思想，利用图链接结构来递归计算各节点的重要性】
u013250861的博客
05-28 1305
PersonalRank算法又称Personalized PageRank算法。该算法继承了经典PageRank算法的思想，利用图链接结构来递归计算各节点的重要性。 与PageRank算法不同的是，为了保证随机行走中各节点的访问概率能够反映出用户的偏好，PersonalRank算法在随机行走中的每次跳转会以（1-alpha）的概率返回到source节点，因此可以基于source节点个性化地计算网络节点的相关性和重要性。 PersonalRank值越高，source节点的相关性/重要性越高。 适用场景：Per
推荐系统-基于PersonalRank推荐模型
csearch的博客
05-07 1905
时间：2017年5月 出处： 声明：版权所有，转载请联系作者并注明出在推荐系统中，用户对物品的行为数据可以转化成图的形式，具体来说，可以转化为二分图进行表示，基于图来考虑推荐问题也是一种常用的思路之一。1.PageRank模型PageRank是Google网页排序的经典算法，这里只做简要概述，详细的算法推导过程及实现，可以网上找找相关资料，挺多的。 PageRank是Larry Page 和
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值