पायथन में एचडीएफ 5 फ़ाइलों का उपयोग कैसे करें

सभी को नमस्कार!

क्रमशः "पायथन वेब डेवलपर" पाठ्यक्रम का शुभारंभ हो रहा है, हम अभी भी दिलचस्प लेख साझा कर रहे हैं और हमें अपने खुले पाठों में आमंत्रित कर रहे हैं, जहां आप दिलचस्प सामग्री देख सकते हैं, शिक्षकों को जान सकते हैं और उनसे सवाल पूछ सकते हैं।

चलो चलते हैं!

HDF5 बड़ी मात्रा में डेटा के कुशल भंडारण को सक्षम बनाता है

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

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


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

इस लेख में, हम देखेंगे कि आप अपनी हार्ड ड्राइव से डेटा को स्टोर करने और पुनर्प्राप्त करने के लिए h5py का उपयोग कैसे कर सकते हैं। हम डेटा को संग्रहीत करने के विभिन्न तरीकों और रीडिंग प्रक्रिया को अनुकूलित करने के तरीके पर चर्चा करेंगे। इस लेख में दिखाई देने वाले सभी उदाहरण हमारे गिथुब भंडार में भी उपलब्ध हैं।

स्थापना

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

pip install h5py 

यदि यह आपके वातावरण में नहीं है तो यह कमांड भी NumPy स्थापित करेगा।

यदि आप अपनी HDF5 फ़ाइलों की सामग्री की जांच के लिए एक ग्राफिकल टूल की तलाश कर रहे हैं, तो आप HDF5 व्यूअर इंस्टॉल कर सकते हैं। यह जावा में लिखा गया है, इसलिए इसे लगभग किसी भी कंप्यूटर पर काम करना चाहिए।

बुनियादी डेटा भंडारण और पढ़ना

एचडीएफ 5 लाइब्रेरी का उपयोग करने के लिए आगे बढ़ते हैं। हम एक नई फ़ाइल बनाएंगे और उसमें एक यादृच्छिक संख्या टाइप करेंगे।

 import h5py import numpy as np arr = np.random.randn(1000) with h5py.File('random.hdf5', 'w') as f: dset = f.create_dataset("default", data=arr) 

पहली कुछ पंक्तियाँ बहुत सरल हैं: हम h5py और NumPy पैकेज आयात करते हैं और यादृच्छिक मानों के साथ एक सरणी बनाते हैं। हम लिखने की अनुमति w के साथ random.hdf5 फ़ाइल खोलते हैं, जिसका अर्थ है कि यदि समान नाम वाली फ़ाइल पहले से मौजूद है, तो इसे फिर से लिखा जाएगा। यदि आप फ़ाइल को सहेजना चाहते हैं और फिर भी इसे लिखने में सक्षम हैं, तो आप इसे w के बजाय एक विशेषता के साथ खोल सकते हैं। हम डिफ़ॉल्ट नामक एक डेटासेट बनाते हैं और डेटा को पहले बनाए गए यादृच्छिक सरणी के रूप में सेट करते हैं। डेटासेट हमारे डेटा के कस्टोडियन हैं, जो मुख्य रूप से एचडीएफ 5 प्रारूप के ब्लॉक का निर्माण करते हैं।

एक नोट

यदि आप कथन से परिचित नहीं हैं, तो मुझे ध्यान देना चाहिए कि यह फाइलों को खोलने और बंद करने का एक सुविधाजनक तरीका है। यहां तक ​​कि अगर कोई त्रुटि होती है, तो फ़ाइल बंद हो जाएगी। यदि किसी कारण से आप उपयोग नहीं कर रहे हैं, तो अंत में f.close() कमांड जोड़ना कभी न भूलें। बयान के साथ किसी भी फाइल के साथ काम करता है, न कि केवल एचडीएफ फाइलें।

हम डेटा को लगभग उसी तरह से पढ़ सकते हैं जैसे हम NumPy फ़ाइल को पढ़ते हैं:

 with h5py.File('random.hdf5', 'r') as f: data = f['default'] print(min(data)) print(max(data)) print(data[:15]) 

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

 for key in f.keys(): print(key) 

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

उपरोक्त उदाहरण में, आप डेटा को एक सरणी के रूप में उपयोग कर सकते हैं। उदाहरण के लिए, आप डेटा [2] दर्ज करके तीसरे तत्व का उल्लेख कर सकते हैं, या आप डेटा [1: 3] मान प्राप्त कर सकते हैं। कृपया ध्यान दें: डेटा एक सरणी नहीं है, यह एक डेटा सेट है। आप इसे print(type(data)) टाइप करके देख सकते हैं। डेटासेट सरणियों की तुलना में पूरी तरह से अलग तरीके से काम करते हैं, क्योंकि उनकी जानकारी हार्ड ड्राइव पर संग्रहीत होती है, और यदि हम उनका उपयोग नहीं करते हैं तो वे इसे रैम में लोड नहीं करते हैं। निम्न कोड, उदाहरण के लिए, काम नहीं करेगा:

 f = h5py.File('random.hdf5', 'r') data = f['default'] f.close() print(data[1]) 

दिखाई देने वाली त्रुटि थोड़ी बोझिल है, लेकिन अंतिम पंक्ति बहुत उपयोगी है:

 ValueError: Not a dataset (not a dataset) 

त्रुटि का मतलब है कि हम एक डेटासेट तक पहुँचने का प्रयास कर रहे हैं, जिसकी अब हमारे पास पहुँच नहीं है। यह थोड़ा भ्रमित करने वाला है, लेकिन ऐसा इसलिए होता है क्योंकि हमने फ़ाइल को बंद कर दिया है और इसलिए अब हमें डेटा में दूसरे मूल्य तक पहुंचने की अनुमति नहीं है। जब हमने च को ['डिफ़ॉल्ट'] चर डेटा को सौंपा है, तो हम वास्तव में फ़ाइल से डेटा नहीं पढ़ते हैं, इसके बजाय हम एक संकेतक उत्पन्न करते हैं जहां डेटा हार्ड ड्राइव पर है। दूसरी ओर, यह कोड काम करेगा:

 f = h5py.File('random.hdf5', 'r') data = f['default'][:] f.close() print(data[10]) 

कृपया ध्यान दें कि केवल अंतर यह है कि हमने डेटासेट पढ़ने के बाद [:] जोड़ा है। कई अन्य मैनुअल h5py पैकेज के साथ HDF5 प्रारूप की पूरी क्षमता का प्रदर्शन किए बिना, ऐसे उदाहरणों पर आधारित हैं। अब तक हमने जिन उदाहरणों की जांच की है, उनके कारण आप सोच रहे होंगे: अगर NumPy फ़ाइलों को सहेजने से HDF5 का उपयोग किया जाता है, तो आपको वही कार्यक्षमता मिलती है? चलो एचडीएफ 5 प्रारूप की सुविधाओं में गोता लगाएँ।

एचडीएफ 5 फाइलों से चयनात्मक पढ़ना

अब तक, हमने देखा है कि जब हम डेटा सेट पढ़ते हैं, तो हम अभी तक डिस्क से डेटा नहीं पढ़ रहे हैं, इसके बजाय हम हार्ड डिस्क पर एक विशिष्ट स्थान के लिए एक लिंक बनाते हैं। हम देख सकते हैं कि क्या होता है, उदाहरण के लिए, हम डेटा सेट के पहले 10 तत्वों को स्पष्ट रूप से पढ़ते हैं:

 with h5py.File('random.hdf5', 'r') as f: data_set = f['default'] data = data_set[:10] print(data[1]) print(data_set[1]) 

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

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

 import h5py import numpy as np arr1 = np.random.randn(10000) arr2 = np.random.randn(10000) with h5py.File('complex_read.hdf5', 'w') as f: f.create_dataset('array_1', data=arr1) f.create_dataset('array_2', data=arr2) 

हमारे पास दो डेटासेट्स हैं जिन्हें array_1 और array_2 कहा जाता है, जिनमें से प्रत्येक में एक यादृच्छिक NumPy सरणी होती है। हम array_2 मानों को पढ़ना चाहते हैं जो उन तत्वों के अनुरूप हैं जहाँ array_1 मान सकारात्मक हैं। हम ऐसा कुछ करने की कोशिश कर सकते हैं:

 with h5py.File('complex_read.hdf5', 'r') as f: d1 = f['array_1'] d2 = f['array_2'] data = d2[d1>0] 

लेकिन वह काम नहीं करेगा। d1 एक डेटा सेट है और इसकी तुलना किसी पूर्णांक से नहीं की जा सकती। एकमात्र तरीका वास्तव में डिस्क से डेटा पढ़ना है, और फिर इसकी तुलना करना है। इसलिए, हमें ऐसा कुछ मिलता है:

 with h5py.File('complex_read.hdf5', 'r') as f: d1 = f['array_1'] d2 = f['array_2'] data = d2[d1[:]>0] 

पहला डेटा सेट d1 पूरी तरह से मेमोरी में लोड हो जाता है जब हम d1 [:] करते हैं, लेकिन दूसरे डेटा सेट d2 से हम केवल अन्य तत्वों को लेते हैं। यदि d1 डेटासेट पूरी तरह से मेमोरी में लोड होने के लिए बहुत बड़ा था, तो हम लूप के अंदर काम कर सकते हैं।

 with h5py.File('complex_read.hdf5', 'r') as f: d1 = f['array_1'] d2 = f['array_2'] data = [] for i in range(len(d1)): if d1[i] > 0: data.append(d2[i]) print('The length of data with a for loop: {}'.format(len(data))) 

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

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

चुनिंदा HDF5 फ़ाइलों को लिखें

उपरोक्त उदाहरणों में, हमने जैसे ही यह बनाया गया, डेटा को डेटासेट में जोड़ा। हालांकि, कई अनुप्रयोगों के लिए आपको पीढ़ी के दौरान डेटा को बचाने की आवश्यकता होती है। HDF5 आपको डेटा को उसी तरह से सहेजने की अनुमति देता है जैसे आप इसे पढ़ते हैं। आइए देखें कि एक खाली डेटासेट कैसे बनाया जाता है और इसमें कुछ डेटा कैसे जोड़े जाते हैं।

 arr = np.random.randn(100) with h5py.File('random.hdf5', 'w') as f: dset = f.create_dataset("default", (1000,)) dset[10:20] = arr[50:60] 

create_dataset को छोड़कर पहली दो पंक्तियाँ पहले जैसी हैं। हम इसे बनाते समय डेटा नहीं जोड़ते हैं, हम सिर्फ एक खाली डेटा सेट बनाते हैं जो 1000 तत्वों तक पकड़ सकता है। पहले की तरह ही तर्क के साथ, जब हम डेटा सेट से कुछ तत्वों को पढ़ते हैं, तो हम वास्तव में डिस्क पर लिखते हैं जब हम डिसेंट वेरिएबल के कुछ तत्वों को मान देते हैं। उपरोक्त उदाहरण में, हम केवल 10 से 19 तक सूचकांकों के साथ, सरणी के सबसेट पर मान निर्दिष्ट करते हैं।

चेतावनी

जब आप डेटा सेट पर मान निर्दिष्ट करते हैं तो यह पूरी तरह सच नहीं होता है कि आप डिस्क पर क्या लिखते हैं। सटीक क्षण ऑपरेटिंग सिस्टम की स्थिति सहित कई कारकों पर निर्भर करता है। यदि कार्यक्रम बहुत जल्द बंद हो जाता है, तो ऐसा हो सकता है कि सब कुछ रिकॉर्ड नहीं किया जाएगा। हमेशा close() विधि का उपयोग करना बहुत महत्वपूर्ण है, और यदि आप चरणों में लिखते हैं, तो प्रविष्टि को मजबूर करने के लिए आप flush() का भी उपयोग कर सकते हैं। के साथ प्रयोग करने से बहुत सारी समस्याओं का निवारण होता है।

यदि आप फ़ाइल को पढ़ते हैं और डेटा सेट के पहले 20 मानों को प्रिंट करते हैं, तो आप देखेंगे कि वे सभी शून्य हैं, सिवाय सूचकांक 10 के 19 के माध्यम से। एक सामान्य त्रुटि है जो ध्यान देने योग्य सिरदर्द हो सकती है। निम्नलिखित कोड डिस्क पर कुछ भी नहीं बचाएगा:

 arr = np.random.randn(1000) with h5py.File('random.hdf5', 'w') as f: dset = f.create_dataset("default", (1000,)) dset = arr 

यह त्रुटि हमेशा बहुत सारी समस्याओं का कारण बनती है, क्योंकि आप यह नहीं समझ पाएंगे कि आपने तब तक कुछ नहीं लिखा जब तक आप परिणाम पढ़ने की कोशिश नहीं करते। यहां समस्या यह है कि आप यह निर्दिष्ट नहीं करते हैं कि आप डेटा कहाँ संग्रहीत करना चाहते हैं, आप सिर्फ एक NumPy सरणी के साथ डिस्सेट चर को अधिलेखित करते हैं। चूंकि डेटासेट और सरणी समान लंबाई हैं, इसलिए आपको dset [:] = arr का उपयोग करना चाहिए। यह त्रुटि आपके विचार से अधिक बार होती है, और चूंकि यह तकनीकी रूप से गलत नहीं है, इसलिए आपको टर्मिनल पर प्रदर्शित होने वाली कोई भी त्रुटि नहीं दिखाई देगी, और आपका डेटा शून्य होगा।

अब तक, हमने हमेशा एक आयामी सरणियों के साथ काम किया है, लेकिन हम उनके लिए सीमित नहीं हैं। उदाहरण के लिए, मान लें कि हम एक 2D सरणी का उपयोग करना चाहते हैं, हम बस कर सकते हैं:

 dset = f.create_dataset('default', (500, 1024)) 

जो हमें 500x1024 सरणी में डेटा स्टोर करने की अनुमति देता है। डेटासेट का उपयोग करने के लिए, हम पहले के समान सिंटैक्स का उपयोग कर सकते हैं, लेकिन दूसरे आयाम को ध्यान में रखते हुए:

 dset[1,2] = 1 dset[200:500, 500:1024] = 123 

स्पेस ऑप्टिमाइज़ करने के लिए डेटा प्रकार निर्दिष्ट करें

अब तक, हमने केवल हिमशैल के टिप की जांच की है जो एचडीएफ 5 को पेश करना है। आप जिस डेटा को रखना चाहते हैं उसकी लंबाई के अलावा, आप स्पेस को ऑप्टिमाइज़ करने के लिए डेटा टाइप को निर्दिष्ट कर सकते हैं। H5py प्रलेखन में सभी समर्थित प्रकारों की एक सूची है, यहाँ हम उनमें से केवल एक जोड़े को दिखाते हैं। उसी समय, हम एक फ़ाइल में कई डेटा सेट के साथ काम करेंगे।

 with h5py.File('several_datasets.hdf5', 'w') as f: dset_int_1 = f.create_dataset('integers', (10, ), dtype='i1') dset_int_8 = f.create_dataset('integers8', (10, ), dtype='i8') dset_complex = f.create_dataset('complex', (10, ), dtype='c16') dset_int_1[0] = 1200 dset_int_8[0] = 1200.1 dset_complex[0] = 3 + 4j 

उपरोक्त उदाहरण में, हमने तीन अलग-अलग डेटा सेट बनाए, जिनमें से प्रत्येक का एक अलग प्रकार है। 1 बाइट के पूर्णांक, 8 बाइट्स के पूर्णांक और 16 बाइट्स की जटिल संख्या। हम केवल एक नंबर स्टोर करते हैं, भले ही हमारे डेटा सेट में 10 तत्व हो सकते हैं। आप मूल्यों को पढ़ सकते हैं और देख सकते हैं कि वास्तव में क्या बचा था। यहां यह ध्यान दिया जाना चाहिए कि 1 बाइट के पूर्णांक को 127 (1200 के बजाय) के लिए और 8 बाइट्स के पूर्णांक को 1200 (1200.1 के बजाय) पर गोल किया जाना चाहिए।

यदि आपने कभी C या फोरट्रान जैसी भाषाओं में प्रोग्राम किया है, तो आप शायद जानते हैं कि विभिन्न प्रकार के डेटा का क्या अर्थ है। हालाँकि, यदि आपने हमेशा पायथन के साथ काम किया है, तो आपके द्वारा काम कर रहे डेटा के प्रकार को स्पष्ट रूप से घोषित किए बिना आपको किसी भी समस्या का सामना नहीं करना पड़ सकता है। यह याद रखना महत्वपूर्ण है कि बाइट्स की संख्या आपको बताती है कि आप कितने अलग-अलग नंबर बचा सकते हैं। यदि आप 1 बाइट का उपयोग करते हैं, तो आपके पास 8 बिट्स हैं, और इसलिए आप 2 ^ 8 विभिन्न नंबरों को स्टोर कर सकते हैं। उपरोक्त उदाहरण में, पूर्णांक दोनों सकारात्मक, नकारात्मक हैं, और 0. जब आप 1 बाइट के पूर्णांक का उपयोग करते हैं, तो आप कुल 2 ^ 8 संभावित संख्याओं के लिए -128 से 127 तक मान स्टोर कर सकते हैं। यह 8 बाइट्स का उपयोग करने के बराबर है, लेकिन संख्या की एक विस्तृत श्रृंखला के साथ।

चयनित डेटा का आकार उसके आकार को प्रभावित करेगा। सबसे पहले, आइए देखें कि यह एक साधारण उदाहरण के साथ कैसे काम करता है। चलो तीन फाइलें बनाते हैं, जिनमें से प्रत्येक 100,000 तत्वों के लिए एक डेटा सेट है, लेकिन विभिन्न डेटा प्रकारों के साथ। हम उनमें समान डेटा सहेजेंगे, और फिर उनके आकार की तुलना करेंगे। हम मेमोरी को भरने के लिए सेट किए गए प्रत्येक डेटा को असाइनमेंट के लिए एक यादृच्छिक सरणी बनाते हैं। याद रखें कि डेटा सेट में निर्दिष्ट प्रारूप में परिवर्तित हो जाएगा।

 arr = np.random.randn(100000) f = h5py.File('integer_1.hdf5', 'w') d = f.create_dataset('dataset', (100000,), dtype='i1') d[:] = arr f.close() f = h5py.File('integer_8.hdf5', 'w') d = f.create_dataset('dataset', (100000,), dtype='i8') d[:] = arr f.close() f = h5py.File('float.hdf5', 'w') d = f.create_dataset('dataset', (100000,), dtype='f16') d[:] = arr f.close() 

जब आप प्रत्येक फ़ाइल का आकार जांचते हैं, तो आपको कुछ ऐसा मिलेगा:

फ़ाइल	आकार (बी)
पूर्णांक_1	102,144
integer_9	802,144
नाव	1602144

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

कृपया ध्यान दें: यदि आप गलत डेटा प्रकार का उपयोग करते हैं, तो आप जानकारी भी खो सकते हैं। उदाहरण के लिए, यदि आपके पास 8 बाइट्स के पूर्णांक हैं, और आप उन्हें 1 बाइट के पूर्णांक के रूप में संग्रहीत करते हैं, तो उनके मानों को छोटा कर दिया जाएगा। प्रयोगशाला में काम करते समय, विभिन्न प्रकार के डेटा बनाने वाले उपकरण अक्सर उपलब्ध होते हैं। कुछ DAQ कार्ड में 16 बिट्स होते हैं, कुछ कैमरे 8 बिट्स के साथ काम करते हैं, लेकिन उनमें से कुछ 24 के साथ काम कर सकते हैं। डेटा प्रकारों पर ध्यान देना महत्वपूर्ण है, लेकिन यह भी कुछ ऐसा है जिसे पायथन डेवलपर्स को ध्यान में नहीं रखना चाहिए, क्योंकि आपको इसकी आवश्यकता नहीं है घोषणा प्रकार।

यह याद रखना भी दिलचस्प है कि डिफ़ॉल्ट न्यूमपी सरणी 8 बाइट्स (64 बिट्स) प्रति तत्व के साथ फ्लोट होगी। यह एक समस्या हो सकती है यदि, उदाहरण के लिए, आप डेटा संग्रहीत करने के लिए शून्य के साथ एक सरणी को आरंभीकृत करते हैं, जो केवल 2 बाइट्स होना चाहिए। सरणी का प्रकार स्वयं नहीं बदलेगा, और यदि आप डेटा सेट बनाते समय डेटा सहेजते हैं (डेटा = my_array जोड़कर), तो डिफ़ॉल्ट प्रारूप "f8" होगा, जो कि एक सरणी है, लेकिन वास्तविक डेटा नहीं है,

डेटा प्रकारों के बारे में सोचना कुछ ऐसा नहीं है जो नियमित रूप से होता है यदि आप सरल अनुप्रयोगों में पायथन के साथ काम करते हैं। हालाँकि, आपको पता होना चाहिए कि डेटा प्रकार मौजूद हैं और आपके परिणामों पर उनका क्या प्रभाव पड़ सकता है। आपके पास बड़ी हार्ड ड्राइव हो सकती हैं और आप वास्तव में फ़ाइल संग्रहण की परवाह नहीं करते हैं, लेकिन जब आप उस गति की परवाह करते हैं जिसके साथ आप बचत करते हैं, तो आपके कोड के हर पहलू को अनुकूलित करने के अलावा कोई अन्य तरीका नहीं है, जिसमें डेटा प्रकार शामिल हैं।

डेटा संपीड़न

डेटा सहेजते समय, आप विभिन्न एल्गोरिदम का उपयोग करके संपीड़न चुन सकते हैं। H5py पैकेज कई संपीड़न फिल्टर का समर्थन करता है, जैसे कि GZIP, LZF और SZIP। संपीड़न फिल्टर में से एक का उपयोग करते समय, डेटा को डिस्क पर अपने रास्ते पर संसाधित किया जाएगा, और पढ़ने पर इसे अनपैक किया जाएगा। इसलिए, कोड में कोई विशेष परिवर्तन नहीं हैं। हम एक ही प्रयोग को दोहरा सकते हैं, विभिन्न प्रकार के डेटा को बचा सकते हैं, लेकिन एक संपीड़न फ़िल्टर का उपयोग करके। हमारा कोड इस तरह दिखता है:

 import h5py import numpy as np arr = np.random.randn(100000) with h5py.File('integer_1_compr.hdf5', 'w') as f: d = f.create_dataset('dataset', (100000,), dtype='i1', compression="gzip", compression_opts=9) d[:] = arr with h5py.File('integer_8_compr.hdf5', 'w') as f: d = f.create_dataset('dataset', (100000,), dtype='i8', compression="gzip", compression_opts=9) d[:] = arr with h5py.File('float_compr.hdf5', 'w') as f: d = f.create_dataset('dataset', (100000,), dtype='f16', compression="gzip", compression_opts=9) d[:] = arr 

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

टाइप	कोई संपीड़न नहीं	संपीड़न 9	संपीड़न ४
पूर्णांक_1	102,144	28016	30,463
integer_8	802,144	43,329	57,971
नाव	1602144	1469580	1469868

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

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

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

डेटासेट का आकार बदलें

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

 import h5py import numpy as np with h5py.File('resize_dataset.hdf5', 'w') as f: d = f.create_dataset('dataset', (100, ), maxshape=(500, )) d[:100] = np.random.randn(100) d.resize((200,)) d[100:200] = np.random.randn(100) with h5py.File('resize_dataset.hdf5', 'r') as f: dset = f['dataset'] print(dset[99]) print(dset[199]) 

सबसे पहले, आप 100 मानों को संग्रहीत करने के लिए एक डाटासेट बनाते हैं और अधिकतम आकार 500 मानों पर सेट करते हैं। मानों के पहले बैच को सहेजने के बाद, आप अगले 100 को सहेजने के लिए डेटा सेट का विस्तार कर सकते हैं। आप प्रक्रिया को दोहरा सकते हैं जब तक कि आप 500 मानों के साथ डेटा सेट प्राप्त न कर लें। , N- . , , .

, , . , - ( , , ):

 with h5py.File('resize_dataset.hdf5', 'a') as f: dset = f['dataset'] dset.resize((300,)) dset[:200] = 0 dset[200:300] = np.random.randn(100) with h5py.File('resize_dataset.hdf5', 'r') as f: dset = f['dataset'] print(dset[99]) print(dset[199]) print(dset[299]) 

, , 200 200 299. , , .

, , , . 2D-, , — , 2D-. 3- HDF-, . , :

 with h5py.File('movie_dataset.hdf5', 'w') as f: d = f.create_dataset('dataset', (1024, 1024, 1), maxshape=(1024, 1024, None )) d[:,:,0] = first_frame d.resize((1024,1024,2)) d[:,:,1] = second_frame 

1024x1024 , . , , . maxshape None.

(Chunks)

, . (chunk) , .. . , , . , :

 dset = f.create_dataset("chunked", (1000, 1000), chunks=(100, 100)) 

, dset [0: 100,0: 100] . dset [200: 300, 200: 300], dset [100: 200, 400: 500] . . h5py, :

(Chunking) . 10 KiB 1 MiB, . , , .

(auto-chunking), . , maxshape. :

 dset = f.create_dataset("autochunk", (1000, 1000), chunks=True) 

(Groups)

. HDF5, , . (groups), , . , :

 import numpy as np import h5py arr = np.random.randn(1000) with h5py.File('groups.hdf5', 'w') as f: g = f.create_group('Base_Group') gg = g.create_group('Sub_Group') d = g.create_dataset('default', data=arr) dd = gg.create_dataset('default', data=arr) 

Base_Group , Sub_Group. default . , , :

 with h5py.File('groups.hdf5', 'r') as f: d = f['Base_Group/default'] dd = f['Base_Group/Sub_Group/default'] print(d[1]) print(dd[1]) 

, : Base_Group/default Base_Group/Sub_Group/default. , , , , . — keys():

 with h5py.File('groups.hdf5', 'r') as f: for k in f.keys(): print(k) 

, , for-. , . visit(), :

 def get_all(name): print(name) with h5py.File('groups.hdf5', 'r') as f: f.visit(get_all) 

, get_all , , name. visit, get_all. visit , , None, . , , Sub_Group, get_all :

 def get_all(name): if 'Sub_Group' in name: return name with h5py.File('groups.hdf5', 'r') as f: g = f.visit(get_all) print(g) 

visit , , None, , get_all. Sub_Group, get_all , Sub_Group . , g , , :

 with h5py.File('groups.hdf5', 'r') as f: g_name = f.visit(get_all) group = f[g_name] 

. — , visititems, : name object. :

 def get_objects(name, obj): if 'Sub_Group' in name: return obj with h5py.File('groups.hdf5', 'r') as f: group = f.visititems(get_objects) data = group['default'] print('First data element: {}'.format(data[0])) 

visititems , , , . , , . . , , .

HDF5

, HDF5, , . , , , , , , .. . , , 200x300x250. , , , , — , .

HDF5 -. .

 import time import numpy as np import h5py import os arr = np.random.randn(1000) with h5py.File('groups.hdf5', 'w') as f: g = f.create_group('Base_Group') d = g.create_dataset('default', data=arr) g.attrs['Date'] = time.time() g.attrs['User'] = 'Me' d.attrs['OS'] = os.name for k in g.attrs.keys(): print('{} => {}'.format(k, g.attrs[k])) for j in d.attrs.keys(): print('{} => {}'.format(j, d.attrs[j])) 

, attrs . , , . , . , , , update:

 with h5py.File('groups.hdf5', 'w') as f: g = f.create_group('Base_Group') d = g.create_dataset('default', data=arr) metadata = {'Date': time.time(), 'User': 'Me', 'OS': os.name,} f.attrs.update(metadata) for m in f.attrs.keys(): print('{} => {}'.format(m, f.attrs[m])) 

, , hdf5, . , . hdf5, . Python -. JSON, , , , pickle.

 import json with h5py.File('groups_dict.hdf5', 'w') as f: g = f.create_group('Base_Group') d = g.create_dataset('default', data=arr) metadata = {'Date': time.time(), 'User': 'Me', 'OS': os.name,} m = g.create_dataset('metadata', data=json.dumps(metadata)) 

, . , . , json.dumps, . , HDF5. , json.loads:

अजगर

 with h5py.File('groups_dict.hdf5', 'r') as f: metadata = json.loads(f['Base_Group/metadata'][()]) for k in metadata: print('{} => {}'.format(k, metadata[k])) 

json , . YAML, XML .. , , , attr , , .

HDF5

, . , , , . HDF , , , , , . , HDF .

HDF5 . , , . , . . SQL, HDFql , SQL HDF5.

. , , - , , . , . , , .

HDF5 — , . , , , , . HDF5 — , , .

अंत

, .