Warum Verkettung von DataFrames, exponentiell langsamer?

Ich habe eine Funktion, die Prozesse, die ein DataFrame, weitgehend zum verarbeiten von Daten in buckets erstellen Sie eine binäre matrix von Funktionen, die in einer bestimmten Spalte mit pd.get_dummies(df[col]).

Zu vermeiden, Verarbeitung all meine Daten mit dieser Funktion auf einmal (das geht out of memory und Ursachen iPython zum Absturz), ich habe gebrochen die große DataFrame in Stücke Verwendung:

chunks = (len(df) / 10000) + 1
df_list = np.array_split(df, chunks)

pd.get_dummies(df) automatisch neue Spalten erstellen, basierend auf dem Inhalt der df[col] - und diese unterscheiden sich mit hoher Wahrscheinlichkeit für jeden df im df_list.

Nach der Verarbeitung, ich bin die Verkettung des DataFrames wieder zusammen mit:

for i, df_chunk in enumerate(df_list):
    print "chunk", i
    [x, y] = preprocess_data(df_chunk)
    super_x = pd.concat([super_x, x], axis=0)
    super_y = pd.concat([super_y, y], axis=0)
    print datetime.datetime.utcnow()

Die Bearbeitungszeit der erste chunk ist durchaus akzeptabel, aber es wächst pro Stück! Dies ist nicht zu tun mit der preprocess_data(df_chunk) als dort ist kein Grund, es zu erhöhen. Ist dieser Anstieg in der Zeit, die als Ergebnis des Anrufs zu pd.concat()?

Bitte siehe log unten:

chunks 6
chunk 0
2016-04-08 00:22:17.728849
chunk 1
2016-04-08 00:22:42.387693 
chunk 2
2016-04-08 00:23:43.124381
chunk 3
2016-04-08 00:25:30.249369
chunk 4
2016-04-08 00:28:11.922305
chunk 5
2016-04-08 00:32:00.357365

Gibt es einen workaround, um diese Fahrt? Ich habe 2900 Stücke zu verarbeiten, so jede Hilfe wird sehr geschätzt!

Offen für andere Vorschläge in Python!

InformationsquelleAutor jfive | 2016-04-08

37

Nie rufen DataFrame.append oder pd.concat innerhalb einer for-Schleife. Es führt zu quadratischen kopieren.

pd.concat gibt ein neues DataFrame. Der Raum zugeteilt, für die neue
DataFrame, und die Daten vom alten DataFrames kopiert werden in die neue
DataFrame. Betrachten Sie die Menge kopieren, die nach dieser Linie innerhalb der for-loop (vorausgesetzt, jeder x hat Größe 1):
```
super_x = pd.concat([super_x, x], axis=0)

| iteration | size of old super_x | size of x | copying required |
|         0 |                   0 |         1 |                1 |
|         1 |                   1 |         1 |                2 |
|         2 |                   2 |         1 |                3 |
|       ... |                     |           |                  |
|       N-1 |                 N-1 |         1 |                N |
```
1 + 2 + 3 + ... + N = N(N+1)/2. So gibt es O(N**2) Kopien erforderlich
vervollständigen Sie die Schleife.

Betrachten wir nun
```
super_x = []
for i, df_chunk in enumerate(df_list):
    [x, y] = preprocess_data(df_chunk)
    super_x.append(x)
super_x = pd.concat(super_x, axis=0)
```
Anhängen an eine Liste ein - O(1) operation und erfordert nicht kopieren. Jetzt
es ist ein einziger Aufruf pd.concat nachdem die Schleife fertig ist. Dieser Aufruf
pd.concat erfordert N Kopien gemacht werden, da super_x enthält N
DataFrames der Größe 1. Also, wenn so konstruiert, super_x erfordert O(N)
Kopien.
- Hi @unutbu, danke für die ausführliche Erklärung, das wirklich erklärt, die Theorie im detail!
- Ist es möglich die Verkettung von 2900 Blöcke dieser Form, auf diese Weise (43717, 3261)? Die Verarbeitung von Schritt dauert jetzt nur noch 10 Sekunden.
- wenn Sie mit concat in einer Schleife, würde nicht die alte zu löschen dataframes in der Schleife das Problem lösen?
- Das Problem ist die Geschwindigkeit, nicht den Speicher. Die Speichernutzung ist etwa die gleiche in beiden Fällen. Kopieren kann ein langsamer Vorgang, wenn der dataframe ist groß, und/oder die Schleife Durchlaufen wird, viele Male. Zu O(n^2) kopiert wird unnötig langsam, da ist ein O(n) alternative -- append an eine Liste, concat einmal nach der Schleife.
- Minor Kommentar: 1 + 2 + 3 + ... + N = N(N-1)/2 sollte es nicht sein 1 + 2 + 3 + ... + N = N(N+1)/2 ?
- Danke für die Korrektur.
InformationsquelleAutor unutbu

Jedes mal, wenn Sie verketten, das Sie wieder eine Kopie der Daten.

Sie wollen, machen Sie eine Liste Ihrer Stücke, und dann verketten alles, wie der Letzte Schritt.

df_x = []
df_y = []
for i, df_chunk in enumerate(df_list):
    print "chunk", i
    [x, y] = preprocess_data(df_chunk)
    df_x.append(x)
    df_y.append(y)

super_x = pd.concat(df_x, axis=0)
del df_x  # Free-up memory.
super_y = pd.concat(df_y, axis=0)
del df_y  # Free-up memory.

Vielen Dank, dieser behebt das Problem!

InformationsquelleAutor Alexander

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.