🔞 🏞️ 🅾️ डिस्क से NumPy एरर्स लोड करना: मेममैप की तुलना () और Zarr / HDF5 👐🏻 😈 🌅

यदि आपका NumPy सरणी RAM में फिट होने के लिए बहुत बड़ा है, तो आप इसे टुकड़ों में तोड़कर संसाधित कर सकते हैं । आप इसे या तो पारदर्शी मोड में कर सकते हैं या स्पष्ट रूप से डिस्क से इन टुकड़ों को एक बार में लोड करके कर सकते हैं। इस स्थिति में, आप दो वर्गों के उपकरणों का सहारा ले सकते हैं:

NumPy विधि memmap(), एक पारदर्शी तंत्र जो आपको डिस्क पर स्थित एक फ़ाइल को देखने की अनुमति देता है जैसे कि यह सभी स्मृति में है।
Zarr और HDF5 डेटा भंडारण प्रारूप जो एक दूसरे के समान हैं, जो अनुमति देते हैं, यदि आवश्यक हो, डिस्क से लोड हो रहा है और डिस्क के सरणी के संकुचित टुकड़ों को सहेज रहा है।

इन तरीकों में से प्रत्येक की अपनी ताकत और कमजोरियां हैं।

सामग्री, जिसका अनुवाद आज हम प्रकाशित करते हैं, डेटा के साथ काम करने के इन तरीकों की सुविधाओं के विश्लेषण के लिए समर्पित है, और कहानी की किन स्थितियों में वे काम में आ सकते हैं। विशेष रूप से, उन डेटा प्रारूपों पर विशेष ध्यान दिया जाएगा जो गणना करने के लिए अनुकूलित हैं और आवश्यक रूप से इस डेटा को अन्य प्रोग्रामर को स्थानांतरित करने के लिए डिज़ाइन नहीं किया गया है।

डिस्क से डेटा पढ़ने या डिस्क पर डेटा लिखने से क्या होता है?

जब पहली बार किसी फ़ाइल को डिस्क से पढ़ा जाता है, तो ऑपरेटिंग सिस्टम डेटा को प्रोसेस मेमोरी में कॉपी नहीं करता है। सबसे पहले, यह तथाकथित "बफर कैश" में इसकी एक प्रति संग्रहीत करते हुए, इस डेटा को इसकी मेमोरी में कॉपी करता है।

यहाँ क्या उपयोग है?

तथ्य यह है कि ऑपरेटिंग सिस्टम कैश में डेटा संग्रहीत करता है यदि आपको उसी डेटा को फिर से उसी फ़ाइल से पढ़ने की आवश्यकता होती है।

यदि डेटा फिर से पढ़ा जाता है, तो यह डिस्क से नहीं, बल्कि रैम से प्रोग्राम मेमोरी में प्रवेश करता है, जो कि परिमाण के क्रम में तेजी से होता है।

यदि कैश द्वारा कब्ज़ा की गई मेमोरी को किसी और चीज़ की आवश्यकता होती है, तो कैश स्वचालित रूप से साफ़ हो जाएगा।

जब डेटा को डिस्क पर लिखा जाता है, तो यह विपरीत दिशा में चलता है। सबसे पहले वे केवल बफर कैश के लिए लिखे गए हैं। इसका मतलब यह है कि लिखने के संचालन आमतौर पर बहुत तेज़ होते हैं, क्योंकि कार्यक्रम को धीमी डिस्क पर ध्यान केंद्रित करने की आवश्यकता नहीं होती है। रिकॉर्डिंग के दौरान, उसे केवल रैम के साथ काम करने की आवश्यकता होती है।

परिणामस्वरूप, डेटा को कैश से डिस्क में फ्लश किया जाता है।

मेममैप का उपयोग करके एक सरणी के साथ काम करना ()

हमारे मामले में, memmap()यह हमें डिस्क पर एक फ़ाइल को देखने की अनुमति देता है जैसे कि यह स्मृति में संग्रहीत एक सरणी है। ऑपरेटिंग सिस्टम, प्रोग्राम के लिए पारदर्शी है, रीड / राइट ऑपरेशन करता है, या तो बफर कैश या हार्ड डिस्क एक्सेस करता है, यह इस बात पर निर्भर करता है कि अनुरोधित डेटा मेमोरी में कैश्ड है या नहीं। इस तरह के एक एल्गोरिथ्म को यहाँ निष्पादित किया जाता है:

क्या कैश में डेटा है? यदि ऐसा है - महान - आप उनसे सीधे संपर्क कर सकते हैं।
डिस्क पर डेटा है? उन तक पहुंच धीमी होगी, लेकिन आपको इसके बारे में चिंता करने की ज़रूरत नहीं है, उन्हें पारदर्शी मोड में लोड किया जाएगा।

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

विधि memmap()को NumPy में बनाया गया है:

import numpy as np
array = np.memmap("mydata/myarray.arr", mode="r",
                  dtype=np.int16, shape=(1024, 1024))

इस कोड को चलाएं, और आपके पास आपके निपटान में एक सरणी होगी, जिसके साथ काम कार्यक्रम के लिए पूरी तरह से पारदर्शी होगा - चाहे वह कार्य बफर कैश के साथ या हार्ड डिस्क के साथ किया गया हो।

मेममैप () सीमाएँ

हालांकि कुछ स्थितियों में यह memmap()अपने आप को काफी अच्छा दिखा सकता है, इस पद्धति की सीमाएँ भी हैं:

डेटा को फ़ाइल सिस्टम में संग्रहित किया जाना चाहिए। डेटा को AWS S3 जैसे बाइनरी स्टोरेज से डाउनलोड नहीं किया जा सकता है।
, . , . , , , .
N- , , , . .

हमें अंतिम बिंदु समझाते हैं। कल्पना करें कि हमारे पास दो-आयामी सरणी है जिसमें 32-बिट (4-बाइट) पूर्णांक हैं। प्रति डिस्क पर 4096 बाइट्स पढ़े जाते हैं। यदि आप एक डिस्क से क्रमिक रूप से फ़ाइल में स्थित डेटा पढ़ते हैं (कहते हैं, ऐसा डेटा किसी सरणी की रेखाओं में है), तो प्रत्येक रीड ऑपरेशन के बाद, हमारे पास 1024 पूर्णांक होंगे। लेकिन यदि आप डेटा पढ़ते हैं, तो फ़ाइल का स्थान सरणी में उनके स्थान से मेल नहीं खाता (जैसे, स्तंभों में स्थित डेटा), तो प्रत्येक रीड ऑपरेशन आपको केवल 1 आवश्यक संख्या प्राप्त करने की अनुमति देगा। नतीजतन, यह पता चला है कि समान मात्रा में डेटा प्राप्त करने के लिए, आपको एक हजार गुना अधिक रीड ऑपरेशन करना होगा।

Zarr और HDF5

उपरोक्त सीमाओं को दूर करने के लिए, आप Zarr या HDF5 डेटा संग्रहण स्वरूपों का उपयोग कर सकते हैं , जो बहुत ही समान हैं:

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

आगे हम केवल Zarr पर चर्चा करेंगे, लेकिन अगर आप HDF5 प्रारूप में रुचि रखते हैं और Zarr के साथ इसकी गहरी तुलना करते हैं, तो आप इस वीडियो को देख सकते हैं ।

Zarr का उपयोग करना

Zarr आपको डेटा के टुकड़ों को स्टोर करने और उन्हें सरणियों के रूप में मेमोरी में लोड करने की अनुमति देता है, और यह भी - सरणियों के रूप में डेटा के इन टुकड़ों को लिखें।

यहाँ कैसे Zarr का उपयोग कर एक सरणी लोड करने के लिए है:

>>> import zarr, numpy as np
>>> z = zarr.open('example.zarr', mode='a',
...               shape=(1024, 1024),
...               chunks=(512,512), dtype=np.int16)
>>> type(z)
<class 'zarr.core.Array'>
>>> type(z[100:200])
<class 'numpy.ndarray'>

कृपया ध्यान दें कि जब तक वस्तु का एक टुकड़ा प्राप्त नहीं होता है, तब तक हम अपने निपटान में नहीं होंगे numpy.ndarray। एक इकाई zarr.core.arrayसिर्फ मेटाडेटा है। केवल डेटा जो स्लाइस में शामिल है, डिस्क से लोड किया गया है।

मैंने Zarr को क्यों चुना?

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

आइए हम अंतिम दो बिंदुओं पर अधिक विस्तार से ध्यान दें।

घर्षण आयाम

मान लीजिए कि हम आकार में 30,000 x 3,000 तत्वों की एक सरणी के साथ काम कर रहे हैं। यदि आपको इस सरणी को पढ़ने और इसकी धुरी के साथ आगे बढ़ने की आवश्यकता है X, और इसकी धुरी के साथ आगे बढ़ रहे हैं Y, तो आप इस सरणी के डेटा वाले टुकड़ों को बचा सकते हैं, जैसा कि नीचे दिखाया गया है (व्यवहार में, सबसे अधिक संभावना है, आपको 9 से अधिक टुकड़ों की आवश्यकता होगी):

अब, अक्ष Xऔर अक्ष दोनों पर स्थित डेटा को Yकुशलता से लोड किया जा सकता है। कार्यक्रम में किस तरह के डेटा की आवश्यकता है, इसके आधार पर, आप डाउनलोड कर सकते हैं, उदाहरण के लिए, टुकड़े (1, 0), (1, 1), (1, 2), या टुकड़े (0, 1), (1, 1), आदि (२, १)।

आधार - सामग्री संकोचन

प्रत्येक टुकड़े को संपीड़ित किया जा सकता है। इसका मतलब यह है कि डेटा डिस्क से तेजी से प्रोग्राम में प्रवेश कर सकता है जो आपको असम्पीडित जानकारी को पढ़ने की अनुमति देता है। यदि डेटा 3 बार संपीड़ित होता है, तो इसका मतलब है कि इसे डिस्क से 3 बार अनपेक्षित डेटा से तेजी से डाउनलोड किया जा सकता है, प्रोसेसर को इसे अनपैक करने में लगने वाले समय को घटाकर।

टुकड़े डाउनलोड होने के बाद, उन्हें प्रोग्राम मेमोरी से हटाया जा सकता है।

सारांश: मेममैप () या Zarr?

memmap()कौन सा उपयोग करना बेहतर है - या Zarr?

Memmap()यह ऐसे मामलों में दिलचस्प लगता है:

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

Zarr निम्नलिखित स्थितियों में विशेष रूप से उपयोगी है (उनमें से कुछ में, जैसा कि ध्यान दिया जाएगा, HDF5 प्रारूप भी लागू है):

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

मैं memmap()Zarr के बीच चयन करूंगा और सबसे पहले, मैं Zarr का उपयोग करने की कोशिश करूंगा - क्योंकि यह पैकेज जो लचीलापन देता है और डेटा भंडारण प्रारूप इसे लागू करता है।

प्रिय पाठकों! आप बड़े NumPy सरणियों के साथ काम करने की समस्या को कैसे हल करते हैं?

डिस्क से NumPy एरर्स लोड करना: मेममैप की तुलना () और Zarr / HDF5