cuML-Machine-Learning

cuML Machine Learning Skill

GPU-beschleunigtes maschinelles Lernen mit NVIDIA RAPIDS cuML. cuML bietet eine scikit-learn-kompatible API, die auf NVIDIA-GPUs läuft und massive Beschleunigungen bei großen Datensätzen ermöglicht.

Wann dieser Skill verwendet werden sollte

Verwenden Sie diesen Skill bei:

• Training von Klassifikationsmodellen (Kategorien vorhersagen, Betrug erkennen, Text klassifizieren)
• Training von Regressionsmodellen (Werte prognostizieren, Preise vorhersagen, Mengen schätzen)
• Clustering von Daten (Kunden segmentieren, Dokumente gruppieren, Muster finden)
• Dimensionsreduktion (hochdimensionale Daten visualisieren, Merkmale komprimieren)
• Vorverarbeitung und Merkmalsextraktion bei großen Datensätzen
• Jeder ML-Aufgabe mit Datensätzen ab 10.000+ Zeilen, bei der GPU-Beschleunigung hilfreich ist

Initialisierung (ERFORDERLICH)

Beginnen Sie jedes Skript mit diesem Boilerplate-Code. Er testet tatsächliche GPU-ML-Operationen.

import pandas as pd
import numpy as np

try:
    import cudf
    import cuml
    # Smoke-Test: überprüft, ob GPU-ML Ende-zu-Ende funktioniert
    _test_data = cudf.DataFrame({'a': [1.0, 2.0, 3.0, 4.0], 'b': [5.0, 6.0, 7.0, 8.0]})
    _km = cuml.cluster.KMeans(n_clusters=2, n_init=1, random_state=42)
    _km.fit(_test_data)
    assert len(_km.labels_) == 4
    GPU = True
except Exception as e:
    print(f"[GPU] cuml nicht verfügbar, Fallback auf scikit-learn: {e}")
    GPU = False

def read_csv(pfad):
    return cudf.read_csv(pfad) if GPU else pd.read_csv(pfad)

def to_pd(df):
    """Konvertiert cuML/cuDF-Ausgabe in pandas. Dies statt .to_pandas() direkt verwenden."""
    if not GPU:
        return df
    try:
        return df.to_pandas()
    except Exception as e:
        print(f"[GPU] .to_pandas() fehlgeschlagen, Arrow-Fallback verwendet: {e}")
        return df.to_arrow().to_pandas()

Importmuster

# GPU-Modus
if GPU:
    from cuml.cluster import KMeans, DBSCAN, HDBSCAN
    from cuml.ensemble import RandomForestClassifier, RandomForestRegressor
    from cuml.linear_model import LinearRegression, Ridge, Lasso, LogisticRegression
    from cuml.neighbors import KNeighborsClassifier, KNeighborsRegressor
    from cuml.svm import SVC, SVR
    from cuml.decomposition import PCA, TruncatedSVD
    from cuml.manifold import UMAP, TSNE
    from cuml.preprocessing import StandardScaler, MinMaxScaler, LabelEncoder
    from cuml.model_selection import train_test_split
    from cuml.metrics import accuracy_score, r2_score, mean_squared_error
# CPU-Fallback
else:
    from sklearn.cluster import KMeans, DBSCAN, HDBSCAN
    from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
    from sklearn.linear_model import LinearRegression, Ridge, Lasso, LogisticRegression
    from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
    from sklearn.svm import SVC, SVR
    from sklearn.decomposition import PCA, TruncatedSVD
    from sklearn.manifold import TSNE
    from sklearn.preprocessing import StandardScaler, MinMaxScaler, LabelEncoder
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score, r2_score, mean_squared_error
    # UMAP nicht in sklearn – überspringen oder `pip install umap-learn`

Kurzreferenz

Train/Test-Split (Hier beginnen)

X = df[["merkmal1", "merkmal2", "merkmal3"]].astype("float32")
y = df["ziel"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Klassifikation

model = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
model.fit(X_train, y_train)

vorhersagen = model.predict(X_test)
genauigkeit = float(accuracy_score(to_pd(y_test), to_pd(vorhersagen)))
print(f"Genauigkeit: {genauigkeit:.4f}")

# Merkmalswichtigkeiten (nur Baummodelle)
wichtigkeiten = to_pd(model.feature_importances_)
for name, imp in zip(merkmalnamen, wichtigkeiten):
    print(f"  {name}: {imp:.4f}")

Regression

model = Ridge(alpha=1.0)
model.fit(X_train, y_train)

vorhersagen = model.predict(X_test)
r2 = float(r2_score(to_pd(y_test), to_pd(vorhersagen)))
mse = float(mean_squared_error(to_pd(y_test), to_pd(vorhersagen)))
print(f"R²-Score: {r2:.4f}")
print(f"MSE: {mse:.4f}")

# Koeffizienten
koeffizienten = to_pd(model.coef_)
print(f"Achsenabschnitt: {float(model.intercept_):.4f}")

Clustering (KMeans)

X = df[["merkmal1", "merkmal2"]].astype("float32")

model = KMeans(n_clusters=4, n_init=10, random_state=42)
model.fit(X)

labels = to_pd(model.labels_)
zentren = to_pd(model.cluster_centers_)
traegheit = float(model.inertia_)

print(f"Trägheit: {traegheit:.2f}")
print(f"Clustergrößen: {labels.value_counts().sort_index().to_dict()}")
print(f"Zentren:\n{zentren}")

Dimensionsreduktion (PCA)

scaler = StandardScaler()
X_skaliert = scaler.fit_transform(X.astype("float32"))

pca = PCA(n_components=3)
X_reduziert = pca.fit_transform(X_skaliert)

varianz_anteil = to_pd(pca.explained_variance_ratio_)
print(f"Erklärte Varianz: {[f'{v:.4f}' for v in varianz_anteil]}")
print(f"Gesamte erklärte Varianz: {float(sum(varianz_anteil)):.4f}")

Dimensionsreduktion (UMAP – nur GPU)

if GPU:
    reducer = UMAP(n_components=2, n_neighbors=15, min_dist=0.1, random_state=42)
    einbettung = to_pd(reducer.fit_transform(X_skaliert))
    print(f"UMAP-Einbettungsform: {einbettung.shape}")

Vorverarbeitung

# Numerische Merkmale skalieren
scaler = StandardScaler()
X_skaliert = scaler.fit_transform(X.astype("float32"))

# Kategoriale Spalten kodieren
le = LabelEncoder()
df["kategorie_kodiert"] = le.fit_transform(df["kategorie"])

Datenformatanforderungen

• cuML benötigt float32 oder float64 für Merkmale. Immer mit X.astype("float32") umwandeln.
• Ganzzahlige Ziele (Klassifikationslabels) funktionieren direkt.
• Kategoriale Spalten müssen zuerst kodiert werden (LabelEncoder oder OneHotEncoder).
• cuML unterstützt keine dünnbesetzten Matrizen – immer dichte Daten verwenden.

Fallstricke

Problem	Lösung
TypeError: sparse input	In dichte Daten konvertieren: X.toarray() oder keine Sparsity verwenden
PCA solver='randomized' schlägt fehl	solver='full' verwenden oder weglassen (cuML wählt automatisch)
UMAP auf CPU nicht verfügbar	UMAP im CPU-Modus überspringen oder pip install umap-learn
Float64 langsamer als float32	In float32 umwandeln: X.astype("float32")
Großer Datensatz OOM	Reduzieren Sie die Merkmale oder stichproben Sie die Daten vor dem Fitten

Ausgabe-Richtlinien

Beim Melden von ML-Ergebnissen:

• Datensatzform (Zeilen × Merkmale) und Zielverteilung angeben
• Größen von Trainings- und Testsets anzeigen
• Wichtige Metriken in einer formatierten Tabelle ausgeben (Genauigkeit, R², MSE usw.)
• Bei Klassifikation: Metriken pro Klasse anzeigen, wenn mehrklassig
• Bei Clustering: Clustergrößen und Zusammenfassungen der Zentren anzeigen
• Bei Dimensionsreduktion: Anteile der erklärten Varianz anzeigen
• Merkmalswichtigkeiten nach Größe geordnet auflisten
• Datenqualitätsprobleme notieren (Klassenungleichgewicht, fehlende Werte, Ausreißer)