概述

基於圖的模型（graph-based model）是推薦系統中的重要內容。
在推薦系統中，使用者行為資料可以表示成圖的形式,具體地，可以用二元組(u,i)$(u,i)$表示，其中每個二元組(u,i)$(u,i)$表示使用者u$u$對物品i$i$的產生過行為，這種資料很容易用一個二分圖表示

其中users集 U={A,B,C}$U=\{A,B,C\}$, items集I={a,b,c,d}$I=\{a,b,c,d\}$。我們用G(V,E)$G(V,E)$來表示上圖。V=U⋃I$V=U\bigcup I$，圖中的邊則是由資料集中的二元組確定。本文不考慮各邊的權重(u$u$對i$i$的興趣度)，都預設為1。

與pagerank演算法的區別

有了圖之後我們要對u進行推薦物品，就轉化為計算使用者頂點u和與所有物品頂點之間的相關性，按照相關性的高低生成推薦列表。說白了，這是一個圖上的排名問題，我們最容易想到的就是Google的pageRank演算法。這裡只給出迭代公式，Pagerank演算法的具體細節在此不做贅述，具體的可以看http://blog.csdn.net/john_xyz/article/details/78915097。

PR(i)=1−αn+α∑j∈(i)PR(j)out(j)$PR(i)=\frac{1-\alpha }{n}+\alpha \sum _{j\in (i)}\frac{PR(j)}{out(j)}$

上式中PR(i)$PR(i)$是網頁i的訪問概率（也就是重要度），α$\alpha$是使用者繼續訪問網頁的概率，

與PageRank隨機選擇一個點開始遊走（也就是說從每個點開始的概率都是相同的）不同，如果我們要計算所有節點相對於使用者u$u$的相關度，則PersonalRank從使用者u$u$對應的節點開始遊走，每到一個節點都以1−α$1-\alpha$的概率停止遊走並從u$u$重新開始，或者以α$\alpha$的概率繼續遊走，從當前節點指向的節點中按照均勻分佈隨機選擇一個節點往下游走。這樣經過很多輪遊走之後，每個頂點被訪問到的概率也會收斂趨於穩定，這個時候我們就可以用概率來進行排名了。

在執行演算法之前，我們需要初始化每個節點的初始概率值。如果我們對使用者

Python程式碼實現

分別用兩種方式實現PersonalRank演算法，一種是用純粹的for迴圈去做，另外一種是用矩陣乘法。對於大規模稀疏矩陣M$M$，使用稀疏矩陣乘法相比於for迴圈，能提高上百倍的效率。當然，如果對於大規模資料使用稠密矩陣，依然很慢。

# coding:utf-8
import numpy as np
import time
import scipy.sparse as sparse
import pandas as pd

def PersonalRank(G, alpha, root):
    """
    Random walk algorithm：calculate importance of all nodes in respect to
    the start_node
    :param G: graph
    :param alpha: probability of random walkRa
    :param root: start node of random walk
    :param num_iter: nums of iteration
    :return: type of dict, ex.
    {node1:prob1, node2:prob2,...}
    """
    rank = dict()
    rank = {x:0 for x in G.keys()}
    rank[root] = 1
    pre = np.zeros(n)
    # iteration
    while np.sum(abs(np.array(list(pre)) - np.array(list(rank.values())))) > 0.001:
        # initialize
        pre = rank.values()
        tmp = {x:0 for x in G.keys()}
        # 取節點i和它的出邊尾節點集合ri
        for i, ri in G.items():
            for j in ri:
                try:
                    tmp[j] += alpha * rank[i] / (1.0 * len(ri))
                except:
                    continue
        tmp[root] += (1 - alpha)
        rank = tmp
    result = sorted(rank.items(), key=lambda x:x[1], reverse=True)[:num_candidates]
    return result

def PersonalRankInMatrix(M, alpha, root):
    """
    Personal Rank in matrix formation
    :param M: transfer probability matrix
    :param index2node: index2node dictionary
    :param node2index: node2index dictionary
    :return:type of list of tuple, ex.
    [(node1, prob1),(node2, prob2),...]
    """
    result = dict()
    v = np.zeros(n)
    v[node2index[root]] = 1
    v0 = v
    while np.sum(abs(v - (alpha*M.dot(v) + (1-alpha)*v0))) > 0.001:
        v = alpha * M.dot(v) + (1-alpha)*v0
    for ind, prob in enumerate(v):
        result[index2node[ind]] =  prob
    result = sorted(result.items(), key=lambda x:x[1], reverse=True)[:num_candidates]
    return result

def Generate_Transfer_Matrix(G):
    """generate transfer matrix given graph"""
    index2node = dict()
    node2index = dict()
    for index,node in enumerate(G.keys()):
        node2index[node] = index
        index2node[index] = node
    # num of nodes
    n = len(node2index)
    # generate Transfer probability matrix, shape of (n,n)
    M = np.zeros([n,n])
    for node1 in G.keys():
        for node2 in G[node1]:
            # FIXME: some nodes not in the Graphs.keys, may incur some errors
            try:
                M[node2index[node2],node2index[node1]] = 1/len(G[node1])
            except:
                continue
    return M, node2index, index2node

def Generate_Transfer_SparseMatrix(G):
    """
    generate transfer sparse matrix given graph
    :param G: graph, type of dict
    :return: transfer matrix, type of 'scipy.sparse.coo.coo_matrix'
    """
    index2node = dict()
    node2index = dict()
    for index,node in enumerate(G.keys()):
        node2index[node] = index
        index2node[index] = node
    # num of nodes
    n = len(node2index)
    # initialize rows and columns
    rows = []
    columns = []
    data = []
    # generate Transfer probability Sparse matrix, shape of (n,n)
    for node1 in G.keys():
        for node2 in G[node1]:
            # FIXME: some nodes not in the Graphs.keys, may incur some errors
            try:
                rows.append(node2index[node2])
                columns.append(node2index[node1])
                data.append(1/len(G[node1]))
            except:
                continue
    rows = np.array(rows)
    columns = np.array(columns)
    data = np.array(data)
    M = sparse.coo_matrix((data, (rows,columns)),shape=(n,n))
    return M, node2index, index2node


# test algorithm performance
if __name__ == '__main__':
    alpha = 0.85
    root = 'A'
    num_iter = 100
    num_candidates = 10
    G = {'A' : {'a' : 1, 'c' : 1},
         'B' : {'a' : 1, 'b' : 1, 'c':1, 'd':1},
         'C' : {'c' : 1, 'd' : 1},
         'a' : {'A' : 1, 'B' : 1},
         'b' : {'B' : 1},
         'c' : {'A' : 1, 'B' : 1, 'C':1},
         'd' : {'B' : 1, 'C' : 1}}
    M, node2index, index2node = Generate_Transfer_SparseMatrix(G)
    n = len(M)
    print(pd.DataFrame(M, index=G.keys(), columns=G.keys()))
    time1 = time.time()
    result1 = PersonalRank(G, alpha, root)
    time2 = time.time()
    result2 = PersonalRankInMatrix(M, alpha, root)
    time3 = time.time()
    print(result1)
    print(result2)
    print(time2 - time1, time3 - time2)

關於稀疏矩陣的思考

在python中，可以藉助官方庫scipy.sparse和numpy中的dot和實現稀疏矩陣和稠密矩陣的相乘，具體如下

import numpy as np
import scipy.sparse as sparse

r=np.array([0,3,1,2,6,3,6,3,4])
c=np.array([0,0,2,2,2,4,5,6,3])
data=np.array([1,1,1,1,1,1,1,1,1])

a = np.ones(7)

sparse_matrix =sparse.coo_matrix((data, (r,c)), shape=(7,7))

print(sparse_matrix)
print(sparse_matrix.todense())
M = sparse_matrix.dot(a)

print(M)

reference