Come moltiplicare in modo elementare una matrice scipy.sparse con un array 1d denso trasmesso?

Question

Supponiamo di disporre di un array sparse 2d. Nel mio vero caso d'uso sia il numero di righe e colonne sono molto più grandi (diciamo 20000 e 50000) di conseguenza, non può andare bene in memoria quando viene utilizzata una rappresentazione densa:

>>> import numpy as np 
>>> import scipy.sparse as ssp 

>>> a = ssp.lil_matrix((5, 3)) 
>>> a[1, 2] = -1 
>>> a[4, 1] = 2 
>>> a.todense() 
matrix([[ 0., 0., 0.], 
     [ 0., 0., -1.], 
     [ 0., 0., 0.], 
     [ 0., 0., 0.], 
     [ 0., 2., 0.]]) 

Ora supponiamo di avere un allineamento 1d fitta con tutta la componenti non-zeri di dimensione 3 (o 50000 nel mio caso reale vita):

>>> d = np.ones(3) * 3 
>>> d 
array([ 3., 3., 3.]) 

desidero calcolare la moltiplicazione elementwise di a e d secondo i consueti semantica trasmissione di NumPy. Tuttavia, matrici sparse in SciPy sono del np.matrix: l'operatore '*' è sovraccaricato avere comportarsi come una matrice moltiplicare invece del elementwise-moltiplicano:

>>> a * d 
array([ 0., -3., 0., 0., 6.]) 

Una soluzione sarebbe quella di fare ' un' interruttore per la semantica di matrice per il '*' operatore, che avrebbe dato il risultato atteso:

>>> a.toarray() * d 
array([[ 0., 0., 0.], 
     [ 0., 0., -3.], 
     [ 0., 0., 0.], 
     [ 0., 0., 0.], 
     [ 0., 6., 0.]]) 

Ma non può farlo in quanto la chiamata a ToArray() sarebbe materializzarsi la versione densa di 'a', che non si adatta alla memoria (e anche il risultato sarà denso):

>>> ssp.issparse(a.toarray()) 
False 

Qualche idea su come costruire questo mantenendo solo le strutture dati sparse e senza dover fare un loop python non efficiente sulle colonne di 'a'?

Answer 1

Ho risposto anche a scipy.org, ma ho pensato di aggiungere una risposta qui, nel caso in cui altri trovino questa pagina durante la ricerca.

È possibile trasformare il vettore in una matrice diagonale sparsa e quindi utilizzare la moltiplicazione della matrice (con *) per fare la stessa cosa della trasmissione, ma in modo efficiente.

>>> d = ssp.lil_matrix((3,3)) 
>>> d.setdiag(np.ones(3)*3) 
>>> a*d 
<5x3 sparse matrix of type '<type 'numpy.float64'>' 
with 2 stored elements in Compressed Sparse Row format> 
>>> (a*d).todense() 
matrix([[ 0., 0., 0.], 
     [ 0., 0., -3.], 
     [ 0., 0., 0.], 
     [ 0., 0., 0.], 
     [ 0., 6., 0.]]) 

Spero che questo aiuti!

Answer 2

Bene, ecco un semplice codice che farà ciò che desideri. Non so se è così efficace come si vorrebbe, in modo da prendere o lasciare:

import scipy.sparse as ssp 
def pointmult(a,b): 
    x = a.copy() 
    for i in xrange(a.shape[0]): 
     if x.data[i]: 
      for j in xrange(len(x.data[i])): 
       x.data[i] *= b[x.rows[i]] 
    return x 

Funziona solo con matrici lil quindi dovrete apportare alcune modifiche, se si desidera farlo funzionare con altri formati.

Answer 3

Penso che A.multiply (B) dovrebbe funzionare in scarse sparse. Il metodo si moltiplica moltiplicando "point-wise", non moltiplicando la matrice.

HTH