बेवकूफ कुशल बड़े मैट्रिक्स गुणा

Question

डिस्क पर बड़े मैट्रिक्स को स्टोर करने के लिए मैं numpy.memmap का उपयोग करता हूं।

यहाँ बड़ा आव्यूह गुणन परीक्षण करने के लिए एक नमूना कोड है:

import numpy as np 
import time 

rows= 10000 # it can be large for example 1kk 
cols= 1000 

#create some data in memory 
data = np.arange(rows*cols, dtype='float32') 
data.resize((rows,cols)) 

#create file on disk 
fp0 = np.memmap('C:/data_0', dtype='float32', mode='w+', shape=(rows,cols)) 
fp1 = np.memmap('C:/data_1', dtype='float32', mode='w+', shape=(rows,cols)) 

fp0[:]=data[:] 
fp1[:]=data[:] 

#matrix transpose test 
tr = np.memmap('C:/data_tr', dtype='float32', mode='w+', shape=(cols,rows)) 
tr= np.transpose(fp1) #memory consumption? 
print fp1.shape 
print tr.shape 

res = np.memmap('C:/data_res', dtype='float32', mode='w+', shape=(rows,rows)) 
t0 = time.time() 
# redifinition ? res= np.dot(fp0,tr) #takes 342 seconds on my machine, if I multiplicate matrices in RAM it takes 345 seconds (I thinks it's a strange result) 
res[:]= np.dot(fp0,tr) # assignment ? 
print res.shape 
print (time.time() - t0) 

तो मेरी प्रश्न हैं:

1. कैसे जो उदाहरण के लिए कुछ मूल्य के लिए इस प्रक्रिया का उपयोग कर रहा है आवेदन की स्मृति consumtion प्रतिबंधित करने के लिए 100 एमबी (या 1 जीबी या कुछ और) तक। मुझे समझ में नहीं आता कि प्रक्रिया की स्मृति खपत का अनुमान कैसे लगाया जाए (मुझे लगता है कि स्मृति "केवल" आवंटित होती है जब "डेटा" चर बनाया जाता है, लेकिन जब हम memmap फ़ाइलों का उपयोग करते हैं तो कितनी मेमोरी उपयोग की जाती है?)
2. डिस्क पर संग्रहीत बड़ी मैट्रिक्स के गुणा के लिए शायद कुछ इष्टतम समाधान है? उदाहरण के लिए, हो सकता है कि डेटा डिस्क पर ऑप्टिमाइज़ नहीं किया गया हो या डिस्क से पढ़ा न जाए, ठीक तरह से चिपकाया न जाए, और डॉट उत्पाद का उपयोग केवल एक कोर हो। शायद मुझे पीईटीबल्स की तरह कुछ उपयोग करना चाहिए?

इसके अलावा मुझे प्रतिबंधित स्मृति उपयोग के साथ समीकरणों (एसवीडी और अन्य) की रैखिक प्रणाली को हल करने में एल्गोरिदम में दिलचस्पी है। शायद इस एल्गोरिदम को आउट-ऑफ-कोर या पुनरावृत्त कहा जाता है और मुझे लगता है कि हार्ड ड्राइव < -> राम, जीपीयू राम < -> सीपीयू राम, सीपीयू राम < -> सीपीयू कैश जैसे कुछ समानताएं हैं।

भी here मुझे PyTables में मैट्रिक्स गुणा के बारे में कुछ जानकारी मिली।

इसके अलावा मुझे आर में this मिला लेकिन मुझे इसे पायथन या मैटलैब के लिए चाहिए।

Answer 1

अपने प्रसंस्करण के लिए NumExpr उपयोग पर विचार करें: https://github.com/pydata/numexpr

... आंतरिक रूप से, NumExpr अपनी ही vectorized आभासी मशीन है कि एक chunked पढ़ने के लिए रणनीति के चारों ओर बनाया गया है, ताकि कुशलता से बेहतर आकार ब्लॉक पर संचालित करने के लिए कार्यरत हैं स्मृति में डेटा का। यदि सही तरीके से ट्यून किया गया तो यह आसानी से भद्दा NumPy संचालन को हरा सकता है।

NumExpr इस मुद्दे के आपके टूटने में # 2 को कवर कर सकता है। आप स्ट्रीम करने द्विपदीय प्रारूप का उपयोग करके # 1 को संबोधित करते हैं तो chunked पढ़ने के लिए जब अपने डेटा फ़ाइलों को लोड हो रहा है दृष्टिकोण कर सकते हैं - तो की तरह:

with open('path/to/your-data.bin', 'rb') as binary: 
     while True: 
      chunk = binary.read(4096) # or what have you 
      if not chunk: 
       break 

तो वह भी आप के लिए निम्न स्तर है, मैं तुम्हें सिफारिश करेंगे HDF5 पुस्तकालय और प्रारूप को देखो: http://www.h5py.org - यह NumPy आधारित संरचनाओं कि मैं के बारे में पता की बाइनरी क्रमांकन लिए सबसे अच्छा समाधान है। h5py मॉड्यूल संपीड़न, खंडित पढ़ने, dtypes, मेटाडाटा का समर्थन करता है ... आप इसे नाम दें।

शुभकामनाएं!

Answer 2

Dask.array अवरुद्ध एल्गोरिदम और कार्य शेड्यूलिंग के बड़े ऑन-डिस्क सारिणी के लिए एक numpy इंटरफेस प्रदान करता है। यह आसानी से आउट-ऑफ-कोर मैट्रिक्स गुणा और अन्य सरल-आइश numpy संचालन कर सकते हैं।

अवरोधित रेखीय बीजगणित कठिन है और आप इस विषय पर अकादमिक कार्य में से कुछ की जाँच कर सकते हैं। Dask लंबा और पतला मैट्रिक्स पर QR और SVD factorizations समर्थन करता है।

बावजूद बड़े सरणियों के लिए, तुम सच में अवरुद्ध करना चाहते हैं एल्गोरिदम, अनुभवहीन नहीं traversals जो अप्रिय तरीकों से डिस्क मारा जाएगा।