├── src
    ├── rating
    │   ├── RatingReader.java
    │   └── RatingRecord.java
    ├── personalrank
    │   ├── Item.java
    │   ├── GraphThread.java
    │   ├── ListenReader.java
    │   ├── IDManager.java
    │   └── Graph.java
    └── svd
    │   ├── sgd
    │       ├── Model.java
    │       └── Trainer.java
    │   ├── SvdModel.java
    │   ├── MovieLensDataReader.java
    │   └── bgd
    │       ├── Trainer.java
    │       └── Model.java
└── README.md


/src/rating/RatingReader.java:
--------------------------------------------------------------------------------
 1 | package rating;
 2 | 
 3 | 
 4 | public abstract class RatingReader {
 5 | 	public abstract int getUserNum();
 6 | 	public abstract int getItemNum();
 7 | 	public abstract double getMinPref();
 8 | 	public abstract double getMaxPref();
 9 | 	
10 | 	public abstract boolean hasNext();	
11 | 	public abstract RatingRecord getNext();
12 | 	public abstract void reset();
13 | }
14 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # svd for recommendation
 2 | reference:
 3 | 
 4 | 《A Guide to Singular Value Decomposition for Collaborative Filtering》
 5 | 
 6 | 《Collaborative Filtering for Netflix》
 7 | 
 8 | 
 9 | #personal rank
10 | reference:
11 | 
12 | http://blog.csdn.net/harryhuang1990/article/details/10048383
13 | 用PersonalRank实现基于图的推荐算法
14 | 
15 | https://github.com/wangrn/RecommendationSystemStudy/blob/master/PersonalRank.py
16 | 


--------------------------------------------------------------------------------
/src/rating/RatingRecord.java:
--------------------------------------------------------------------------------
 1 | package rating;
 2 | 
 3 | public class RatingRecord {
 4 | 	
 5 | 	int user;
 6 | 	int item;
 7 | 	double pref;
 8 | 	
 9 | 	
10 | 	public RatingRecord(int u,int i,double p)
11 | 	{
12 | 		user=u;
13 | 		item=i;
14 | 		pref=p;
15 | 	}
16 | 	
17 | 	public int getUser()
18 | 	{
19 | 		return user;
20 | 	}
21 | 	public int getItem()
22 | 	{
23 | 		return item;
24 | 	}
25 | 	public double getPref()
26 | 	{
27 | 		return pref;
28 | 	}
29 | 
30 | 	
31 | }
32 | 


--------------------------------------------------------------------------------
/src/personalrank/Item.java:
--------------------------------------------------------------------------------
 1 | package personalrank;
 2 | 
 3 | 
 4 | 
 5 | class Item implements Comparable<Item>
 6 | {
 7 | 	int id;
 8 | 	float weight;
 9 | 	public Item(int id,float weight)
10 | 	{
11 | 		this.id=id;
12 | 		this.weight=weight;
13 | 	}
14 | 	
15 | 
16 | 
17 | 	@Override
18 | 	public int compareTo(Item o) {
19 | 		if(weight<o.weight)
20 | 		{
21 | 			return 1;
22 | 		}
23 | 		else if(weight>o.weight)
24 | 		{
25 | 			return -1;
26 | 		}
27 | 		else return 0;
28 | 	}
29 | 	
30 | }
31 | 


--------------------------------------------------------------------------------
/src/svd/sgd/Model.java:
--------------------------------------------------------------------------------
 1 | package svd.sgd;
 2 | 
 3 | import svd.SvdModel;
 4 | 
 5 | public class Model extends SvdModel{
 6 | 
 7 | 	public Model(int un, int in, int r, double minPref, double maxPref) {
 8 | 		super(un, in, r, minPref, maxPref);
 9 | 		// TODO Auto-generated constructor stub
10 | 	}
11 | 	
12 | 	public double update(int user,int item,double pref)
13 | 	{
14 | 		double predicted = predict(user, item);
15 | 		double error= pref - predicted;
16 | 		
17 | 		double[] userVecotr = new double[rank];
18 | 		for(int r=0;r<rank;r++)
19 | 		{
20 | 			//没有正则化,训练集rmse很快降低,但是测试集效果还是不好,证实了过拟合.
21 | 			/*
22 | 			userVecotr[r] = userVectors[user][r]+error*itemVectors[item][r]*alpha;
23 | 			itemVectors[item][r] =  itemVectors[item][r] + error*userVectors[user][r]*alpha;
24 | 			*/
25 | 			
26 | 			//加上正则化后,避免过拟合.训练集rmse降低速度较慢,但测试集效果很好.
27 | 			userVecotr[r] = userVectors[user][r]+(error*itemVectors[item][r]-k*userVectors[user][r])*alpha;
28 | 			itemVectors[item][r] =  itemVectors[item][r] + (error*userVectors[user][r]-k*itemVectors[item][r])*alpha;
29 | 			
30 | 			userVectors[user][r] = userVecotr[r];
31 | 		}	
32 | 		
33 | 		return error*error;
34 | 	}
35 | 
36 | }
37 | 


--------------------------------------------------------------------------------
/src/svd/SvdModel.java:
--------------------------------------------------------------------------------
 1 | package svd;
 2 | 
 3 | public class SvdModel {
 4 | 	
 5 | 	
 6 | 	protected double alpha=0.001;
 7 | 	protected double k=0.02;
 8 | 	
 9 | 	protected int userNum;
10 | 	protected int itemNum;
11 | 	protected int rank;
12 | 
13 | 	protected double minPref;
14 | 	protected double maxPref;
15 | 	
16 | 	protected double[][] userVectors;
17 | 	protected double[][] itemVectors;
18 | 	
19 | 
20 | 	
21 | 	public SvdModel(int un,int in,int r,double minPref,double maxPref)
22 | 	{
23 | 		
24 | 		userNum=un;
25 | 		itemNum=in;
26 | 		rank=r;
27 | 		this.minPref=minPref;
28 | 		this.maxPref=maxPref;
29 | 		
30 | 
31 | 		userVectors = new double[userNum][rank];
32 | 		itemVectors = new double[itemNum][rank];
33 | 
34 | 
35 | 		
36 | 		for(int u=0;u<userNum;u++)
37 | 		{
38 | 			for(int i=0;i<rank;i++)
39 | 			{
40 | 				userVectors[u][i] = Math.random()*(Math.sqrt((maxPref-minPref)/rank));
41 | 				//调整了初始化的方式,也对性能有提升
42 | 			}
43 | 		}
44 | 		
45 | 		for(int u=0;u<itemNum;u++)
46 | 		{
47 | 			for(int i=0;i<rank;i++)
48 | 			{
49 | 				itemVectors[u][i] = Math.random()*(Math.sqrt((maxPref-minPref)/rank));
50 | 			}
51 | 		}		
52 | 	}
53 | 	
54 | 	public double predict(int u,int i)
55 | 	{
56 | 		double score=0.0;
57 | 		for(int r=0;r<rank;r++)
58 | 		{
59 | 			score= score+userVectors[u][r]*itemVectors[i][r];
60 | 		}
61 | 		
62 | 		if(score>(maxPref-minPref))
63 | 		{
64 | 			score = maxPref;
65 | 		}
66 | 		else if(score<0)
67 | 		{
68 | 			score = minPref;
69 | 		}
70 | 		else
71 | 		{
72 | 			score +=minPref;
73 | 		}
74 | 		
75 | 		return score;
76 | 	}
77 | 	
78 | 
79 | 	
80 | 	
81 | 	
82 | }
83 | 


--------------------------------------------------------------------------------
/src/personalrank/GraphThread.java:
--------------------------------------------------------------------------------
 1 | package personalrank;
 2 | 
 3 | import java.io.IOException;
 4 | 
 5 | public class GraphThread  extends Thread{
 6 | 
 7 | 	Graph graph;
 8 | 	int start;
 9 | 	int end;
10 | 	public GraphThread(Graph graph,int start,int end)
11 | 	{
12 | 		this.graph = graph;
13 | 		this.start =start;
14 | 		this.end = end;
15 | 	}
16 | 
17 | 	public void run()
18 | 	{
19 | 		graph.recommend(start, end);
20 | 	}
21 | 	
22 | 	public static void main(String[] args) throws IOException, InterruptedException {
23 | 		// TODO Auto-generated method stub
24 | 
25 | 		ListenReader reader = new ListenReader("dataset/user_music.dat");
26 | 		Graph graph = new Graph(reader);
27 | 		
28 | 		int totalUser = graph.idManager.getUserMaxIternalID() +1;
29 | 		
30 | 		int threadNum = 10;
31 | 		GraphThread[] threads = new GraphThread[threadNum];
32 | 		int start=-1;
33 | 		int end=-1;
34 | 		long start_time = System.currentTimeMillis(); 
35 | 		for(int i=0;i<threadNum;i++)
36 | 		{
37 | 			start = end+1; if(start>totalUser) break;
38 | 			end=start+totalUser/threadNum; if(end>totalUser) end = totalUser;
39 | 			System.out.println("thread:"+i);
40 | 			System.out.println("start:"+start);
41 | 			System.out.println("end:"+end);
42 | 			
43 | 			threads[i] = new GraphThread(graph,start,end);
44 | 			threads[i].start();		
45 | 			
46 | 		}
47 | 		
48 | 		for(int i=0;i<threadNum;i++)
49 | 		{
50 | 			if(threads[i] !=null)
51 | 				threads[i].join();
52 | 			System.out.println("finished:"+i);
53 | 		}
54 | 		
55 | 		long end_time = System.currentTimeMillis();  
56 |         System.out.println("子线程执行时长：" + (end_time - start_time));  
57 | 	}
58 | 
59 | }
60 | 


--------------------------------------------------------------------------------
/src/personalrank/ListenReader.java:
--------------------------------------------------------------------------------
 1 | package personalrank;
 2 | 
 3 | import java.io.BufferedReader;
 4 | import java.io.File;
 5 | import java.io.FileInputStream;
 6 | import java.io.IOException;
 7 | import java.io.InputStreamReader;
 8 | import java.util.Iterator;
 9 | import java.util.LinkedList;
10 | 
11 | import rating.RatingReader;
12 | import rating.RatingRecord;
13 | 
14 | public class ListenReader extends RatingReader{
15 | 
16 | 	LinkedList<RatingRecord> records;
17 | 	Iterator<RatingRecord> iter;
18 | 	BufferedReader br;
19 | 	public ListenReader(String filePath) throws IOException
20 | 	{
21 | 		records = new LinkedList<RatingRecord>();
22 | 		br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(filePath))));
23 | 		String line;
24 | 		while(true)
25 | 		{
26 | 			line=br.readLine();
27 | 			if(line==null) break;
28 | 			String[] fields=line.split(",");
29 | 			int u= Integer.parseInt(fields[0]);
30 | 			int i= Integer.parseInt(fields[1]);
31 | 			records.push(new RatingRecord(u,i,1));				
32 | 		}
33 | 		br.close();
34 | 		
35 | 	}
36 | 
37 | 	
38 | 
39 | 
40 | 	@Override
41 | 	public double getMinPref() {
42 | 		// TODO Auto-generated method stub
43 | 		return 1;
44 | 	}
45 | 
46 | 	@Override
47 | 	public double getMaxPref() {
48 | 		// TODO Auto-generated method stub
49 | 		return 1;
50 | 	}
51 | 
52 | 	@Override
53 | 	public boolean hasNext() {
54 | 		// TODO Auto-generated method stub
55 | 		return iter.hasNext();
56 | 	}
57 | 
58 | 	@Override
59 | 	public RatingRecord getNext() {
60 | 		// TODO Auto-generated method stub
61 | 		return iter.next();
62 | 	}
63 | 
64 | 	@Override
65 | 	public void reset() {
66 | 		// TODO Auto-generated method stub
67 | 		iter = records.iterator();
68 | 	}
69 | 	
70 | 	//以下两个方法是无效方法
71 | 	@Override
72 | 	public int getUserNum() {
73 | 		// TODO Auto-generated method stub
74 | 		return 0;
75 | 	}
76 | 
77 | 	@Override
78 | 	public int getItemNum() {
79 | 		// TODO Auto-generated method stub
80 | 		return 0;
81 | 	}
82 | 
83 | }
84 | 


--------------------------------------------------------------------------------
/src/svd/MovieLensDataReader.java:
--------------------------------------------------------------------------------
 1 | package svd;
 2 | 
 3 | import java.io.BufferedReader;
 4 | import java.io.File;
 5 | import java.io.FileInputStream;
 6 | import java.io.IOException;
 7 | import java.io.InputStreamReader;
 8 | import java.util.Iterator;
 9 | import java.util.LinkedList;
10 | 
11 | import rating.RatingReader;
12 | import rating.RatingRecord;
13 | 
14 | public class MovieLensDataReader extends RatingReader{
15 | 	
16 | 	
17 | 	LinkedList<RatingRecord> records;
18 | 	Iterator<RatingRecord> iter;
19 | 	BufferedReader br;
20 | 	int maxUser;
21 | 	int maxItem;
22 | 	double minPref;
23 | 	double maxPref;
24 | 	
25 | 	public MovieLensDataReader(String filePath) throws IOException
26 | 	{
27 | 		minPref = Double.MAX_VALUE;
28 | 		maxPref = Double.MIN_VALUE;
29 | 		
30 | 		maxUser=-1;
31 | 		maxItem=-1;
32 | 		records = new LinkedList<RatingRecord>();	
33 | 		
34 | 		br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(filePath))));
35 | 		String line;
36 | 		while(true)
37 | 		{
38 | 			line=br.readLine();
39 | 			if(line==null) break;
40 | 			String[] fields=line.split("\t");
41 | 			int u= Integer.parseInt(fields[0]) -1;//MovieLens数据集的id从1开始
42 | 			int i= Integer.parseInt(fields[1]) -1;
43 | 			double p= Double.parseDouble(fields[2]);
44 | 			records.push(new RatingRecord(u,i,p));	
45 | 			
46 | 			maxUser = maxUser<u?u:maxUser;
47 | 			maxItem = maxItem<i?i:maxItem;
48 | 			minPref = minPref<p?minPref:p;
49 | 			maxPref = maxPref<p?p:maxPref;
50 | 			
51 | 			
52 | 		}
53 | 		br.close();
54 | 		iter = records.iterator();
55 | 	}
56 | 	
57 | 
58 | 	
59 | 	public  double getMinPref()
60 | 	{
61 | 		return minPref;
62 | 	}
63 | 	
64 | 	public  double getMaxPref()
65 | 	{
66 | 		return maxPref;
67 | 	}
68 | 	
69 | 	
70 | 	public int getUserNum()
71 | 	{
72 | 		return maxUser+1;
73 | 	}
74 | 	
75 | 	public int getItemNum()
76 | 	{
77 | 		return maxItem+1;
78 | 	}
79 | 	
80 | 	public boolean hasNext()
81 | 	{
82 | 		return iter.hasNext();
83 | 	}
84 | 	
85 | 	public RatingRecord getNext()
86 | 	{
87 | 		return iter.next();
88 | 	}
89 | 	
90 | 	public void reset()
91 | 	{
92 | 		iter = records.iterator();
93 | 	}
94 | 	
95 | 	
96 | }
97 | 


--------------------------------------------------------------------------------
/src/svd/sgd/Trainer.java:
--------------------------------------------------------------------------------
 1 | package svd.sgd;
 2 | 
 3 | import java.io.IOException;
 4 | 
 5 | import rating.RatingReader;
 6 | import rating.RatingRecord;
 7 | import svd.MovieLensDataReader;
 8 | 
 9 | public class Trainer {	
10 | 	
11 | 	
12 | 	
13 | 	Model model;
14 | 	RatingReader trainData;
15 | 	String trainFile;
16 | 	
17 | 	public Trainer(String trainFilePath) throws IOException
18 | 	{
19 | 		trainFile = trainFilePath;
20 | 		trainData = new MovieLensDataReader(trainFile);
21 | 		int userNum = trainData.getUserNum();
22 | 		int itemNum = trainData.getItemNum();
23 | 		double minPref=trainData.getMinPref();
24 | 		double maxPref=trainData.getMaxPref();
25 | 		
26 | 		int rank =150;//增大潜在隐义因子数量,收敛速度较快,但程序运行速度较慢
27 | 		model= new Model(userNum,itemNum,rank,minPref,maxPref);
28 | 		
29 | 		
30 | 	}
31 | 	
32 | 	public void train(int maxIter)
33 | 	{
34 | 		int count=0;
35 | 		double lastRmse = Double.MAX_VALUE;
36 | 		while(true)
37 | 		{		
38 | 			System.out.printf("第%d次迭代:",count++);
39 | 			double loss=0.0;
40 | 			int n=0;
41 | 			while(trainData.hasNext())
42 | 			{
43 | 				RatingRecord rating = trainData.getNext();
44 | 				int u=rating.getUser();
45 | 				int i=rating.getItem();
46 | 				double p=rating.getPref();
47 | 							
48 | 				//更新用户u的特征向量			
49 | 				//更新物品i的特征向量
50 | 				loss+= model.update(u,i,p);
51 | 				n++;							
52 | 			}
53 | 			
54 | 			double rmse=Math.sqrt(loss/n);
55 | 			System.out.println("rmse:"+rmse);
56 | 			
57 | 			//判断一下,如果rmse开始增大,则停止迭代
58 | 			if(rmse>lastRmse) break;
59 | 			if(count>maxIter) break;
60 | 			
61 | 			lastRmse = rmse;			
62 | 			trainData.reset();						
63 | 		}
64 | 		
65 | 	}
66 | 	
67 | 	public void test(String testFile) throws IOException
68 | 	{
69 | 		RatingReader testData = new MovieLensDataReader(testFile);
70 | 		double sum=0.0;
71 | 		int n=0;
72 | 		while(testData.hasNext())
73 | 		{
74 | 			RatingRecord rating = testData.getNext();
75 | 			int u=rating.getUser();
76 | 			int i=rating.getItem();
77 | 			double p=rating.getPref();
78 | 			double predicted = model.predict(u, i);
79 | 			double error=(p-predicted)*(p-predicted);
80 | 			sum+=error;	
81 | 			n++;
82 | 		}
83 | 		double rmse=Math.sqrt(sum/n);
84 | 		System.out.println("test rmse:"+rmse);
85 | 		
86 | 	}
87 | 	
88 | 	public static void main(String[] args) throws IOException {
89 | 		// TODO Auto-generated method stub
90 | 		
91 | 		Trainer trainer = new Trainer("dataset/ua.base");
92 | 		trainer.train(1000);
93 | 		trainer.test("dataset/ua.test");
94 | 
95 | 	}
96 | 
97 | }
98 | 


--------------------------------------------------------------------------------
/src/svd/bgd/Trainer.java:
--------------------------------------------------------------------------------
  1 | package svd.bgd;
  2 | 
  3 | import java.io.IOException;
  4 | 
  5 | import rating.RatingReader;
  6 | import rating.RatingRecord;
  7 | import svd.MovieLensDataReader;
  8 | 
  9 | 
 10 | 
 11 | public class Trainer {
 12 | 
 13 | 	Model model;
 14 | 	RatingReader trainData;
 15 | 	String trainFile;
 16 | 	
 17 | 	
 18 | 	int userNum;
 19 | 	int itemNum;
 20 | 	
 21 | 	public Trainer(String trainFilePath) throws IOException
 22 | 	{
 23 | 		trainFile = trainFilePath;
 24 | 		trainData = new MovieLensDataReader(trainFile);
 25 | 		userNum = trainData.getUserNum();
 26 | 		itemNum = trainData.getItemNum();
 27 | 		double minPref=trainData.getMinPref();
 28 | 		double maxPref=trainData.getMaxPref();
 29 | 		
 30 | 		int rank =150;
 31 | 		
 32 | 		double[][] ratingMatrix = new double[userNum][itemNum];
 33 | 		
 34 | 		for(int u=0;u<userNum;u++)
 35 | 		{
 36 | 			for(int i=0;i<itemNum;i++)
 37 | 			{
 38 | 				ratingMatrix[u][i]=0;
 39 | 			}
 40 | 		}
 41 | 		
 42 | 		while(trainData.hasNext())
 43 | 		{
 44 | 			RatingRecord rating = trainData.getNext();
 45 | 			int u=rating.getUser();
 46 | 			int i=rating.getItem();
 47 | 			double p=rating.getPref();
 48 | 			ratingMatrix[u][i]=p;			
 49 | 		}
 50 | 		
 51 | 		model= new Model(userNum,itemNum,rank,minPref,maxPref,ratingMatrix);
 52 | 		
 53 | 
 54 | 				
 55 | 	}
 56 | 	
 57 | 	public void train(int maxIter)
 58 | 	{
 59 | 		double lastRmse = Double.MAX_VALUE;
 60 | 		for(int iter=0;iter<maxIter;iter++)
 61 | 		{		
 62 | 			
 63 | 			double rmse=model.update();	
 64 | 			if(lastRmse<rmse) break;				
 65 | 			lastRmse= rmse;
 66 | 			System.out.println("iter:"+iter+", rmse:"+rmse);
 67 | 		}
 68 | 			
 69 | 	}
 70 | 	
 71 | 	public void test(String testFile) throws IOException
 72 | 	{
 73 | 		RatingReader testData = new MovieLensDataReader(testFile);
 74 | 		double sum=0.0;
 75 | 		int n=0;
 76 | 		while(testData.hasNext())
 77 | 		{
 78 | 			RatingRecord rating = testData.getNext();
 79 | 			int u=rating.getUser();
 80 | 			int i=rating.getItem();
 81 | 			double p=rating.getPref();
 82 | 			double predicted = model.predict(u, i);
 83 | 			double error=(p-predicted)*(p-predicted);
 84 | 			sum+=error;	
 85 | 			n++;
 86 | 		}
 87 | 		double rmse=Math.sqrt(sum/n);
 88 | 		System.out.println("test rmse:"+rmse);
 89 | 		
 90 | 	}
 91 | 	
 92 | 	public static void main(String[] args) throws IOException {
 93 | 		// TODO Auto-generated method stub
 94 | 		Trainer trainer = new Trainer("dataset/ua.base");
 95 | 		trainer.train(1000);
 96 | 		trainer.test("dataset/ua.test");
 97 | 	}
 98 | 
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/svd/bgd/Model.java:
--------------------------------------------------------------------------------
  1 | package svd.bgd;
  2 | 
  3 | import svd.SvdModel;
  4 | 
  5 | public class Model extends SvdModel{
  6 | 	
  7 | 	
  8 | 	double[][] userdiffs;
  9 | 	double[][] itemdiffs;
 10 | 	double[][] ratingMatrix;
 11 | 	
 12 | 	public Model(int un, int in, int r, double minPref, double maxPref,double[][] ratings) {
 13 | 		super(un, in, r, minPref, maxPref);
 14 | 		
 15 | 		userdiffs = new double[userNum][rank];
 16 | 		itemdiffs = new double[itemNum][rank];
 17 | 		ratingMatrix= ratings;
 18 | 
 19 | 	}
 20 | 	
 21 | 	public void clearDiffs()
 22 | 	{
 23 | 		for(int u=0;u<userNum;u++)
 24 | 		{
 25 | 			for(int r=0;r<rank;r++)
 26 | 			{
 27 | 				userdiffs[u][r]=0;//-k*userVectors[u][r];
 28 | 			}			
 29 | 		}
 30 | 		
 31 | 		for(int i=0;i<itemNum;i++)
 32 | 		{
 33 | 			for(int r=0;r<rank;r++)
 34 | 			{
 35 | 				itemdiffs[i][r]=0;//-k*itemVectors[i][r];
 36 | 			}			
 37 | 		}
 38 | 		
 39 | 	}
 40 | 	
 41 | 	public double update()
 42 | 	{
 43 | 		clearDiffs();
 44 | 		double sum=0;
 45 | 		int count=0;
 46 | 		//user特征和item特征偏导数
 47 | 		for(int u=0;u<userNum;u++)
 48 | 		{
 49 | 				for(int i=0;i<itemNum;i++)
 50 | 				{
 51 | 					
 52 | 					if(ratingMatrix[u][i]==0)
 53 | 					{
 54 | 					   //do nothing
 55 | 						/*
 56 | 						for(int r=0;r<rank;r++)
 57 | 						{
 58 | 							userdiffs[u][r]+= 0-k*userVectors[u][r];
 59 | 							itemdiffs[i][r]+= 0-k*itemVectors[i][r];
 60 | 						}	
 61 | 						*/
 62 | 						//看论文这部分是需要的,但是这样子实验结果不对.去掉这部分反而对了
 63 | 						//论文后面有改进,明确了对未知评分不作处理.可以看公式16
 64 | 						//没有绝对的对错,只有优劣之分
 65 | 					}
 66 | 					else
 67 | 					{
 68 | 						double predicted=predict(u,i);
 69 | 						double error=ratingMatrix[u][i]-predicted;
 70 | 						sum=sum+error*error;
 71 | 						count++;
 72 | 						for(int r=0;r<rank;r++)
 73 | 						{
 74 | 							userdiffs[u][r]+= (error*itemVectors[i][r]-k*userVectors[u][r]);//
 75 | 							itemdiffs[i][r]+= (error*userVectors[u][r]-k*itemVectors[i][r]);//
 76 | 						}	
 77 | 						//map-reduce实现思路,先对每个user-item作map处理,算出部分偏导数,然后user作为key得到user的偏导数,item作为key得到item的偏导数
 78 | 					}
 79 | 				}			
 80 | 		}
 81 | 				
 82 | 		//更新特征
 83 | 		for(int u=0;u<userNum;u++)
 84 | 		{		
 85 | 			for(int r=0;r<rank;r++)
 86 | 			{
 87 | 				userVectors[u][r]=userVectors[u][r]+userdiffs[u][r]*alpha;
 88 | 			}			
 89 | 		}
 90 | 		
 91 | 		//更新特征
 92 | 		for(int i=0;i<itemNum;i++)
 93 | 		{
 94 | 			for(int r=0;r<rank;r++)
 95 | 			{
 96 | 				itemVectors[i][r] = itemVectors[i][r]+itemdiffs[i][r]*alpha;
 97 | 			}
 98 | 		}
 99 | 		
100 | 		double rmse=Math.sqrt(sum/count);
101 | 		return rmse;
102 | 	}
103 | 	
104 | 
105 | 
106 | }
107 | 


--------------------------------------------------------------------------------
/src/personalrank/IDManager.java:
--------------------------------------------------------------------------------
  1 | package personalrank;
  2 | 
  3 | import java.util.HashMap;
  4 | import java.util.Iterator;
  5 | import java.util.Map.Entry;
  6 | 
  7 | import rating.RatingRecord;
  8 | 
  9 | public class IDManager {
 10 | 
 11 | 	
 12 | 	
 13 | 	private HashMap<Integer,Integer> user2Internal;
 14 | 	private int userMaxIternalID;
 15 | 	private HashMap<Integer,Integer> item2Internal;
 16 | 	private int itemMaxIternalID;
 17 | 	private int[] internalMapping;
 18 | 	
 19 | 	public int[] getInternalMapping()
 20 | 	{
 21 | 		return internalMapping;
 22 | 	}
 23 | 	
 24 | 	public HashMap<Integer,Integer> getAllUser()
 25 | 	{
 26 | 		return user2Internal;
 27 | 	}
 28 | 	
 29 | 	public int totalUserItem()
 30 | 	{
 31 | 		return itemMaxIternalID+1;
 32 | 	}
 33 | 	
 34 | 	public int getUserMaxIternalID()
 35 | 	{
 36 | 		return userMaxIternalID;
 37 | 	}
 38 | 	
 39 | 	public boolean isUser(int internalID)
 40 | 	{
 41 | 		return internalID<=userMaxIternalID;
 42 | 	}
 43 | 	
 44 | 	public boolean isItem(int internalID)
 45 | 	{
 46 | 		return internalID>userMaxIternalID;
 47 | 	}
 48 | 	
 49 | 	public int getOriginID(int internalID)
 50 | 	{
 51 | 		if(internalID<internalMapping.length)
 52 | 			return internalMapping[internalID];
 53 | 		return -1;
 54 | 	}
 55 | 	
 56 | 	public int getUserInternalID(int user)
 57 | 	{
 58 | 		if(user2Internal.containsKey(user))
 59 | 			return user2Internal.get(user);
 60 | 		return -1;
 61 | 	}
 62 | 	
 63 | 	public int getItemInternalID(int item)
 64 | 	{
 65 | 		if(item2Internal.containsKey(item))
 66 | 			return item2Internal.get(item);
 67 | 		return -1;
 68 | 	}
 69 | 	
 70 | 	public IDManager(ListenReader reader)
 71 | 	{
 72 | 		user2Internal = new HashMap<Integer,Integer> ();
 73 | 		item2Internal = new HashMap<Integer,Integer> ();
 74 | 		
 75 | 		reader.reset();
 76 | 		int count=0;
 77 | 		while(reader.hasNext())
 78 | 		{
 79 | 			RatingRecord record = reader.getNext();
 80 | 			int u = record.getUser();
 81 | 			if(!user2Internal.containsKey(u))
 82 | 			{
 83 | 				user2Internal.put(u, count++);
 84 | 			}
 85 | 		}
 86 | 		userMaxIternalID=count-1;
 87 | 		
 88 | 		reader.reset();
 89 | 		while(reader.hasNext())
 90 | 		{
 91 | 			RatingRecord record = reader.getNext();
 92 | 			int i = record.getItem();
 93 | 			if(!item2Internal.containsKey(i))
 94 | 			{
 95 | 				item2Internal.put(i, count++);
 96 | 			}
 97 | 		}
 98 | 		
 99 | 		assert(user2Internal.size()+item2Internal.size()==count);
100 | 		itemMaxIternalID = count-1;
101 | 		
102 | 		internalMapping = new int[count];
103 | 		
104 | 		Iterator<Entry<Integer, Integer>>  iter = user2Internal.entrySet().iterator();
105 | 		Entry<Integer, Integer> entry;
106 | 		while(iter.hasNext())
107 | 		{
108 | 			entry = iter.next();
109 | 			internalMapping[entry.getValue()]=entry.getKey();
110 | 		}
111 | 		
112 | 		iter = item2Internal.entrySet().iterator();
113 | 		while(iter.hasNext())
114 | 		{
115 | 			entry = iter.next();
116 | 			internalMapping[entry.getValue()]=entry.getKey();
117 | 		}
118 | 		
119 | 		
120 | 	}
121 | 	
122 | 
123 | 
124 | }
125 | 


--------------------------------------------------------------------------------
/src/personalrank/Graph.java:
--------------------------------------------------------------------------------
  1 | package personalrank;
  2 | 
  3 | import java.io.IOException;
  4 | import java.util.ArrayList;
  5 | import java.util.Collections;
  6 | import java.util.HashMap;
  7 | import java.util.Iterator;
  8 | import java.util.Map.Entry;
  9 | 
 10 | import rating.RatingRecord;
 11 | 
 12 | public class Graph {
 13 | 
 14 | 
 15 | 	
 16 | 	ArrayList<HashMap<Integer,Float> > graph;
 17 | 	
 18 | 	IDManager idManager;
 19 | 	public Graph(ListenReader reader)
 20 | 	{
 21 | 		idManager = new IDManager(reader);
 22 | 		
 23 | 		int userItemNum = idManager.totalUserItem();
 24 | 		
 25 | 		graph = new ArrayList<HashMap<Integer,Float> >();
 26 | 		for(int i=0;i<userItemNum;i++)
 27 | 		{
 28 | 			graph.add(new HashMap<Integer,Float>());//申请空间
 29 | 		}
 30 | 		
 31 | 		reader.reset();
 32 | 		RatingRecord record;
 33 | 		int u;
 34 | 		int i;
 35 | 		float p;
 36 | 		while(reader.hasNext())
 37 | 		{
 38 | 			record = reader.getNext();
 39 | 			u = idManager.getUserInternalID(record.getUser());
 40 | 			i = idManager.getItemInternalID(record.getItem());
 41 | 			p = (float) record.getPref();
 42 | 			graph.get(u).put(i, p);
 43 | 			graph.get(i).put(u, p);			
 44 | 		}
 45 | 		
 46 | 	}
 47 | 	
 48 | 	
 49 | 	public void recommend(int start,int end)//为了多线程调用
 50 | 	{
 51 | 		float alpha = (float) 0.8;
 52 | 		int maxIters = 20;
 53 | 		int k = 100;
 54 | 		
 55 | 		int[] internalMapping = idManager.getInternalMapping();
 56 | 		int userMaxIternalID = idManager.getUserMaxIternalID();
 57 | 		
 58 | 		if(start>userMaxIternalID || end>userMaxIternalID) return;
 59 | 		int originID;
 60 | 		int internalID;
 61 | 		for(int i=start;i<end;i++)
 62 | 		{
 63 | 			originID = internalMapping[i];
 64 | 			internalID = i;			
 65 | 			ArrayList<Item> sorted = personalRank(internalID, alpha, maxIters);
 66 | 			
 67 | 			for(int j=0;j<k;j++)
 68 | 			{
 69 | 				Item item = sorted.get(j);
 70 | 				int itemID = idManager.getOriginID(item.id);
 71 | 				float w = item.weight;
 72 | 			}
 73 | 		}
 74 | 		
 75 | 		
 76 | 		
 77 | 	}
 78 | 	
 79 | 	public void recommend()
 80 | 	{
 81 | 		HashMap<Integer,Integer> user2Internal = idManager.getAllUser();
 82 | 		
 83 | 		System.out.println(user2Internal.size());//10449
 84 | 		//已推荐10400位
 85 | 	//	总耗时为：2544秒
 86 | 		
 87 | 		float alpha = (float) 0.8;
 88 | 		int maxIters = 20;
 89 | 		int k = 100;
 90 | 		
 91 | 		Iterator<Entry<Integer, Integer>> iter = user2Internal.entrySet().iterator();
 92 | 		int originID;
 93 | 		int internalID;
 94 | 		Entry<Integer, Integer> entry;
 95 | 		long startMili=System.currentTimeMillis();// 当前时间对应的毫秒数
 96 | 		int count=0;
 97 | 		while(iter.hasNext())
 98 | 		{
 99 | 			entry = iter.next();
100 | 			originID = entry.getKey();
101 | 			internalID = entry.getValue();			
102 | 			ArrayList<Item> sorted = personalRank(internalID, alpha, maxIters);
103 | 			
104 | 			for(int i=0;i<k;i++)
105 | 			{
106 | 				Item item = sorted.get(i);
107 | 				int itemID = idManager.getOriginID(item.id);
108 | 				float w = item.weight;
109 | 				//System.out.println(itemID+":"+w);
110 | 			}
111 | 			
112 | 			count++;
113 | 			
114 | 			if(count%100==0)
115 | 			{
116 | 				long endMili=System.currentTimeMillis();	
117 | 				System.out.println("已推荐"+count+"位");
118 | 				System.out.println("总耗时为："+(endMili-startMili)/1000+"秒");
119 | 			}
120 | 
121 | 			
122 | 		}
123 | 		
124 | 		
125 | 		
126 | 	}
127 | 	
128 | 	
129 | 	public void personalRank(int userOriginID)
130 | 	{
131 | 		int userInternalID = idManager.getUserInternalID(userOriginID);
132 | 		float alpha = (float) 0.8;
133 | 		ArrayList<Item> sorted = personalRank(userInternalID, alpha, 20);
134 | 		
135 | 		int k = 100;
136 | 		for(int i=0;i<k;i++)
137 | 		{
138 | 			Item item = sorted.get(i);
139 | 			int itemID = idManager.getOriginID(item.id);
140 | 			float w = item.weight;
141 | 			System.out.println(itemID+":"+w);
142 | 		}
143 | 		
144 | 	}
145 | 	
146 | 	public ArrayList<Item> personalRank(int userInternalID,float alpha,int maxIters)
147 | 	{
148 | 		int userItemNum = idManager.totalUserItem();
149 | 		float[] rank = new float[userItemNum]; 
150 | 		for(int i=0;i<userItemNum;i++)
151 | 		{
152 | 			rank[i]=0;
153 | 		}
154 | 		rank[userInternalID]=1;
155 | 		
156 | 		float[] rankCache;
157 | 		HashMap<Integer, Float>  edges;
158 | 		Iterator<Entry<Integer, Float>> edgeIter;
159 | 		Entry<Integer, Float> edge;
160 | 		int j;
161 | 		for(int iter=0;iter<maxIters;iter++)
162 | 		{		
163 | 			rankCache=new float[userItemNum];
164 | 			for(int i=0;i<userItemNum;i++)
165 | 			{
166 | 				rankCache[i]=0;
167 | 			}
168 | 			
169 | 			for(int i=0;i<graph.size();i++)
170 | 			{
171 | 				edges = graph.get(i);
172 | 				edgeIter = edges.entrySet().iterator();
173 | 				while(edgeIter.hasNext())
174 | 				{
175 | 					edge = edgeIter.next();
176 | 					j = edge.getKey();
177 | 					rankCache[j] += alpha*rank[i]/(edges.size()*1.0);
178 | 					if(j==userInternalID)
179 | 					{
180 | 						rankCache[j] += 1.0-alpha;
181 | 					}
182 | 					
183 | 				}
184 | 				
185 | 			}
186 | 			
187 | 			rank = rankCache;
188 | 			
189 | 		}
190 | 		
191 | 		ArrayList<Item> candidates = new ArrayList<Item>();
192 | 		//过滤+排序
193 | 		for(int i=idManager.getUserMaxIternalID()+1;i<rank.length;i++)
194 | 		{
195 | 			candidates.add(new Item(i,rank[i]));
196 | 		}
197 | 		
198 | 		Collections.sort(candidates);
199 | 		
200 | 		return candidates;
201 | 	
202 | 		
203 | 	}
204 | 	
205 | 	
206 | 	public static void main(String[] args) throws IOException {
207 | 		// TODO Auto-generated method stub
208 | 		
209 | 		ListenReader reader = new ListenReader("dataset/user_music.dat");
210 | 		Graph graph = new Graph(reader);
211 | 		
212 | 		
213 | 		
214 | 		//graph.recommend();//大概1秒4个,也就是0.25秒一个
215 | 		
216 | 		long startMili=System.currentTimeMillis();// 当前时间对应的毫秒数
217 | 		for(int i=0;i<100;i++)
218 | 		{
219 | 			graph.personalRank(79057533);
220 | 		}
221 | 		
222 | 		long endMili=System.currentTimeMillis();	
223 | 		System.out.println("总耗时为："+(endMili-startMili)+"毫秒");
224 | 
225 | 
226 | 	}
227 | 
228 | }
229 | 


--------------------------------------------------------------------------------