विशाल numpy 2 डी-सरणी बनाने और भरने का सबसे तेज़ तरीका?

Question

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

import itertools, operator, time, copy, os, sys 
import numpy 
from multiprocessing import Pool 


def f2(x): # more complex mathematical formulas that change according to values in *i* and *x* 
    temp=[] 
    for i in combine: 
     temp.append(0.2*x[1]*i[1]/64.23) 
    return temp 

def combinations_with_replacement_counts(n, r): #provide all combinations of r balls in n boxes 
    size = n + r - 1 
    for indices in itertools.combinations(range(size), n-1): 
     starts = [0] + [index+1 for index in indices] 
     stops = indices + (size,) 
     yield tuple(map(operator.sub, stops, starts)) 

global combine 
combine = list(combinations_with_replacement_counts(3, 60)) #here putted 60 but need 350 instead 
print len(combine) 
if __name__ == '__main__': 
    t1=time.time() 
    pool = Pool()    # start worker processes 
    results = [pool.apply_async(f2, (x,)) for x in combine] 
    roots = [r.get() for r in results] 
    print roots [0:3] 
    pool.close() 
    pool.join() 
    print time.time()-t1 

• बना सकते हैं और इस तरह के विशाल numpy सरणी को भरने के लिए सबसे तेज़ तरीका क्या है? भरने के बाद कुल मिलाकर numpy array में परिवर्तित करें?
• क्या हम गणना कर सकते हैं कि 2 डी-सरणी के मामलों/कॉलम/पंक्तियां सरणी भरने के लिए स्वतंत्र हैं? मल्टीप्रोसेसिंग का उपयोग करके इस तरह के गणना को अनुकूलित करने के लिए सुराग/ट्रेल्स?

Answer 1

आप इच्छित आकार के साथ एक खाली numpy.memmap सरणी बना सकते हैं, और फिर multiprocessing.Pool का उपयोग अपने मान भरने के लिए। इसे सही तरीके से करने से आपके पूल में अपेक्षाकृत कम प्रत्येक प्रक्रिया की स्मृति पदचिह्न भी जारी रहेगी।

Answer 2

मुझे पता है कि आप साझा किए गए numpy arrays बना सकते हैं जिन्हें विभिन्न धागे से बदला जा सकता है (माना जाता है कि बदले गए क्षेत्र ओवरलैप नहीं होते हैं)। यहाँ कोड है कि आप ऐसा करने के लिए उपयोग कर सकते हैं के स्केच है (मैं stackoverflow पर कहीं मूल विचार को देखा, संपादित करें: यहाँ यह है https://stackoverflow.com/a/5550156/1269140)

import multiprocessing as mp ,numpy as np, ctypes 

def shared_zeros(n1, n2): 
    # create a 2D numpy array which can be then changed in different threads 
    shared_array_base = mp.Array(ctypes.c_double, n1 * n2) 
    shared_array = np.ctypeslib.as_array(shared_array_base.get_obj()) 
    shared_array = shared_array.reshape(n1, n2) 
    return shared_array 

class singleton: 
    arr = None 

def dosomething(i): 
    # do something with singleton.arr 
    singleton.arr[i,:] = i 
    return i 

def main(): 
    singleton.arr=shared_zeros(1000,1000) 
    pool = mp.Pool(16) 
    pool.map(dosomething, range(1000)) 

if __name__=='__main__': 
    main()