पायथन ने मेमोरी को पढ़ा

Question

मैं एक डेटा सेट के साथ काम कर रहा हूं जो ~ 8 जीबी बड़ा है और मैं भी विभिन्न एमएल मॉडल को प्रशिक्षित करने के लिए विज्ञान-सीखने का उपयोग कर रहा हूं। डेटा सेट मूल रूप से इनट्स के 1 डी वैक्टर की एक सूची है।

मैं एकाधिक पायथन प्रक्रियाओं में डेटा सेट कैसे उपलब्ध कर सकता हूं या मैं डेटा सेट को कैसे एन्कोड कर सकता हूं ताकि मैं इसे multiprocessing कक्षाओं का उपयोग कर सकूं? मैं ctypes पर पढ़ रहा हूं और मैं multiprocessing के दस्तावेज में भी पढ़ रहा हूं लेकिन मैं बहुत उलझन में हूं। मुझे केवल डेटा को हर प्रक्रिया में पढ़ने योग्य बनाने की आवश्यकता है ताकि मैं इसके साथ मॉडल को प्रशिक्षित कर सकूं।

क्या मुझे ctypes के रूप में साझा multiprocessing चर होना चाहिए?

मैं डेटासेट को ctypes के रूप में कैसे प्रस्तुत कर सकता हूं?

Answer 1

मुझे लगता है कि आप पूरे डेटासेट को रैम में एक numpy सरणी में लोड करने में सक्षम हैं, और आप लिनक्स या मैक पर काम कर रहे हैं। (यदि आप विंडोज़ पर हैं या आप सरणी को रैम में फिट नहीं कर सकते हैं, तो आपको शायद डिस्क पर फ़ाइल में सरणी की प्रतिलिपि बनाना चाहिए और इसे एक्सेस करने के लिए numpy.memmap का उपयोग करना चाहिए। आपका कंप्यूटर डिस्क से डेटा को रैम में कैश करेगा कर सकते हैं, और उन कैशों को प्रक्रियाओं के बीच साझा किया जाएगा, इसलिए यह एक भयानक समाधान नहीं है।)

उपरोक्त धारणाओं के तहत, यदि आपको multiprocessing के माध्यम से बनाई गई अन्य प्रक्रियाओं में डेटासेट को केवल पढ़ने की आवश्यकता है, तो आप बस इसे बना सकते हैं डेटासेट और फिर अन्य प्रक्रियाओं को लॉन्च करें। उनके पास मूल नामस्थान से डेटा तक केवल पढ़ने के लिए पहुंच होगी। वे मूल नामस्थान से डेटा बदल सकते हैं, लेकिन वे परिवर्तन अन्य प्रक्रियाओं के लिए दृश्यमान नहीं होंगे (मेमोरी मैनेजर स्मृति के प्रत्येक सेगमेंट को कॉपी करेगा जो वे स्थानीय मेमोरी मैप में बदलते हैं)।

अपने अन्य प्रक्रियाओं मूल डाटासेट में परिवर्तन और उन परिवर्तनों को माता-पिता की प्रक्रिया या अन्य प्रक्रियाओं के लिए दृश्यमान बनाना चाहते हैं तो आपको कुछ इस तरह इस्तेमाल कर सकते हैं:

import multiprocessing 
import numpy as np 

# create your big dataset 
big_data = np.zeros((3, 3)) 

# create a shared-memory wrapper for big_data's underlying data 
# (it doesn't matter what datatype we use, and 'c' is easiest) 
# I think if lock=True, you get a serialized object, which you don't want. 
# Note: you will need to setup your own method to synchronize access to big_data. 
buf = multiprocessing.Array('c', big_data.data, lock=False) 

# at this point, buf and big_data.data point to the same block of memory, 
# (try looking at id(buf[0]) and id(big_data.data[0])) but for some reason 
# changes aren't propagated between them unless you do the following: 
big_data.data = buf 

# now you can update big_data from any process: 
def add_one_direct(): 
    big_data[:] = big_data + 1 

def add_one(a): 
    # People say this won't work, since Process() will pickle the argument. 
    # But in my experience Process() seems to pass the argument via shared 
    # memory, so it works OK. 
    a[:] = a+1 

print "starting value:" 
print big_data 

p = multiprocessing.Process(target=add_one_direct) 
p.start() 
p.join() 

print "after add_one_direct():" 
print big_data 

p = multiprocessing.Process(target=add_one, args=(big_data,)) 
p.start() 
p.join() 

print "after add_one():" 
print big_data 

Answer 2

Share Large, Read-Only Numpy Array Between Multiprocessing Processes

का डुप्लिकेट हो सकता है आप नए numpy memmap वस्तु के लिए वर्तमान प्रतिनिधित्व से आपके डेटासेट परिवर्तित कर सकते हैं, और हर प्रक्रिया से इसका इस्तेमाल करते हैं। लेकिन यह वैसे भी बहुत तेज नहीं होगा, यह सिर्फ राम से सरणी के साथ काम करने का कुछ अमूर्तता देता है, असल में यह एचडीडी से फाइल होगी, आंशिक रूप से रैम में कैश किया जाएगा। तो आपको partial_fit विधियों के साथ scikit-learn algos पसंद करना चाहिए, और उनका उपयोग करें।

https://docs.scipy.org/doc/numpy/reference/generated/numpy.memmap.html

असल joblib (जो प्रयोग किया जाता है parallelizing के लिए scikit सीखने) स्वचालित रूप से (यदि यह काफी बड़ा है, निश्चित रूप से) विभिन्न प्रक्रियाओं से इसका इस्तेमाल करने के प्रतिनिधित्व memmap करने के लिए अपने डाटासेट बदल देता है।