Question

我正在尝试用Python写这个 matlab implementation，但我不明白一点：

last_v = ones（N，1）* inf;

我们在这里获得一个含有所有无穷大的载体吗？在这种情况下，while中的条件立即为假，我们不会获得任何迭代：

while（norm（v - last_v，2）＆gt; v_quadratic_error）

我的理解是什么？

这就是我试过的方式：

from numpy import *
def pagerank(M,d,v_quadratic_error):
count = 0
N=M.shape[1]
v=random.rand(N,1)
v=v/linalg.norm(v)
ainf=array([[inf]])
last_v = dot(ones((N,1)),ainf)
R = d*M + ((1-d)/N * ones((N,N)))
while linalg.norm(v-last_v,2) > v_quadratic_error:
    last_v = v
    v = dot(R,v)
    count+=1
    print 'iteration #', count
return v

Answer 1

在Matlab / Octave中：

octave:4> last_v = ones(N, 1) * inf;
octave:10> norm(v - last_v, 2)
ans = Inf
octave:13> norm(v - last_v, 2) > v_quadratic_error
ans =  1

在Python中：

In [139]: last_v = np.dot(np.ones((N,1)),ainf)
In [140]: np.linalg.norm(v - last_v, 2)
Out[140]: nan
In [141]: np.linalg.norm(v - last_v, 2) <= v_quadratic_error
Out[141]: False

因此Matlab / Octave中的条件为True，但Python中的类似表达式为False。在Python中，而不是使用

while linalg.norm(v-last_v,2) > v_quadratic_error:

你可以使用

while True:
    last_v = v
    ...
    if np.linalg.norm(v - last_v, 2) <= v_quadratic_error: break

这可以保证执行流程至少进入while-loop一次，然后在条件为True时中断。到那时last_v将具有有限值，因此避免了NaN与Inf的问题。

import numpy as np

def pagerank(M, d, v_quadratic_error):
    count = 0
    N = M.shape[1]
    while True:
        v = np.random.rand(N, 1)
        if (v != 0).all(): break
    v = v / np.linalg.norm(v)
    R = d * M + ((1 - d) / N * np.ones((N, N)))
    while True:
        last_v = v
        v = np.dot(R, v)
        count += 1
        print('iteration # {}: {}'.format(count, np.isfinite(v)))
        if np.linalg.norm(v - last_v, 2) <= v_quadratic_error: break
    return v

M = np.array(np.mat('0 0 0 0 1 ; 0.5 0 0 0 0 ; 0.5 0 0 0 0 ; 0 1 0.5 0 0 ; 0 0 0.5 1 0'))
print(pagerank(M, 0.80, 0.001))

收益率（类似）

[[ 0.46322263]
 [ 0.25968575]
 [ 0.25968575]
 [ 0.38623472]
 [ 0.48692059]]

Answer 2

是的，你是对的，这条线会产生一个无穷大的向量。也可以直接使用inf：https://de.mathworks.com/help/matlab/ref/inf.html - ＆gt; inf(N,1)。

条件虽然不会产生错误，但为什么呢？请查看欧几里德规范：https://en.wikipedia.org/wiki/Euclidean_distance - ＆gt; inf的向量的范数（通过一些随机值减去，实际上仍将产生infs的向量）将再次产生inf，所以

inf > v_quadratic_error

将是真的。在循环中，last_v被覆盖，因此在下一次迭代中它会收敛。

PageRank python实现，算法

2 个答案: