Skalierung großer Datensätze

Einführung

Dieses Lab konzentriert sich darauf, wie man Datenanalysen auf größere Datensätze mit pandas skalieren kann. Es behandelt Methoden wie das Laden weniger Daten, die Verwendung effizienter Datentypen, das Teilen von Daten (chunking) und die Nutzung anderer Bibliotheken wie Dask. Es ist wichtig zu beachten, dass pandas eher für In-Memory-Analysen geeignet ist und möglicherweise nicht das beste Tool für sehr große Datensätze ist.

Tipps für die virtuelle Maschine (VM)

Nachdem die VM gestartet wurde, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und auf Jupyter Notebook für die Übung zuzugreifen.

Manchmal müssen Sie möglicherweise einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Operationen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie sich gerne an Labby wenden. Geben Sie uns nach der Sitzung Feedback, und wir werden das Problem umgehend für Sie lösen.

Datensatz generieren

Der erste Schritt besteht darin, einen großen Datensatz für Tests zu generieren. Wir erstellen einen Datensatz mit vielen Spalten, der in einer Parquet-Datei gespeichert werden kann. Dieser Schritt erfordert die Bibliotheken pandas und numpy.

import pandas as pd
import numpy as np

def make_timeseries(start="2000-01-01", end="2000-12-31", freq="1D", seed=None):
    ## Funktion zur Generierung von Zeitreihendaten
    index = pd.date_range(start=start, end=end, freq=freq, name="timestamp")
    n = len(index)
    state = np.random.RandomState(seed)
    columns = {
        "name": state.choice(["Alice", "Bob", "Charlie"], size=n),
        "id": state.poisson(1000, size=n),
        "x": state.rand(n) * 2 - 1,
        "y": state.rand(n) * 2 - 1,
    }
    df = pd.DataFrame(columns, index=index, columns=sorted(columns))
    if df.index[-1] == end:
        df = df.iloc[:-1]
    return df

timeseries = [
    make_timeseries(freq="1T", seed=i).rename(columns=lambda x: f"{x}_{i}")
    for i in range(10)
]
ts_wide = pd.concat(timeseries, axis=1)
ts_wide.to_parquet("timeseries_wide.parquet")

Weniger Daten laden

Anstatt alle Daten zu laden, können wir nur die Spalten laden, die wir benötigen. Hier demonstrieren wir zwei Methoden, um weniger Daten aus der Parquet-Datei zu laden.

## Option 1: Alle Daten laden und dann filtern
columns = ["id_0", "name_0", "x_0", "y_0"]
pd.read_parquet("timeseries_wide.parquet")[columns]

## Option 2: Nur die angeforderten Spalten laden
pd.read_parquet("timeseries_wide.parquet", columns=columns)

Effiziente Datentypen verwenden

Die Standard-Datentypen von pandas sind nicht die speicherplatzeffizientesten. Dieser Schritt zeigt, wie man effizientere Datentypen verwendet, um größere Datensätze im Speicher zu speichern.

ts = make_timeseries(freq="30S", seed=0)
ts.to_parquet("timeseries.parquet")
ts = pd.read_parquet("timeseries.parquet")

## Spalte 'name' in den Typ 'category' umwandeln, um Effizienz zu erhöhen
ts2 = ts.copy()
ts2["name"] = ts2["name"].astype("category")

## Numerische Spalten in die kleinsten möglichen Typen umwandeln
ts2["id"] = pd.to_numeric(ts2["id"], downcast="unsigned")
ts2[["x", "y"]] = ts2[["x", "y"]].apply(pd.to_numeric, downcast="float")

Chunking (Teilen von Daten) verwenden

Chunking ist eine Methode, um ein großes Problem in kleinere Probleme aufzuteilen, die unabhängig voneinander gelöst werden können. Solange jeder Datenblock (Chunk) in den Speicher passt, können Sie mit Datensätzen arbeiten, die viel größer sind als der verfügbare Speicher.

files = pathlib.Path("data/timeseries/").glob("ts*.parquet")
counts = pd.Series(dtype=int)
for path in files:
    df = pd.read_parquet(path)
    counts = counts.add(df["name"].value_counts(), fill_value=0)
counts.astype(int)

Andere Bibliotheken verwenden

Andere Bibliotheken wie Dask können Datensätze verarbeiten, die größer sind als der verfügbare Speicher. Dask bietet eine pandas-ähnliche API und kann Daten parallel verarbeiten.

import dask.dataframe as dd

ddf = dd.read_parquet("data/timeseries/ts*.parquet", engine="pyarrow")

## Häufigkeiten berechnen mit Dask
ddf["name"].value_counts().compute()

Zusammenfassung

In diesem Lab haben wir verschiedene Techniken gezeigt, wie man Datenanalysen auf größere Datensätze skalieren kann, indem man pandas verwendet. Wir haben einen großen Datensatz generiert, gelernt, wie man weniger Daten lädt, effiziente Datentypen und Chunking (Teilen von Daten) einsetzt. Wir haben auch untersucht, wie man andere Bibliotheken wie Dask nutzen kann, um Datensätze zu verarbeiten, die größer sind als der verfügbare Speicher. Die in diesem Lab gelernten Techniken und Konzepte werden bei der Arbeit mit großen Datensätzen in Datenanalyseprojekten nützlich sein.