Точечное произведение двух разреженных матриц, влияющих только на нулевые значения

взломал его! Ну, тут много материалов составляющей, характерные для разреженных матриц, которые я узнал по пути. Вот реализация, которую я мог бы собрать -

# Find the indices in output array that are to be updated  
R,C = ((A!=0).dot(B!=0)).nonzero()
mask = np.asarray(A[R,C]==0).ravel()
R,C = R[mask],C[mask]

# Make a copy of A and get the dot product through sliced rows and columns
# off A and B using the definition of matrix-multiplication    
out = A.copy()
out[R,C] = (A[R].multiply(B[:,C].T).sum(1)).ravel()   

самой дорогой частью, по-видимому, является умножение и суммирование по элементам. На некоторых быстрых тестах синхронизации кажется, что это было бы хорошо на разреженных матрицах с высокой степенью разреженности, чтобы превзойти оригинальное решение на основе точечной маски с точки зрения производительности, которое, я думаю, исходит из его фокусировки на памяти эффективность.

во время выполнения теста

функции определения -

def naive(A, B):
    mask = A != 0
    out = A.dot(B).tolil()
    out[mask] = A[mask]
    return out.tocsr()

def proposed(A, B):
    R,C = ((A!=0).dot(B!=0)).nonzero()
    mask = np.asarray(A[R,C]==0).ravel()
    R,C = R[mask],C[mask]
    out = A.copy()
    out[R,C] = (A[R].multiply(B[:,C].T).sum(1)).ravel()    
    return out

тайминги -

In [57]: # Input matrices 
    ...: M,N = 25000, 170       
    ...: A = sparse.rand(M, N, density=0.001, format='csr')
    ...: B = sparse.rand(N, N, density=0.02, format='csr')
    ...: 

In [58]: %timeit naive(A, B)
10 loops, best of 3: 92.2 ms per loop

In [59]: %timeit proposed(A, B)
10 loops, best of 3: 132 ms per loop

In [60]: # Input matrices with increased sparse-ness
    ...: M,N = 25000, 170       
    ...: A = sparse.rand(M, N, density=0.0001, format='csr')
    ...: B = sparse.rand(N, N, density=0.002, format='csr')
    ...: 

In [61]: %timeit naive(A, B)
10 loops, best of 3: 78.1 ms per loop

In [62]: %timeit proposed(A, B)
100 loops, best of 3: 8.03 ms per loop

Python не является моим основным языком, но я думал, что это интересная проблема, и я хотел дать этому удар:)

предисловий:

import numpy
import scipy.sparse
# example matrices and sparse versions
A = numpy.array([[1, 2, 0, 1], [1, 0, 1, 2], [0, 1, 2 ,1], [1, 2, 1, 0]])
B = numpy.array([[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]])
A_s = scipy.sparse.lil_matrix(A)
B_s = scipy.sparse.lil_matrix(B)

таким образом, вы хотите преобразовать оригинальную проблему:

C = A.dot(B)
C[A.nonzero()] = A[A.nonzero()]

к чему-то разреженному. Чтобы убрать это с пути, прямой" разреженный " перевод вышеизложенного:

C_s = A_s.dot(B_s)
C_s[A_s.nonzero()] = A_s[A_s.nonzero()]

но похоже, что вы не довольны этим, так как он сначала вычисляет все продукты dot, которые вас беспокоят это может быть неэффективно.

Итак, ваш вопрос: если вы сначала найдете нули и только оцените точечные продукты на этих элементах, это будет быстрее? Т. е. для плотной матрицы это может быть что-то вроде:

Xs, Ys = numpy.nonzero(A==0)
D = A[:]
D[Xs, Ys] = map ( lambda x,y: A[x,:].dot(B[:,y]), Xs, Ys)

давайте переведем это на разреженную матрицу. Моим главным камнем преткновения здесь было нахождение" нулевых " индексов; так как A_s==0 не имеет смысла для разреженных матриц, я нашел их так:

Xmax, Ymax = A_s.shape
DenseSize = Xmax * Ymax
Xgrid, Ygrid = numpy.mgrid[0:Xmax, 0:Ymax]
Ygrid = Ygrid.reshape([DenseSize,1])[:,0]
Xgrid = Xgrid.reshape([DenseSize,1])[:,0]
AllIndices = numpy.array([Xgrid, Ygrid])
NonzeroIndices = numpy.array(A_s.nonzero())
ZeroIndices = numpy.array([x for x in AllIndices.T.tolist() if x not in NonzeroIndices.T.tolist()]).T

если вы знаете лучше / быстрее, все значит, попробуй. Как только у нас есть нулевые индексы, мы можем сделать аналогичное отображение, как и раньше:

D_s = A_s[:]
D_s[ZeroIndices[0], ZeroIndices[1]] = map ( lambda x, y : A_s[x,:].dot(B[:,y])[0], ZeroIndices[0], ZeroIndices[1] )

что дает вам результат разреженной матрицы.

теперь я не знаю, быстрее это или нет. Я в основном сделал удар, потому что это была интересная проблема, и посмотреть, смогу ли я сделать это на python. На самом деле я подозреваю, что это может быть не быстрее, чем direct whole-matrix dotproduct, потому что он использует listcomprehensions и отображение в большом наборе данных (как вы говорите, вы ожидаете много ноли.) Но это!--27-- > is ответ на ваш вопрос "как я могу вычислять только точечные продукты для нулевых значений, не умножая матрицы в целом". Мне было бы интересно посмотреть, если вы попробуете это, как это сравнивается с точки зрения скорости на ваших наборах данных.

EDIT: я помещаю ниже пример версии "обработка блоков" на основе вышеизложенного, которая, я думаю, должна позволить вам обрабатывать ваш большой набор данных без проблем. Дайте мне знать, если это завод.

import numpy
import scipy.sparse
# example matrices and sparse versions
A = numpy.array([[1, 2, 0, 1], [1, 0, 1, 2], [0, 1, 2 ,1], [1, 2, 1, 0]])
B = numpy.array([[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]])
A_s = scipy.sparse.lil_matrix(A)
B_s = scipy.sparse.lil_matrix(B)

# Choose a grid division (i.e. how many processing blocks you want to create)
BlockGrid = numpy.array([2,2])

D_s = A_s[:] # initialise from A

Xmax, Ymax = A_s.shape
BaseBSiz = numpy.array([Xmax, Ymax]) / BlockGrid
for BIndX in range(0, Xmax, BlockGrid[0]):
  for BIndY in range(0, Ymax, BlockGrid[1]):
    BSizX, BSizY = D_s[ BIndX : BIndX + BaseBSiz[0], BIndY : BIndY + BaseBSiz[1] ].shape
    Xgrid, Ygrid = numpy.mgrid[BIndX : BIndX + BSizX, BIndY : BIndY + BSizY]
    Xgrid = Xgrid.reshape([BSizX*BSizY,1])[:,0]
    Ygrid = Ygrid.reshape([BSizX*BSizY,1])[:,0]
    AllInd = numpy.array([Xgrid, Ygrid]).T
    NZeroInd = numpy.array(A_s[Xgrid, Ygrid].reshape((BSizX,BSizY)).nonzero()).T + numpy.array([[BIndX],[BIndY]]).T
    ZeroInd = numpy.array([x for x in AllInd.tolist() if x not in NZeroInd.tolist()]).T
    #
    # Replace zero-values in current block
    D_s[ZeroInd[0], ZeroInd[1]] = map ( lambda x, y : A_s[x,:].dot(B[:,y])[0], ZeroInd[0], ZeroInd[1] )