Bild vom Herausgeber

# Einführung

Dask ist eine Reihe von Paketen, die parallele Rechenfunktionen nutzen – äußerst nützlich bei der Verarbeitung großer Datenmengen oder beim Erstellen effizienter, datenintensiver Anwendungen wie fortschrittlicher Analyse- und maschineller Lernsysteme. Zu den hervorstechendsten Vorteilen gehört die nahtlose Integration von Dask in bestehende Python-Frameworks, einschließlich der Unterstützung für die gleichzeitige Verarbeitung großer Datenmengen scikit-lernen Module durch parallelisierte Arbeitsabläufe. In diesem Artikel erfahren Sie, wie Sie Dask für eine skalierbare Datenverarbeitung nutzen können, selbst unter begrenzten {Hardware}-Einschränkungen.

# Schritt-für-Schritt-Anleitung

Obwohl es nicht besonders massiv ist, ist das Datensatz zum kalifornischen Wohnungsbau ist relativ groß und daher eine gute Wahl für ein einfaches, anschauliches Codierungsbeispiel, das zeigt, wie Dask und scikit-learn gemeinsam für die Datenverarbeitung in großem Maßstab genutzt werden können.

Dask bietet eine dataframe Modul, das viele Aspekte der Pandas nachahmt DataFrame Objekte zur Verarbeitung großer Datenmengen, die möglicherweise nicht vollständig in den Speicher passen. Wir werden dieses Dask verwenden DataFrame Struktur zum Laden unserer Daten aus einer CSV in ein GitHub-Repository wie folgt:

import dask.dataframe as dd

url = "https://uncooked.githubusercontent.com/gakudo-ai/open-datasets/refs/heads/major/housing.csv"
df = dd.read_csv(url)

df.head()

Hier ein wichtiger Hinweis. Wenn Sie die „Type“ des Datensatzes sehen möchten – die Anzahl der Zeilen und Spalten – ist die Methode etwas schwieriger als nur die Verwendung df.form. Stattdessen sollten Sie Folgendes tun:

num_rows = df.form(0).compute()
num_cols = df.form(1)
print(f"Variety of rows: {num_rows}")
print(f"Variety of columns: {num_cols}")

Ausgabe:

Variety of rows: 20640
Variety of columns: 10

Beachten Sie, dass wir Dasks verwendet haben compute() um träge die Anzahl der Zeilen zu berechnen, aber nicht die Anzahl der Spalten. Die Metadaten des Datensatzes ermöglichen es uns, die Anzahl der Spalten (Merkmale) sofort zu ermitteln, wohingegen die Bestimmung der Anzahl der Zeilen in einem Datensatz, die (hypothetisch) größer als der Speicher – und somit partitioniert – sein könnten, eine verteilte Berechnung erfordert: etwas, das compute() wickelt für uns clear ab.

Datenvorverarbeitung ist meist ein vorheriger Schritt zum Aufbau eines Modells oder Schätzers für maschinelles Lernen. Bevor wir zu diesem Teil übergehen und da der Schwerpunkt dieses praktischen Artikels darauf liegt, zu zeigen, wie Dask zur Verarbeitung von Daten verwendet werden kann, bereinigen und bereiten wir es vor.

Ein häufiger Schritt bei der Datenaufbereitung ist Umgang mit fehlenden Werten. Mit Dask ist der Prozess so nahtlos, als ob wir nur Pandas verwenden würden. Der folgende Code entfernt beispielsweise Zeilen für Instanzen, die fehlende Werte in einem ihrer Attribute enthalten:

df = df.dropna()

num_rows = df.form(0).compute()
num_cols = df.form(1)
print(f"Variety of rows: {num_rows}")
print(f"Variety of columns: {num_cols}")

Jetzt wurde der Datensatz um über 200 Instanzen reduziert und umfasst insgesamt 20433 Zeilen.

Als Nächstes können wir einige numerische Merkmale im Datensatz skalieren, indem wir Scikit-Learns integrieren StandardScaler oder irgendein anderes geeignetes Skalierungsmethode:

from sklearn.preprocessing import StandardScaler

numeric_df = df.select_dtypes(embrace=("quantity"))
X_pd = numeric_df.drop("median_house_value", axis=1).compute()

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_pd)

Beachten Sie vor allem, dass wir in Dask eine Folge von datensatzintensiven Vorgängen ausführen, z. B. das Löschen von Zeilen mit fehlenden Werten und das anschließende Löschen der Zielspalte "median_house_value"müssen wir hinzufügen compute() am Ende der Folge verketteter Operationen. Das liegt daran Datensatztransformationen in Dask werden träge durchgeführt. Einmal compute() aufgerufen wird, wird das Ergebnis der verketteten Transformation des Datensatzes als Pandas materialisiert DataFrame (Dask hängt von Pandas ab, daher müssen Sie die Pandas-Bibliothek nicht explizit in Ihren Code importieren, es sei denn, Sie rufen direkt eine Pandas-exklusive Funktion auf.)

Was ist, wenn wir wollen? Trainieren Sie ein Modell für maschinelles Lernen? Dann sollten wir die Zielvariable extrahieren "median_house_value" und wenden Sie dasselbe Prinzip an, um es in ein Pandas-Objekt zu konvertieren:

y = df("median_house_value")
y_pd = y.compute()

Von nun an besteht der Prozess darin, den Datensatz in Trainings- und Testsätze aufzuteilen und ein Regressionsmodell zu trainieren RandomForestRegressorund die Bewertung seines Fehlers anhand der Testdaten ähnelt vollständig einem traditionellen Ansatz, bei dem Pandas und Scikit-Be taught auf orchestrierte Weise verwendet werden. Da baumbasierte Modelle unempfindlich gegenüber der Function-Skalierung sind, können Sie entweder die unskalierten Options (X_pd) oder die skalierten (X_scaled). Im Folgenden fahren wir mit den oben berechneten skalierten Merkmalen fort:

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
import numpy as np

# Use the scaled function matrix produced earlier
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_pd, test_size=0.2, random_state=42)

mannequin = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
mannequin.match(X_train, y_train)

y_pred = mannequin.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
print(f"RMSE: {rmse:.2f}")

Ausgabe:

# Zusammenfassung

Dask und scikit-learn können zusammen verwendet werden, um skalierbare, parallelisierte Datenverarbeitungsabläufe zu nutzen, um beispielsweise große Datensätze für die Erstellung von Modellen für maschinelles Lernen effizient vorzuverarbeiten. In diesem Artikel wurde gezeigt, wie man Daten mit Dask lädt, bereinigt, vorbereitet und transformiert und anschließend Commonplace-Scikit-Be taught-Instruments für die Modellierung maschinellen Lernens anwendet – und das alles bei gleichzeitiger Optimierung der Speichernutzung und Beschleunigung der Pipeline bei der Verarbeitung großer Datenmengen.

Iván Palomares Carrascosa ist führend, Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Bild von Autor | Ideogramm

Als Datenwissenschaftler verarbeiten wir große Datensätze oder komplexe Modelle, für die eine erhebliche Zeit für den Betrieb erforderlich ist. Um Zeit zu sparen und schneller Ergebnisse zu erzielen, verwenden wir Instruments, die Aufgaben gleichzeitig oder über mehrere Maschinen hinweg ausführen. Zwei beliebte Python -Bibliotheken dafür sind Strahl Und Dask. Beide helfen, die Datenverarbeitung und das Modelltraining zu beschleunigen, sie werden jedoch für verschiedene Arten von Aufgaben verwendet.

In diesem Artikel werden wir erklären, was Ray und Diek sind und wann sie jede auswählen sollen.

# Was sind Dask und Ray?

Dask ist eine Bibliothek, die zum Umgang mit großen Datenmengen verwendet wird. Es ist so konzipiert, dass es auf eine Weise funktioniert PandasAnwesend Numpyoder Scikit-Be taught. Dask zerlegt Daten und Aufgaben in kleinere Teile und führt sie parallel aus. Dies macht es perfekt für Datenwissenschaftler, die ihre Datenanalyse skalieren möchten, ohne viele neue Konzepte zu lernen.

Ray ist ein allgemeineres Instrument, mit dem Sie verteilte Anwendungen erstellen und ausführen können. Es ist besonders stark in maschinellem Lernen und KI -Aufgaben.

Ray hat auch zusätzliche Bibliotheken aufgebaut, wie:

• Ray Melodie zum Tuning von Hyperparametern im maschinellen Lernen
• Strahlzug Für Trainingsmodelle für mehrere GPUs
• Strahlung Für die Bereitstellung von Modellen als Webdienste

Ray ist großartig, wenn Sie skalierbare Pipelines für maschinelles Lernen erstellen oder AI -Anwendungen bereitstellen möchten, die komplexe Aufgaben parallel ausführen müssen.

# Characteristic -Vergleich

Ein strukturierter Vergleich von Dask und Strahl basierend auf den Kernattributen:

# Wann benutzt man was?

Wählen Sie Dask, wenn Sie:

• Verwenden Pandas/NumPy und Skalierbarkeit wollen
• Verarbeiten Sie tabellarische oder Array-ähnliche Daten
• Führen Sie Batch ETL oder Characteristic Engineering durch
• Brauchen dataframe oder array Abstraktionen mit fauler Ausführung

Wählen Sie Ray, wenn Sie:

• Müssen viele unabhängige Python -Funktionen parallel ausführen
• Sie möchten maschinelle Lernpipelines bauen, Modelle bedienen oder langlebige Aufgaben verwalten
• Benötigen Sie eine mikroserviceähnliche Skalierung mit staatlichen Aufgaben

# Ökosystemwerkzeuge

Beide Bibliotheken bieten oder unterstützen eine Reihe von Instruments zur Abdeckung des Datenwissenschaftslebenszyklus, jedoch mit unterschiedlichem Schwerpunkt:

# Reale Szenarien

// Große Datenreinigung und Characteristic Engineering

Verwenden Dask.

Warum? Die Dask integriert reibungslos in pandas Und NumPy. Viele Datenteams verwenden diese Instruments bereits. Wenn Ihr Datensatz zu groß ist, um in den Speicher zu passen, kann Dask ihn in kleinere Teile aufteilen und diese Teile parallel verarbeiten. Dies hilft bei Aufgaben wie dem Reinigen von Daten und dem Erstellen neuer Funktionen.

Beispiel:

import dask.dataframe as dd
import numpy as np

df = dd.read_csv('s3://knowledge/large-dataset-*.csv')
df = df(df('quantity') > 100)
df('log_amount') = df('quantity').map_partitions(np.log)
df.to_parquet('s3://processed/output/')

Dieser Code liest mehrere große CSV -Dateien aus einem S3 -Bucket mit dem parallelen Dask. Es filtert Zeilen, wobei die Menge der Menge mehr als 100 ist, eine Protokolltransformation anwendet und das Ergebnis als Parquetendateien speichert.

// Parallele Hyperparameter -Tuning für maschinelles Lernenmodelle

Verwenden Strahl.

Warum? Ray Melodie eignet sich hervorragend zum Ausprobieren verschiedener Einstellungen beim Coaching von Modellen für maschinelles Lernen. Es integriert sich in Instruments wie Pytorch Und XGBoostund es kann schlechte Läufe frühzeitig stoppen, um Zeit zu sparen.

Beispiel:

from ray import tune
from ray.tune.schedulers import ASHAScheduler

def train_fn(config):
    # Mannequin coaching logic right here
    ...

tune.run(
    train_fn,
    config={"lr": tune.grid_search((0.01, 0.001, 0.0001))},
    scheduler=ASHAScheduler(metric="accuracy", mode="max")
)

Dieser Code definiert eine Trainingsfunktion und verwendet Ray Melodie, um unterschiedliche Lernraten parallel zu testen. Es wird automatisch die beste Konfiguration mit dem ASHA -Scheduler geplant und bewertet.

// Verteilte Array -Berechnungen

Verwenden Dask.

Warum? Dask -Arrays sind hilfreich, wenn sie mit großen Zahlenmengen arbeiten. Es teilt das Array in Blöcke und verarbeitet sie parallel.

Beispiel:

import dask.array as da

x = da.random.random((10000, 10000), chunks=(1000, 1000))
y = x.imply(axis=0).compute()

Dieser Code erstellt ein großes zufälliges Array, das in Stücke unterteilt ist, die parallel verarbeitet werden können. Anschließend berechnet es den Mittelwert jeder Spalte mithilfe der parallelen Rechenleistung von Dask.

// Erstellen eines Finish-to-Finish-maschinellen Lerndienstes

Verwenden Strahl.

Warum? Ray ist nicht nur für Modelltraining, sondern auch für das Servieren und das Lebenszyklusmanagement konzipiert. Mit StrahlungSie können Modelle in der Produktion einsetzen, die Vorverarbeitungslogik parallel ausführen und sogar staatliche Schauspieler skalieren.

Beispiel:

from ray import serve

@serve.deployment
class ModelDeployment:
    def __init__(self):
        self.mannequin = load_model()

    def __call__(self, request_body):
        knowledge = request_body
        return self.mannequin.predict((knowledge))(0)

serve.run(ModelDeployment.bind())

Dieser Code definiert eine Klasse, um ein maschinelles Lernmodell zu laden und über eine API mit Ray Serve zu servieren. Die Klasse erhält eine Anfrage, macht eine Vorhersage mit dem Modell und gibt das Ergebnis zurück.

# Endgültige Empfehlungen

# Abschluss

Ray und Dask sind beide Instruments, die Datenwissenschaftlern helfen, große Datenmengen zu bewältigen und Programme schneller auszuführen. Ray ist intestine für Aufgaben, die viel Flexibilität benötigen, wie z. B. Projekte für maschinelles Lernen. Die Dask ist nützlich, wenn Sie mit ähnlichen Instruments mit großen Datensätzen arbeiten möchten Pandas oder NumPy.

Welches Sie wählen, hängt davon ab, was Ihr Projekt benötigt und welche Artwork der Daten, die Sie haben. Es ist eine gute Idee, beide Beispiele zu versuchen, um zu sehen, welche besser zu Ihrer Arbeit passt.

Jayita Gulati ist ein Fanatic und technische Schriftsteller für maschinelles Lernen, der von ihrer Leidenschaft für den Aufbau maschineller Lernmodelle angetrieben wird. Sie hat einen Grasp -Abschluss in Informatik an der Universität von Liverpool.