पायथन पांडा: 2,000,000 डेटाफ्रेम पंक्तियों को बाइनरी मैट्रिक्स (pd.get_dummies()) में स्मृति त्रुटि के बिना कनवर्ट करें?

Question

मैं 2,000,000 पंक्तियों के साथ रिकॉर्ड की एक बड़ी फ़ाइल संसाधित कर रहा हूं। प्रत्येक पंक्ति में क्रमशः गैर-स्पैम या स्पैम के लिए ईमेल और बाइनरी लेबल [0,1] के बारे में सुविधाएं शामिल हैं।

मैं email_type जैसी सभी सुविधाओं को परिवर्तित करना चाहता हूं जो [1,10] से बाइनरी मैट्रिक्स में मान लेते हैं।

इसे pd.get_dummies() का उपयोग करके पूरा किया जा सकता है, जो सुविधाओं के कॉलम से बाइनरी मैट्रिक्स बनाता है।

यह 10,000 पंक्तियों के अनुसार डेटा के एक छोटे से सबमिले पर पूरी तरह से काम करता है। हालांकि, 100,000+ पंक्तियों के लिए, मुझे त्रुटि Killed:9 दिखाई देती है।

इस से निपटने के लिए, मैं कोशिश की है निम्नलिखित:

कदम:

1. स्प्लिट numpyp.array_split()
2. का उपयोग कर 10,000 पंक्तियों के टुकड़ों में DataFrame 10,000 पंक्तियों
से प्रत्येक DataFrame के लिए एक द्विआधारी मैट्रिक्स बनाएं
3. इन्हें डेटाफ्रेम की सूची में जोड़ें
4. इन डेटाफ्रेम को एक साथ जोड़ें (मैं कोलम में अंतर को संरक्षित करने के लिए ऐसा कर रहा हूं एनएस कि प्रत्येक ब्लॉक में शामिल होंगे)

कोड:

# break into chunks 
chunks = (len(df)/10000) + 1 
df_list = np.array_split(df, chunks) 
super_x = [] 
super_y = [] 

# loop through chunks 
for i, df_chunk in enumerate(df_list): 
    # preprocess_data() returns x,y (both DataFrames) 
    [x, y] = preprocess_data(df_chunk) 
    super_x.append(x) 
    super_y.append(y) 

# vertically concatenate DataFrames 
super_x_mat = pd.concat(super_x, axis=0).fillna(0) 
super_y_mat = pd.concat(super_y, axis=0) 

# pickle (in case of further preprocessing) 
super_x_mat.to_pickle('super_x_mat.p') 
super_y_mat.to_pickle('super_y_mat.p') 

# return values as np.ndarray 
x = super_x_mat.values 
y = super_y_mat.values 
return[x, y] 

कुछ उदाहरण उत्पादन:

chunks 13 
chunk 0 2016-04-08 12:46:55.473963 
chunk 1 2016-04-08 12:47:05.942743 
... 
chunk 12 2016-04-08 12:49:16.318680 
Killed: 9 

चरण 2 (बाइनरी मैट्रिक्स के लिए रूपांतरण) 32 ब्लॉक संसाधित करने के बाद स्मृति से बाहर है (320,000 पंक्तियां), हालांकि स्मृति से बाहर हो सकता है क्योंकि खंड df_chunks.append(df) के रूप में डेटाफ्रेम की सूची में जोड़ा गया है।

चरण 3 स्मृति 20 सफलतापूर्वक संसाधित ब्लॉक (200,000 पंक्तियाँ)

आदर्श उत्पादन numpy.ndarray है कि मैं एक sklearn रसद प्रतिगमन वर्गीकारक फ़ीड कर सकते हैं श्रेणीबद्ध करने की कोशिश कर से बाहर है।

मैं अन्य दृष्टिकोणों का प्रयास कैसे कर सकता हूं? मैं इस आकार को अधिक नियमित रूप से डेटासेट पर मशीन लर्निंग से संपर्क करना शुरू कर रहा हूं।

मैं सलाह के बाद कर रहा हूँ और जैसे सुझाव के लिए खुले:

1. प्रत्येक हिस्सा का संसाधन, पूरे dataframe से सभी संभव स्तंभों का उपयोग करने और फिर से संयोजन फ़ाइल डाटा संग्रहण का
2. सुझाव से पहले फ़ाइल के रूप में बचत
3. पूरी तरह से अन्य विभिन्न मैट्रिक्स

Answer 1

का उपयोग कर आप एक गर्म एन्कोडिंग की तरह कुछ कर रहे हैं, या किसी भी मामले में शून्य के बहुत सारे करने जा रहे हैं, तो दृष्टिकोण, आप विपक्ष है sparse matrices का उपयोग कर विचार किया? यह पूर्व प्रसंस्करण के बाद किया जाना चाहिए उदा।:

x=x.to_sparse() 
[x, y] = preprocess_data(df_chunk) 
super_x.append(x) 

एक टिप्पणी:

[x, y] = preprocess_data(df_chunk) 
x = sparse.csr_matrix(x.values) 
super_x.append(x) 

पांडा भी एक sparse type है जब से तुम काट रहे हैं और पंक्ति से शामिल होने, सीएसआर सीएससी बेहतर है।