Panda di Python: convertire 2.000.000 di righe DataFrame in Matrix binario (pd.get_dummies()) senza errori di memoria?

Question

Sto elaborando un grande file di record con le righe 2,000,000. Ogni riga contiene funzionalità relative alle e-mail e un'etichetta binaria [0,1] rispettivamente per non-spam o spam.

Voglio convertire tutte le funzionalità come email_type che assume valori da [1,10] a una matrice binaria.

Questo può essere eseguito utilizzando pd.get_dummies(), che crea una matrice binaria da una colonna di funzioni.

Questo funziona perfettamente su un piccolo sotto campione dei dati, ad esempio 10,000 righe. Tuttavia, per le righe 100,000+, vedo l'errore Killed:9.

Per affrontare questo, ho provato quanto segue:

Passi:

1. Spalato il dataframe in blocchi di 10.000 righe utilizzando numpyp.array_split()
2. Creare una matrice binaria per ogni dataframe di 10.000 righe
3. Aggiungili a un elenco di DataFrames
4. Concatena questi DataFram insieme (lo sto facendo per mantenere la differenza in colum ns che ogni blocco conterrà)

Codice:

# 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] 

Qualche esempio di output:

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 

Fase 2 (conversione a matrice binaria) è fuori la memoria dopo la trasformazione 32 blocchi (320,000 righe), tuttavia la memoria insufficiente potrebbe verificarsi quando il blocco viene aggiunto a un elenco di dati come segue df_chunks.append(df).

Fase 3 è fuori di memoria La concatenazione 20 blocchi trasformati con successo (200,000 righe)

L'uscita ideale è numpy.ndarray che posso alimentare ad una logistica classificatore sklearn regressione.

Quali altri approcci posso provare? Sto iniziando ad avvicinarmi all'apprendimento automatico su set di dati di queste dimensioni più regolarmente.

che sto cercando consiglio e aperti a suggerimenti come:

1. elaborazione di ogni pezzo, utilizzando tutte le possibili colonne da tutta dataframe e salvare come file prima di ri-unisce
2. Suggerimenti di archiviazione dei dati di file
3. Completamente altri approcci che utilizzano diverse matrici

Answer 1

Se si sta facendo qualcosa come una codifica a caldo, o comunque avranno molti zeri, avete progettato con sparse matrices? Questo dovrebbe essere fatto dopo la pre-elaborazione, ad es.: Ha

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

pandi anche un sparse type: nota

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

Uno: poiché si sta tagliando e unendo per riga, csr è preferibile CSC.