def compute_S(A):
'''
compute the transition matrix S from addjacency matrix A, which solves sink node problem by filling the all-zero columns in A.
S[j][i] represents the probability of moving from node i to node j.
If node i is a sink node, S[j][i] = 1/n.
Input:
A: adjacency matrix, a (n by n) numpy matrix of binary values. If there is a link from node i to node j, A[j][i] =1. Otherwise A[j][i]=0 if there is no link.
Output:
S: transition matrix, a (n by n) numpy matrix of float values. S[j][i] represents the probability of moving from node i to node j.
The values in each column of matrix S should sum to 1.
'''
#########################################
## INSERT YOUR CODE HERE
n = len(A)
S = compute_P(A)
for i in range(n):
is_sink = 1
for j in range(n):
if S[j, i]!=0:
is_sink = 0
if is_sink == 1:
for k in range(n):
S[k, i] = 1./n
#########################################
return S
def compute_S(A):
'''
compute the transition matrix S from addjacency matrix A, which solves sink node problem by filling the all-zero columns in A.
S[j][i] represents the probability of moving from node i to node j.
If node i is a sink node, S[j][i] = 1/n.
Input:
A: adjacency matrix, a (n by n) numpy matrix of binary values. If there is a link from node i to node j, A[j][i] =1. Otherwise A[j][i]=0 if there is no link.
Output:
S: transition matrix, a (n by n) numpy matrix of float values. S[j][i] represents the probability of moving from node i to node j.
The values in each column of matrix S should sum to 1.
'''
#########################################
## INSERT YOUR CODE HERE
S_init = A.copy(); # Need to copy to avoid modifying A
num_rows = np.shape(S_init)[0];
num_cols = np.shape(S_init)[1];
S_prob = 1. / num_cols;
for j in range(num_cols): # Iterate over all columns (across row)
if (np.count_nonzero(S_init[: , j]) == 0): # If no non-zero values in ith column,
for i in range(num_rows): # Iterate over all rows (down column)
S_init[i,j] = S_prob; # Reassign 0 => (1 / num_cols) (equal probability)
S = compute_P(S_init); # We can now use compute_P on correct matrix (infinite loop in sink-node problem is analguous to division by zero that occurs in compute_P)
#########################################
return S;
def compute_S(A):
'''
compute the transition matrix S from addjacency matrix A, which solves sink node problem by filling the all-zero columns in A.
S[j][i] represents the probability of moving from node i to node j.
If node i is a sink node, S[j][i] = 1/n.
Input:
A: adjacency matrix, a (n by n) numpy matrix of binary values. If there is a link from node i to node j, A[j][i] =1. Otherwise A[j][i]=0 if there is no link.
Output:
S: transition matrix, a (n by n) numpy matrix of float values. S[j][i] represents the probability of moving from node i to node j.
The values in each column of matrix S should sum to 1.
'''
#########################################
## INSERT YOUR CODE HERE
shape = set(np.shape(A))
assert len(shape) == 1
n = shape.pop()
P = compute_P(A)
colsums = P.sum(axis=0)
sink_nodes = np.asarray(np.isnan(colsums))
sink_nodes = sink_nodes.reshape((n, ))
from copy import deepcopy
S = deepcopy(P)
if sink_nodes.any():
S[:, sink_nodes] = 1 / n
#########################################
return S
def compute_S(A):
'''
compute the transition matrix S from addjacency matrix A, which solves sink node problem by filling the all-zero columns in A.
S[j][i] represents the probability of moving from node i to node j.
If node i is a sink node, S[j][i] = 1/n.
Input:
A: adjacency matrix, a (n by n) numpy matrix of binary values. If there is a link from node i to node j, A[j][i] =1. Otherwise A[j][i]=0 if there is no link.
Output:
S: transition matrix, a (n by n) numpy matrix of float values. S[j][i] represents the probability of moving from node i to node j.
The values in each column of matrix S should sum to 1.
'''
#########################################
## INSERT YOUR CODE HERE
n = A.shape[0]
sumCol = np.sum(A, axis=0)
for col in range(n):
if(sumCol[col]==0):
A[:, col] = 1/n
P = compute_P(A)
S=P
#########################################
return S
def compute_S(A):
'''
compute the transition matrix S from adjacency matrix A, which solves sink node problem by filling the all-zero columns in A.
S[j][i] represents the probability of moving from node i to node j.
If node i is a sink node, S[j][i] = 1/n.
Input:
A: adjacency matrix, a (n by n) numpy matrix of binary values. If there is a link from node i to node j, A[j][i] =1. Otherwise A[j][i]=0 if there is no link.
Output:
S: transition matrix, a (n by n) numpy matrix of float values. S[j][i] represents the probability of moving from node i to node j.
The values in each column of matrix S should sum to 1.
'''
#########################################
## INSERT YOUR CODE HERE
num_nodes = A.shape[0]
A[:, A.sum(axis=0) == 0] = np.ones((num_nodes, 1))
S = compute_P(A)
#########################################
return S
''' TEST: Now you can test the correctness of your code above by typing `nosetests -v test4.py:test_compute_S' in the terminal. '''
def compute_S(A):
'''
compute the transition matrix S from addjacency matrix A, which solves sink node problem by filling the all-zero columns in A.
S[j][i] represents the probability of moving from node i to node j.
If node i is a sink node, S[j][i] = 1/n.
Input:
A: adjacency matrix, a (n by n) numpy matrix of binary values. If there is a link from node i to node j, A[j][i] =1. Otherwise A[j][i]=0 if there is no link.
Output:
S: transition matrix, a (n by n) numpy matrix of float values. S[j][i] represents the probability of moving from node i to node j.
The values in each column of matrix S should sum to 1.
'''
P = compute_P(A)
numrows = P.shape[0]
numcols = P.shape[1]
columnsum = np.sum(A, axis=0)
for n in range(columnsum.shape[1]):
if columnsum[0, n] == 0:
for k in range(numrows):
P[k, n] = 1 / numcols
S = np.asmatrix(P)
return S
def compute_S(A):
'''
compute the transition matrix S from addjacency matrix A, which solves sink node problem by filling the all-zero columns in A.
S[j][i] represents the probability of moving from node i to node j.
If node i is a sink node, S[j][i] = 1/n.
Input:
A: adjacency matrix, a (n by n) numpy matrix of binary values. If there is a link from node i to node j, A[j][i] =1. Otherwise A[j][i]=0 if there is no link.
Output:
S: transition matrix, a (n by n) numpy matrix of float values. S[j][i] represents the probability of moving from node i to node j.
The values in each column of matrix S should sum to 1.
'''
#########################################
## INSERT YOUR CODE HERE
A = compute_P(A)
for x in range(A.shape[1]):
n = 0.0
for i in (A[:, x]):
n = n + i
if n == 0:
m = float(A.shape[0])
A[:, x] = 1 / m
S = A
#########################################
return S