Элементарный максимум двух разреженных матриц

Question

Есть ли простой/встроенный способ получить максимальный размер элемента из двух (или идеально большего) разреженных матриц? То есть редкий эквивалент np.maximum.

Answer 1

Это сделал трюк:

def maximum (A, B): 
    BisBigger = A-B 
    BisBigger.data = np.where(BisBigger.data < 0, 1, 0) 
    return A - A.multiply(BisBigger) + B.multiply(BisBigger) 

Answer 2

from scipy import sparse 
from numpy import array 
I = array([0,3,1,0]) 
J = array([0,3,1,2]) 
V = array([4,5,7,9]) 
A = sparse.coo_matrix((V,(I,J)),shape=(4,4)) 

A.data.max() 
9 

Если вы еще не сделали, вы должны попробовать ipython, вы могли бы спасти вашу уверенность время мой делая свободное матрицу A затем просто набрав A. затем вкладку, это напечатает список методов, которые вы можете позвоните по телефону A. Из этого вы увидите, что A.data дает ненулевые записи в виде массива и, следовательно, вы просто хотите максимум этого.

Answer 3

Нет, нет встроенного способа сделать это в scipy.sparse. Простое решение является

np.maximum(X.A, Y.A) 

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

# convert to COO, if necessary 
X = X.tocoo() 
Y = Y.tocoo() 

Xdict = dict(((i, j), v) for i, j, v in zip(X.row, X.col, X.data)) 
Ydict = dict(((i, j), v) for i, j, v in zip(Y.row, Y.col, Y.data)) 

keys = list(set(Xdict.iterkeys()).union(Ydict.iterkeys())) 

XmaxY = [max(Xdict.get((i, j), 0), Ydict.get((i, j), 0)) for i, j in keys] 
XmaxY = coo_matrix((XmaxY, zip(*keys))) 

Обратите внимание, что это использует чистый Python вместо векторизованных идиомы. Вы можете попытаться избавиться от частичного времени, векторизируя его части.

Answer 4

Вот другой памяти эффективное решение, которое должно быть немного быстрее, чем larsmans'. Он основан на нахождении набора уникальных индексов для ненулевых элементов в двух массивах с использованием кода от Jaime's excellent answer here.

import numpy as np 
from scipy import sparse 

def sparsemax(X, Y): 

    # the indices of all non-zero elements in both arrays 
    idx = np.hstack((X.nonzero(), Y.nonzero())) 

    # find the set of unique non-zero indices 
    idx = tuple(unique_rows(idx.T).T) 

    # take the element-wise max over only these indices 
    X[idx] = np.maximum(X[idx].A, Y[idx].A) 

    return X 

def unique_rows(a): 
    void_type = np.dtype((np.void, a.dtype.itemsize * a.shape[1])) 
    b = np.ascontiguousarray(a).view(void_type) 
    idx = np.unique(b, return_index=True)[1] 
    return a[idx] 

Тестирование:

def setup(n=1000, fmt='csr'): 
    return sparse.rand(n, n, format=fmt), sparse.rand(n, n, format=fmt) 

X, Y = setup() 
Z = sparsemax(X, Y) 
print np.all(Z.A == np.maximum(X.A, Y.A)) 
# True 

%%timeit X, Y = setup() 
sparsemax(X, Y) 
# 100 loops, best of 3: 4.92 ms per loop 

Answer 5

Последние scipy (13.0) определяет поэлементно булевы для разреженных матриц,. Итак:

BisBigger = B>A 
A - A.multiply(BisBigger) + B.multiply(BisBigger) 

np.maximum нет (пока) работы, поскольку он использует np.where, который до сих пор пытается получить truth value of an array.

Любопытно B>A возвращает булевский тип, а B>=A - float64.