一.加权SlopeOne算法公式：
(1).求得所有item之间的评分偏差
上式中分子部分为项目j与项目i的偏差和，分母部分为所有同时对项目j与项目i评分的用户数
(2).加权预测评分
项目j与项目i
上式中表示用户u对项目j的评分预测，分子为项目j对项目i的偏差加上用户对项目i的评分，cji表示同时对项目j与项目i评分的用户数
二.python实现
#!/usr/bin/python
# -*- coding: utf-8 -*- user_data = {"小明": {"张学友": 4, "周杰伦": 3, "刘德华": 4},
"小海": {"张学友": 5, "周杰伦": 2},
"李梅": {"周杰伦": 3.5, "刘德华": 4},
"李磊": {"张学友": 5, "刘德华": 3}} class recommender: def __init__(self,data):
self.frequency={}
self.deviation={}
self.data=data #计算所有item之间评分偏差
def computeDeviation(self):
for ratings in self.data.values():
for item,rating in ratings.items():
self.frequency.setdefault(item,{})
self.deviation.setdefault(item,{})
for item2,rating2 in ratings.items():
if item!=item2:
self.frequency[item].setdefault(item2,0)
self.deviation[item].setdefault(item2,0.0)
self.frequency[item][item2]+=1#两个项目的用户数
self.deviation[item][item2]+=(rating-rating2)#累加两个评分差值
for item,ratings in self.deviation.items():
for item2 in ratings:
ratings[item2]/=self.frequency[item][item2] #评分预测
def predictRating(self,userRatings,k):
recommendations={}
frequencies={}
for item,rating in userRatings.items():
for diffItem,diffRating in self.deviation.items():
if diffItem not in userRatings and item in self.deviation[diffItem]:
fre=self.frequency[diffItem][item]
recommendations.setdefault(diffItem,0.0)
frequencies.setdefault(diffItem,0)
#分子部分
recommendations[diffItem]+=(diffRating[item]+rating)*fre
#分母部分
frequencies[diffItem]+=fre
recommendations=[(k,v/frequencies[k]) for (k,v) in recommendations.items()]
#排序返回前k个
recommendations.sort(key=lambda a_tuple:a_tuple[1],reverse=True)
return recommendations[:k] if __name__=='__main__':
r=recommender(user_data)
r.computeDeviation()
u=user_data['李磊']
print(r.predictRating(u,5))
三.java实现
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Collections; /**
* Created by on 2016/12/8.ShiYan
* 一.计算所有物品对的偏差
* 二.利用偏差进行预测
*/
public class SlopeOne {
Map<String,Map<String,Integer>> frequency=null;
Map<String,Map<String,Double>> deviation=null;
Map<String,Map<String,Integer>> user_rating=null; public SlopeOne( Map<String,Map<String,Integer>> user_rating){
frequency=new HashMap<String,Map<String,Integer>>();
deviation=new HashMap<String,Map<String,Double>>();
this.user_rating=user_rating;
} /**
* 所有有item间的评分偏差
*/
public void computeDeviation(){
for(Map.Entry<String,Map<String,Integer>> ratingsEntry:user_rating.entrySet()){
for(Map.Entry<String,Integer> ratingEntry:ratingsEntry.getValue().entrySet()){
String item=ratingEntry.getKey();
int rating=ratingEntry.getValue();
Map<String,Integer> itemFrequency=null;
if(!frequency.containsKey(item)){
itemFrequency=new HashMap<String, Integer>();
frequency.put(item,itemFrequency);
}else{
itemFrequency=frequency.get(item);
} Map<String,Double> itemDeviation=null;
if(!deviation.containsKey(item)){
itemDeviation=new HashMap<String, Double>();
deviation.put(item,itemDeviation);
}else{
itemDeviation=deviation.get(item);
} for(Map.Entry<String,Integer> ratingEntry2:ratingsEntry.getValue().entrySet()){
String item2=ratingEntry2.getKey();
int rating2=ratingEntry2.getValue();
if(!item.equals(item2)){
//两个项目的用户数
itemFrequency.put(item2,itemFrequency.containsKey(item2)?itemFrequency.get(item2)+1:0);
//两个项目的评分偏差，累加
itemDeviation.put(item2,itemDeviation.containsKey(item2)?itemDeviation.get(item2)+(rating-rating2):0.0);
}
}
}
} for(Map.Entry<String,Map<String,Double>> itemsDeviation:deviation.entrySet()){
String item=itemsDeviation.getKey();
Map<String,Double> itemDev=itemsDeviation.getValue();
Map<String,Integer> itemFre=frequency.get(item);
for(String itemName:itemDev.keySet()){
itemDev.put(itemName,itemDev.get(itemName)/itemFre.get(itemName));
}
}
} /**
* 评分预测
* @param userRating 目标用户的评分
* @param k 返回前k个
* @return
*/
public List<Map.Entry<String,Double>> predictRating(Map<String,Integer> userRating,int k){
Map<String,Double> recommendations=new HashMap<String,Double>();
Map<String,Integer> frequencies=new HashMap<String, Integer>();
for(Map.Entry<String,Integer> userEntry:userRating.entrySet()){
String userItem=userEntry.getKey();
double rating=userEntry.getValue();
for(Map.Entry<String,Map<String,Double>> deviationEntry:deviation.entrySet()){
String item=deviationEntry.getKey();
Map<String,Double> itemDeviation=deviationEntry.getValue();
Map<String,Integer> itemFrequency=frequency.get(item);
if(!userRating.containsKey(item) && itemDeviation.containsKey(userItem)){
int fre=itemFrequency.get(userItem);
if(!recommendations.containsKey(item))
recommendations.put(item,0.0);
if(!frequencies.containsKey(item))
frequencies.put(item,0);
//分子部分
recommendations.put(item,recommendations.get(item)+(itemDeviation.get(userItem)+rating)*fre);
//分母部分
frequencies.put(item,frequencies.get(item)+fre);
}
}
}
for(Map.Entry<String,Double> recoEntry:recommendations.entrySet()){
String key=recoEntry.getKey();
double value=recoEntry.getValue()/frequencies.get(key);
recommendations.put(key,value);
}
//排序，这里还可以使用优先队列返回top_k
List<Map.Entry<String,Double>> list_map=new ArrayList<Map.Entry<String,Double>>(recommendations.entrySet());
Collections.sort(list_map,new Comparator<Map.Entry<String,Double>>(){
@Override
public int compare(Map.Entry<String, Double> o1, Map.Entry<String, Double> o2) {
if(o2.getValue()>o1.getValue())
return 1;
else if(o2.getValue()<o1.getValue())
return -1;
else
return 0;
}
}
);
List<Map.Entry<String,Double>> top_k=new ArrayList<Map.Entry<String, Double>>();
if(list_map.size()<k) k=list_map.size();
for(int i=0;i<k;i++){
top_k.add(list_map.get(i));
}
return top_k;
} public static void main(String[] args){
Map<String,Map<String,Integer>> userRatings=new HashMap<String, Map<String, Integer>>();
Map<String,Integer> xiMingRating=new HashMap<String, Integer>();
xiMingRating.put("张学友",4);
xiMingRating.put("周杰伦",3);
xiMingRating.put("刘德华",4);
Map<String,Integer> xiHaiRating=new HashMap<String, Integer>();
xiHaiRating.put("张学友",5);
xiHaiRating.put("周杰伦",2);
Map<String,Integer> liMeiRating=new HashMap<String, Integer>();
liMeiRating.put("周杰伦",3);
liMeiRating.put( "刘德华",4);
Map<String,Integer> liLeiRating=new HashMap<String, Integer>();
liLeiRating.put("张学友",5);
liLeiRating.put("刘德华",3);
userRatings.put("xiMing",xiMingRating);
userRatings.put("xiHai",xiHaiRating);
userRatings.put("liMei", liMeiRating);
userRatings.put("liLei",liLeiRating); SlopeOne slopOne=new SlopeOne(userRatings);
slopOne.computeDeviation();
List<Map.Entry<String,Double>> top_k=slopOne.predictRating(userRatings.get("liLei"),5);
for(Map.Entry<String,Double> item:top_k){
System.out.println(item.getKey()+" "+item.getValue());
}
}
}