एक विशाल डस्क डेटाफ्रेम को लकड़ी की छत में सहेज रहा है?

Question

मेरे पास 100,000+ पंक्तियों से बना डेटाफ्रेम है और प्रत्येक पंक्ति में 100,000 कॉलम हैं, पूरी तरह से 10,000,000,000 फ्लोट मान हैं।

मैं एक csv (टैब द्वारा अलग) फ़ाइल में पहले से में उन्हें पढ़ने के लिए प्रबंधित किया है और मैं उन्हें सफलतापूर्वक 250GB रैम के साथ एक 50 कोर जिऑन मशीन के लिए पढ़ सकते हैं और इस तरह के रूप में एक .parq निर्देशिका के रूप में इसे बाहर लिखने की कोशिश:

huge.csv में तैरने तारों के रूप में सहेजे गए थे और यह 125 जीबी है।

import dask.dataframe as dd 
filename = 'huge.csv' 
df = dd.read_csv(filename, delimiter='\t', sample=500000000) 
df.to_parquet('huge.parq') 

यह एक सप्ताह के करीब के लिए huge.parq के लिए लिख दिया गया है और निर्देशिका 14GB है और यह बचत .to_parquet जल्द ही किसी भी समय बंद करने के लिए नहीं जा रहा है की प्रक्रिया की तरह लगता है।

और free -mh दिखाया जा रहा है वहाँ अभी भी है स्मृति उपलब्ध छोड़ दिया लेकिन समय यह .parq निर्देशिका को बचाने के लिए ले रहा है काफी धीमी है कि:

$ free -mh 
       total  used  free  shared buff/cache available 
Mem:   251G   98G   52G   10M  101G  152G 
Swap:   238G   0B  238G 

प्रश्न हैं:

• के आकार को देखते हुए डेटाफ्रेम और मशीन, क्या यह डेटा डेटा फ्रेम को एक लकड़ी की छत फ़ाइल में सहेजने के लिए संभव है?

• क्या यह विशाल डेटाफ्रेम को बचाने के लिए dask और fastparquet के लिए सामान्य है?

• क्या कोई रास्ता तय करने का कोई तरीका है कि यह एक लकड़ी की छत फ़ाइल को बचाने के लिए ले जाएगा?

Answer 1

जैसा कि ऊपर टिप्पणियों में चर्चा की, वहाँ कोई सैद्धांतिक कारण यह है कि .to_parquet() अपने डेटा के साथ सामना नहीं करनी चाहिए। हालांकि, कॉलम की संख्या बेहद बड़ी है, और क्योंकि प्रत्येक के साथ एक ओवरहेड है, यह आश्चर्य की बात नहीं है कि प्रक्रिया में काफी समय लग रहा है - यह सामान्य उपयोग मामला नहीं है।

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

कैसे एक 10k एक्स 10k सरणी स्टोर करने के लिए का एक उदाहरण:

import dask.array as da 
import zarr 
arr = da.random.random(size=(10000, 10000), chunks=(1000, 1000)) 
z = zarr.open_array('z.zarr', shape=(10000, 10000), chunks=(1000, 1000), mode='w', dtype='float64') 
arr.store(z) 

और अब z.zarr/100 डेटा फ़ाइल हिस्सा होता है।

आपके मामले में, मुश्किल हिस्सा डेटा पढ़ रहा है, क्योंकि आप पंक्तियों की संख्या को प्राथमिकता नहीं जानते हैं। आप इस्तेमाल कर सकते हैं

df = dataframe.read_csv(..) 
len(df) # get length 
z = zarr.open_arr(...) # provide dtype, size and chunk appropriately 
df.values.store(z) 

या इसे और अधिक dask.delayed साथ np.loadtxt रैप करने के लिए dataframe मंच छोड़ करने कुशल हो सकता है।