個性化召回算法實踐(三)——PersonalRank算法

將用戶行為表示為二分圖模型。假設給用戶\(u\)進行個性化推薦，要計算所有節點相對於用戶\(u\)的相關度，則PersonalRank從用戶\(u\)對應的節點開始游走，每到一個節點都以\(1-d\)的概率停止游走並從\(u\)重新開始，或者以\(d\)的概率繼續游走，從當前節點指向的節點中按照均勻分布隨機選擇一個節點往下游走。這樣經過很多輪游走之后，每個頂點被訪問到的概率也會收斂趨於穩定，這個時候我們就可以用概率來進行排名了。
在執行算法之前，我們需要初始化每個節點的初始概率值。如果我們對用戶\(u\)進行推薦，則令\(u\)對應的節點的初始訪問概率為1，其他節點的初始訪問概率為0，然后再使用迭代公式計算。

\[PR(i)=(1-d)r_i+d\sum_{j \in in(i)} \frac {PR(j)}{|out(i)|} \\ r_i = \begin{cases} 1 \ \ i=u \\ 0 \ \ i!=u \end{cases} \]

一般有兩種算法實現，一種是矩陣化實現，一種是非矩陣化實現。

非矩陣化實現

根據userID與itemID建立二分圖。在代碼中，self.G代表全局有向圖，為區分userID與itemID分別加了不同的前綴。另外，user-item對保存在圖中，方向是相互的。接下來，就在圖中根據概率進行轉移。

其中G = dict(item_user,**user_item)的含義是將兩個dict拼接成一個dict

import pandas as pd
import time

class PersonalRank:
    def __init__(self,X,Y):
        X,Y = ['user_'+str(x) for x in X],['item_'+str(y) for y in Y]
        self.G = self.get_graph(X,Y)

    def get_graph(self,X,Y):
        """
        Args:
            X: user id
            Y: item id
        Returns:
            graph:dic['user_id1':{'item_id1':1},  ... ]
        """
        item_user = dict()
        for i in range(len(X)):
            user = X[i]
            item = Y[i]
            if item not in item_user:
                item_user[item] = {}
            item_user[item][user]=1

        user_item = dict()
        for i in range(len(Y)):
            user = X[i]
            item = Y[i]
            if user not in user_item:
                user_item[user] = {}
            user_item[user][item]=1
        G = dict(item_user,**user_item)
        return G


    def recommend(self, alpha, userID, max_depth,K=10):
        # rank = dict()
        userID = 'user_' + str(userID)
        rank = {x: 0 for x in self.G.keys()}
        rank[userID] = 1
        # 開始迭代
        begin = time.time()
        for k in range(max_depth):
            tmp = {x: 0 for x in self.G.keys()}
            # 取出節點i和他的出邊尾節點集合ri
            for i, ri in self.G.items():
                # 取節點i的出邊的尾節點j以及邊E(i,j)的權重wij,邊的權重都為1，歸一化后就是1/len(ri)
                for j, wij in ri.items():
                    tmp[j] += alpha * rank[i] / (1.0 * len(ri))
            tmp[userID] += (1 - alpha)
            rank = tmp
        end = time.time()
        print('use_time', end - begin)
        lst = sorted(rank.items(), key=lambda x: x[1], reverse=True)[:K]
        for ele in lst:
            print("%s:%.3f, \t" % (ele[0], ele[1]))

if __name__ == '__main__':
    moviesPath = '../data/ml-1m/movies.dat'
    ratingsPath = '../data/ml-1m/ratings.dat'
    usersPath = '../data/ml-1m/users.dat'

    # usersDF = pd.read_csv(usersPath,index_col=None,sep='::',header=None,names=['user_id', 'gender', 'age', 'occupation', 'zip'])
    # moviesDF = pd.read_csv(moviesPath,index_col=None,sep='::',header=None,names=['movie_id', 'title', 'genres'])
    ratingsDF = pd.read_csv(ratingsPath, index_col=None, sep='::', header=None,names=['user_id', 'movie_id', 'rating', 'timestamp'])
    X=ratingsDF['user_id'][:1000]
    Y=ratingsDF['movie_id'][:1000]
    PersonalRank(X,Y).recommend(alpha=0.8,userID=1,max_depth=50,K=30)#輸出對用戶1推薦的 top10 item
    # print('PersonalRank result',rank)

矩陣化實現

\[r = (1-\alpha)r_o + \alpha M^T r \]

其中，\(r\)是\(m+n\)行，1列的矩陣，每一行代表該頂點對固定頂點的PR值；是\(m+n\)行，1列的矩陣，負責選取某一個頂點作為固定頂點，其數值只有1行為1，其余為0。\(M\)是m+n行，m+n列的矩陣，是轉移矩陣，其值\(M_{ij}=\frac{1}{out(i)},j \in out(i) \ else \ 0\),即為頂點的出度倒數，若沒有連接邊則為0。上式可轉換為：

\[r = (E-\alpha M^T)^{-1}(1-\alpha)r_o \]

其中，\((E-\alpha M^T)^{-1}\)可以看做所有頂點的推薦結果，每一列代表一個頂點項，對該頂點的PR值。

#-*-coding:utf-8-*-
"""
author:jamest
date:20190310
PersonalRank function with Matrix
"""
import pandas as pd
import numpy as np
import time
import operator
from scipy.sparse import coo_matrix
from scipy.sparse.linalg import gmres


class PersonalRank:
    def __init__(self,X,Y):
        X,Y = ['user_'+str(x) for x in X],['item_'+str(y) for y in Y]
        self.G = self.get_graph(X,Y)

    def get_graph(self,X,Y):
        """
        Args:
            X: user id
            Y: item id
        Returns:
            graph:dic['user_id1':{'item_id1':1},  ... ]
        """
        item_user = dict()
        for i in range(len(X)):
            user = X[i]
            item = Y[i]
            if item not in item_user:
                item_user[item] = {}
            item_user[item][user]=1

        user_item = dict()
        for i in range(len(Y)):
            user = X[i]
            item = Y[i]
            if user not in user_item:
                user_item[user] = {}
            user_item[user][item]=1
        G = dict(item_user,**user_item)
        return G


    def graph_to_m(self):
        """
        Returns:
            a coo_matrix sparse mat M
            a list,total user item points
            a dict,map all the point to row index
        """

        graph = self.G
        vertex = list(graph.keys())
        address_dict = {}
        total_len = len(vertex)
        for index in range(len(vertex)):
            address_dict[vertex[index]] = index
        row = []
        col = []
        data = []
        for element_i in graph:
            weight = round(1/len(graph[element_i]),3)
            row_index=  address_dict[element_i]
            for element_j in graph[element_i]:
                col_index = address_dict[element_j]
                row.append(row_index)
                col.append(col_index)
                data.append(weight)
        row = np.array(row)
        col = np.array(col)
        data = np.array(data)
        m = coo_matrix((data,(row,col)),shape=(total_len,total_len))
        return m,vertex,address_dict


    def mat_all_point(self,m_mat,vertex,alpha):
        """
        get E-alpha*m_mat.T
        Args:
            m_mat
            vertex:total item and user points
            alpha:the prob for random walking
        Returns:
            a sparse
        """
        total_len = len(vertex)
        row = []
        col = []
        data = []
        for index in range(total_len):
            row.append(index)
            col.append(index)
            data.append(1)
        row = np.array(row)
        col = np.array(col)
        data = np.array(data)
        eye_t = coo_matrix((data,(row,col)),shape=(total_len,total_len))
        return eye_t.tocsr()-alpha*m_mat.tocsr().transpose()

    def recommend_use_matrix(self, alpha, userID, K=10,use_matrix=True):
        """
        Args:
            alpha:the prob for random walking
            userID:the user to recom
            K:recom item num
        Returns:
            a dic,key:itemid ,value:pr score
        """
        m, vertex, address_dict = self.graph_to_m()
        userID = 'user_' + str(userID)
        print('add',address_dict)
        if userID not in address_dict:
            return []
        score_dict = {}
        recom_dict = {}
        mat_all = self.mat_all_point(m,vertex,alpha)
        index = address_dict[userID]
        initial_list = [[0] for row in range(len(vertex))]
        initial_list[index] = [1]
        r_zero = np.array(initial_list)
        res = gmres(mat_all,r_zero,tol=1e-8)[0]
        for index in range(len(res)):
            point = vertex[index]
            if len(point.strip().split('_'))<2:
                continue
            if point in self.G[userID]:
                continue
            score_dict[point] = round(res[index],3)
        for zuhe in sorted(score_dict.items(),key=operator.itemgetter(1),reverse=True)[:K]:
            point,score = zuhe[0],zuhe[1]
            recom_dict[point] = score
        return recom_dict




if __name__ == '__main__':
    moviesPath = '../data/ml-1m/movies.dat'
    ratingsPath = '../data/ml-1m/ratings.dat'
    usersPath = '../data/ml-1m/users.dat'

    # usersDF = pd.read_csv(usersPath,index_col=None,sep='::',header=None,names=['user_id', 'gender', 'age', 'occupation', 'zip'])
    # moviesDF = pd.read_csv(moviesPath,index_col=None,sep='::',header=None,names=['movie_id', 'title', 'genres'])
    ratingsDF = pd.read_csv(ratingsPath, index_col=None, sep='::', header=None,names=['user_id', 'movie_id', 'rating', 'timestamp'])
    X=ratingsDF['user_id'][:1000]
    Y=ratingsDF['movie_id'][:1000]
    rank = PersonalRank(X,Y).recommend_use_matrix(alpha=0.8,userID=1,K=30)
    print('PersonalRank result',rank)

參考：
推薦系統概述（一）
Github