前言

一本比較老的書，偏實用，正好打算入手python機器學習，實現一遍程式碼。

關於協作型過濾

介紹他的一個引用場景：已有使用者對自己感興趣的電影評分的情況下，怎麼合理的為使用者推薦新電影？或者一個新使用者在瀏覽電影時，推薦其他相關的電影？
協作性過濾 的思想處理上述問題的邏輯是這樣的：

• 兩個使用者對共同感興趣的電影評分都相近，顯然可以互相推薦對方未看過的電影。
• 如果兩部電影使用者對它們的評分很接近，顯然這兩部電影就更值得同時出現。

具體來說：

1. 相關性指標：計算兩個使用者對共同感興趣的電影的評分相關係數來衡量兩個使用者之間的相關程度，可以用皮爾遜相關係數，距離倒數等。
2. 相關係數加權：為A推薦未看過的電影d時，如果B和C同時對電影d打過分，則以B、C與A的評分相關係數來加權各自對電影d的打分，作為A喜歡電影d的程度的預測。
3. 基於物品的過濾：推薦與使用者喜歡的電影d相關程度高的電影，意義在於不用計算該使用者與所有其他使用者的評分相關程度。

資料集

使用者電影評分資料 MovieLens
zip壓縮包
——movies.csv：電影資訊表，主要是電影id和電影標題
——ratings.csv：打分表，主要使用者id，電影id和評分

程式碼：

__author__ = "xqx"
"""
    新建recommendations.py，下載資料集解壓到本地
"""
 

import recommendations as rd
import json

# 匯入使用者電影評分資料
prefs = rd.loadMovieLens(path = r'E:\桌面space\space\學習ing\python學習\集體智慧程式設計\提供推薦\data\ml-latest-small')

if input("是否重新開始計算物品")=='y':
    #計算物品相似度矩陣並儲存
    print("開始計算物品相似度字典.....")
    itemMatch = rd.calculateSimilarItems(prefs,10)
    print("計算完成!"
 
)
    with open('itemMatch.json','w') as outfile:
        json.dump(itemMatch,outfile,ensure_ascii=False)
        outfile.write('\n')

else:
    #匯入物品相似度矩陣
    f=open("itemMatch.json","r")  
    for line in f:  
        itemMatch=json.loads(line) 
    f.close()

userid = '87'

print( "為使用者%s推薦的電影如下："%userid )

recommends = rd.getRecommendedItems(prefs,itemMatch,userid)

for i in range(len(recommends)):
    print('%.3f\t%s'%(recommends[i][0],recommends[i][1]))

結果

是否重新開始計算物品n
為使用者87推薦的電影如下：
5.000 xXx (2002)
5.000 loudQUIETloud: A Film About the Pixies (2006)
5.000 Zombieland (2009)
5.000 Zodiac (2007)
5.000 Zenon: Z3 (2004)
5.000 Zenon: The Zequel (2001)
5.000 Zenon: Girl of the 21st Century (1999)
5.000 Young People Fucking (a.k.a. YPF) (2007)
5.000 Yossi & Jagger (2002)
5.000 Wrong Cops (2013)
5.000 Wrong (2012)
5.000 Winnebago Man (2009)
5.000 Willie & Phil (1980)
5.000 Wild at Heart (1990)
5.000 Wild Zero (2000)
5.000 Where’s Marlowe? (1998)
5.000 What Happened Was… (1994)
4.667 Zulu (1964)

附件

recommendations.py

"""
資料集：姓名：電影：評分
"""
critics={'Lisa Rose': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5,
 'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5, 
 'The Night Listener': 3.0},
'Gene Seymour': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5, 
 'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0, 
 'You, Me and Dupree': 3.5}, 
'Michael Phillips': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.0,
 'Superman Returns': 3.5, 'The Night Listener': 4.0},
'Claudia Puig': {'Snakes on a Plane': 3.5, 'Just My Luck': 3.0,
 'The Night Listener': 4.5, 'Superman Returns': 4.0, 
 'You, Me and Dupree': 2.5},
'Mick LaSalle': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0, 
 'Just My Luck': 2.0, 'Superman Returns': 3.0, 'The Night Listener': 3.0,
 'You, Me and Dupree': 2.0}, 
'Jack Matthews': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,
 'The Night Listener': 3.0, 'Superman Returns': 5.0, 'You, Me and Dupree': 3.5},
'Toby': {'Snakes on a Plane':4.5,'You, Me and Dupree':1.0,'Superman Returns':4.0}}



from math import sqrt
"""
    通過兩個人對同一物品的評分來定義兩人的相似度
      內在邏輯是：兩個相似的人喜歡同一個東西，對電影的評分應該相似             
"""
# 返回兩個人基於距離的相似度評價
def sim_distance(prefs,person1,person2):
    """
    距離的倒數來定義形似度
    """
    # 得到共有屬性的列表
    si = {}

    # 計算所有差值的平方和
    sum_of_squres = 0

    for item in prefs[person1]:
        if item in prefs[person2]:
            si[item]=1
            sum_of_squres += pow(prefs[person1][item] - prefs[person2][item], 2)

    # 如果兩者沒有共同之處，則返回0
    if len(si)==0:return 0

    return 1/(1+sqrt(sum_of_squres))

# 返回p1和p2的皮爾遜相關係數
def sim_pearson(prefs, p1, p2):
    """
    相關係數             
    """
    # 得到雙方都曾評價過的物品列表
    si = {}
    for item in prefs[p1]:
        if item in prefs[p2]: si[item] = 1

    # 得到列表元素的個數
    n = len(si)

    # 如果沒有共同之處，返回1
    if n==0: return 0;

    # 對所有偏好求和
    sum1 = sum([prefs[p1][it] for it in si])
    sum2 = sum([prefs[p2][it] for it in si])

    # 求平方和
    sum1sq = sum([pow(prefs[p1][it],2) for it in si])
    sum2sq = sum([pow(prefs[p2][it],2) for it in si])

    # 求乘積之和
    psum = sum([prefs[p2][it]*prefs[p1][it] for it in si])

    # 計算皮爾遜相關係數
    num = psum-sum1*sum2/n
    den = sqrt((sum1sq - pow(sum1,2)/n)*(sum2sq - pow(sum2,2)/n))
    if den==0 :return 0

    return num/den

# 從反映偏好的字典中返回最匹配者
# 返回結果的個數和相似度函式均可最為可選引數
# 預設返回前5個，計算皮爾遜相關係數
def topMatches(prefs,person,n=5,similarity=sim_pearson):
    """
    返回與指定客戶的相似性最高的前n位
    """
    scores = [(similarity(prefs, person, other),other)
                  for other in prefs if other!=person]

    # 對列表進行排序
    scores.sort()
    scores.reverse()
    return scores[:n]

# 相似係數加權的影片打分值
def getRecommendations(prefs, person ,similarity=sim_pearson):
    """
    對客戶未看過的影片，通過相似度加權評分，然後返回評分高的
    """
    totals = {}
    simSums = {}
    for other in prefs:
        # 不要和自己比較
        if other==person: continue
        sim = similarity(prefs,person, other)

        # 忽略評價值為零或小於零的情況
        if sim<=0: continue
        for item in prefs[other]:
            # 只對自己還未看過的影片進行評價
            if item not in prefs[person] or prefs[person][item]==0:
                # 相似度 * 評價值
                totals.setdefault(item,0)
                totals[item] += prefs[other][item]*sim
                # 相似度只和
                simSums.setdefault(item,0)
                simSums[item]+=sim

    # 建立一個歸一化的列表
    rankings = [(total/simSums[item],item) for item,total in totals.items()]

    # 返回經過排序的列表
    rankings.sort()
    rankings.reverse()
    return rankings

def transforPrefs(prefs):
    result = {}
    for person in prefs:
        for item in prefs[person]:
            result.setdefault(item, {})

            # 將人和物品對調
            result[item][person] = prefs[person][item]
    return result


###匯入本地的MovieLens資料集

def loadMovieLens(path='/data/ml-latest-small'):

    # 獲取影片標題
    movies = {}
    file = open(path + '/movies.csv')
    file.readline()

    for line in file:
        (ids, title)=line.split(',')[:2]
        movies[ids] = title

    file.close()

    # 載入資料
    prefs = {}
    file = open(path + '/ratings.csv')
    file.readline()
    for line in file:
        (user,movieid,rating,ts)=line.split(',')
        prefs.setdefault(user,{})
        prefs[user][movies[movieid]]=float(rating)

    file.close()
    return prefs


def calculateSimilarItems(prefs,n = 10):
    # 建立字典，以給出與這些物品最為相似的所有其他物品
    result = {}

    # 以物品為中心對偏好矩陣實施倒置處理
    itemPrefs = transforPrefs(prefs)
    c = 0
    for item in itemPrefs:
        # 針對大資料更新狀態變數
        c += 1
        # 顯示進度
        if c%100==0:print("%d / %d"%(c,len(itemPrefs)))
        # 尋找最為相似的物品
        scores = topMatches(itemPrefs, item, n=n,similarity=sim_distance)
        result[item] = scores

    return result

def getRecommendedItems(prefs,itemMatch,user):
    userRatins = prefs[user]
    scores={}
    totalSim={}

    # 迴圈遍歷由當前使用者評分的物品
    for (item,rating) in userRatins.items():

        # 迴圈遍歷與當前物品相近的物品
        for (similarity,item2) in itemMatch[item]:

            # 如果該使用者已經對當前物品做過評價，則將其忽略
            if item2 in userRatins:continue;

            # 評價值與相似度的加權之和
            scores.setdefault(item2,0)
            scores[item2] += similarity * rating

            # 全部相似度之和
            totalSim.setdefault(item2, 0)
            totalSim[item2] += similarity

    # 相似度加權平均   
    rankings = [(score/totalSim[item],item) for item,score in scores.items()]

    # 按最高值到最低值的順序，返回評價結果
    rankings.sort()
    rankings.reverse()
    return rankings