java和python实现一个加权SlopeOne推荐算法

一.加权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());
         }
     }
 }