python矩阵相乘算法,Python中稀疏矩阵的矩阵乘法

I want to multiply a sparse matrix A, with a matrix B which has 0, -1, or 1 as elements. To reduce the complexity of the matrix multiplication, I can ignore items if they are 0, or go ahead and add the column without multiplication if the item is 1, or subs. if it's -1. The discussion about this is here:

Now I can go ahead and implement this trick but I wonder if I use Numpy's multiplication functions it'll be faster.

Does anyone knows if they optimised matrix multiplication for such matrices? Or can you suggest something to speed this process up since I have a matrix 300000x1000.

解决方案

Have you looked at scipy.sparse? There's no point in re-inventing the wheel, here. Sparse matricies are a fairly standard thing.

(In the example, I'm using a 300000x4 matrix for easier printing after the multiplication. A 300000x1000 matrix shouldn't be any problem, though. This will be much faster than multiplying two dense arrays, assuming you have a majority of 0 elements.)

import scipy.sparse

import numpy as np

# Make the result reproducible...

np.random.seed(1977)

def generate_random_sparse_array(nrows, ncols, numdense):

"""Generate a random sparse array with -1 or 1 in the non-zero portions"""

i = np.random.randint(0, nrows-1, numdense)

j = np.random.randint(0, ncols-1, numdense)

data = np.random.random(numdense)

data[data <= 0.5] = -1

data[data > 0.5] = 1

ij = np.vstack((i,j))

return scipy.sparse.coo_matrix((data, ij), shape=(nrows, ncols))

A = generate_random_sparse_array(4, 300000, 1000)

B = generate_random_sparse_array(300000, 5, 1000)

C = A * B

print C.todense()

This yields:

[[ 0. 1. 0. 0. 0.]

[ 0. 2. -1. 0. 0.]

[ 1. -1. 0. 0. 0.]

[ 0. 0. 0. 0. 0.]]