ब्रॉडकास्ट घन 1 डी सरणी द्वारा acipy.sparse मैट्रिक्स को multwisely कैसे करें?

Question

मान लीजिए कि मेरे पास 2 डी स्पैस सरणी है। मेरा असली USECASE में दोनों पंक्तियों और स्तंभों की संख्या बहुत बड़ा कर रहे हैं (कहना 20000 और 50000) इसलिए यह स्मृति में फिट नहीं कर सकते जब एक घने प्रतिनिधित्व प्रयोग किया जाता है:

>>> 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.]]) 

अब मान लीजिए कि मैं सभी के साथ एक घने 1 दिन सरणी है (मेरे वास्तविक जीवन के मामले में या 50000) का आकार 3 के साथ गैर शून्य घटकों:

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

मैं एक की elementwise गुणा गणना करने के लिए पसंद है और numpy के सामान्य प्रसारण अर्थ विज्ञान का उपयोग कर d होगा। हालांकि, scipy में विरल मैट्रिक्स np.matrix के होते हैं: '*' ऑपरेटर यह एक मैट्रिक्स गुणा के बजाय की तरह व्यवहार करने के लिए ओवरलोड हो गया है elementwise-गुणा:

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

एक समाधान बनाने के लिए 'होगा * एक 'के लिए सरणी अर्थ विज्ञान के लिए स्विच' 'ऑपरेटर, कि अपेक्षित परिणाम देना होगा:

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

लेकिन मैं ऐसा नहीं कर सकते कि जब कॉल toArray करने के लिए() के घने संस्करण अमल में लाना होगा' एक 'जो स्मृति में फिट नहीं है (और नतीजा भी घना होगा):

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

कोई विचार यह है कि इसे केवल एक छोटे से डेटास्ट्रक्चर रखने के दौरान और 'ए' के ​​कॉलम पर एक अक्षम पाइथन लूप करने के बिना इसे कैसे बनाया जाए?

Answer 1

मैंने scipy.org पर भी उत्तर दिया, लेकिन मैंने सोचा कि मुझे यहां एक जवाब जोड़ना चाहिए, अगर अन्य लोग खोज करते समय यह पृष्ठ ढूंढें।

आप वेक्टर को एक स्पैस डायगोनल मैट्रिक्स में बदल सकते हैं और फिर प्रसारण के समान काम करने के लिए मैट्रिक्स गुणा (* के साथ) का उपयोग कर सकते हैं, लेकिन कुशलतापूर्वक।

>>> 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.]]) 

आशा है कि मदद करता है!

Answer 2

अच्छा, यहां एक साधारण कोड है जो आप चाहते हैं कि करेंगे। अगर यह के रूप में कुशल आप चाहते हैं के रूप में है पता नहीं है, इसलिए इसे लेने के लिए या इसे छोड़:

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 

यह केवल लील मैट्रिक्स के साथ काम करता है ताकि आप कुछ परिवर्तन करने की अगर आप इसे काम करना चाहता हूँ होगा अन्य प्रारूपों के साथ।

Answer 3

मुझे लगता है कि एमुल्टिपली (बी) को तेज स्पैस में काम करना चाहिए। विधि गुणा करता है "पॉइंट-वार" गुणा करता है, मैट्रिक्स गुणा नहीं।

HTH