Python: NumPy 将行除以总和或将其替换为另一个

Question

i am currently trying to obtain a matrice using the NumPy library, but there is a problem that i cannot find the solution to

I currently have the following numpy array

mat = 
[[0. 1. 1. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [1. 1. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1. 1.]
 [0. 0. 0. 1. 0. 1.]
 [0. 0. 0. 1. 0. 0.]]

Now i want to divide each line by the sum of the line, but if the sum of the line is equal to zero, i replace it by a line of 1/len(mat) . I tried to use the following code:

    for line in mat:
        line /= np.sum(line)
        mat[np.isnan(mat)] = 1/N 

The following code will return:

[[0.         0.5        0.5        0.         0.         0.        ]
 [0.16666667 0.16666667 0.16666667 0.16666667 0.16666667 0.16666667]
 [0.33333333 0.33333333 0.         0.         0.33333333 0.        ]
 [0.         0.         0.         0.         0.5        0.5       ]
 [0.         0.         0.         0.5        0.         0.5       ]
 [0.         0.         0.         1.         0.         0.        ]]

This is the correct result i was trying to get, but it gives RuntimeWarning: invalid value encountered in true_divide .

So I was wondering if there was a better way to get the correct result, so i don't have to check after each line if the line if full of nan . (Also if there is a way to instantly divide each line by the sum of each line, instead of have to use the for loop.)

Answer 1

Divide by the sum row-wise and fill NaN with 1/len(mat)

np.nan_to_num(                     # Function to replace non-finite values with given value
    np.divide(                     # Divide function
        mat,                       # Input array for division
        mat.sum(axis=1)[:, None]   # Sum across axis=1(across row) and transpose them for division
    ),
    nan=1/len(mat)                 # value that will replace non-finite values
)

One-liner

np.nan_to_num(np.divide(mat, mat.sum(axis=1)[:, None]), nan=1/len(mat))

Output

[[0.         0.5        0.5        0.         0.         0.        ]
 [0.16666667 0.16666667 0.16666667 0.16666667 0.16666667 0.16666667]
 [0.33333333 0.33333333 0.         0.         0.33333333 0.        ]
 [0.         0.         0.         0.         0.5        0.5       ]
 [0.         0.         0.         0.5        0.         0.5       ]
 [0.         0.         0.         1.         0.         0.        ]]

Answer 2

import numpy as np

mat = np.array([[1,2,3],[4,5,6], [-1,0,1]])
s = mat.sum(axis=1, keepdims=True)  # sum of each line
out = np.ones_like(mat).astype(np.float) / len(mat)  # initialize with 1/N
not_zeros = s[:,0]!=0  # logical indexes of noz zero sum lines 
out[not_zeros, :] = mat[not_zeros, :] / s[not_zeros] # normalize onlt the non zero sum lines
print(out)

[[0.16666667 0.33333333 0.5       ]
 [0.26666667 0.33333333 0.4       ]
 [0.33333333 0.33333333 0.33333333]]

Update - zero sum lines are 1/N

Answer 3

are you looking for something like

import numpy as np

mat = np.array([[0. ,1. ,1., 0., 0., 0.],
 [0., 0., 0., 0., 0. ,0.],
 [1. ,1., 0., 0., 1., 0.],
 [0., 0., 0., 0. ,1., 1.],
 [0. ,0., 0., 1., 0., 1.],
 [0. ,0. ,0. ,1. ,0., 0.]])

sum_ = np.sum(mat, axis=1)

mat[(sum_==0), :] = 1/len(mat) # handle where sum==0
mat[~(sum_==0), :] /= sum_[~(sum_==0), np.newaxis] # handle where sum not 0

mat

array([[0.        , 0.5       , 0.5       , 0.        , 0.        ,
        0.        ],
       [0.16666667, 0.16666667, 0.16666667, 0.16666667, 0.16666667,
        0.16666667],
       [0.33333333, 0.33333333, 0.        , 0.        , 0.33333333,
        0.        ],
       [0.        , 0.        , 0.        , 0.        , 0.5       ,
        0.5       ],
       [0.        , 0.        , 0.        , 0.5       , 0.        ,
        0.5       ],
       [0.        , 0.        , 0.        , 1.        , 0.        ,
        0.        ]])