cuML - Machine Learning accéléré par GPU

Compétence Machine Learning cuML

Apprentissage automatique accéléré par GPU avec NVIDIA RAPIDS cuML. cuML fournit une API compatible scikit-learn qui s'exécute sur les GPU NVIDIA, permettant des accélérations massives sur de grands ensembles de données.

Quand utiliser cette compétence

Utilisez cette compétence lorsque :

• Vous entraînez des modèles de classification (prédire des catégories, détecter des fraudes, classifier du texte)
• Vous entraînez des modèles de régression (prévoir des valeurs, prédire des prix, estimer des quantités)
• Vous effectuez du clustering (segmentation client, regroupement de documents, recherche de motifs)
• Vous faites de la réduction de dimensionnalité (visualiser des données haute dimension, compresser des caractéristiques)
• Vous prétraitez ou concevez des caractéristiques sur de grands ensembles de données
• Toute tâche de ML sur des ensembles de données avec 10 000+ lignes où l'accélération GPU est bénéfique

Initialisation (OBLIGATOIRE)

Commencez toujours chaque script avec ce code préparatoire. Il teste les opérations ML GPU réelles.

import pandas as pd
import numpy as np

try:
    import cudf
    import cuml
    # Test de fumée : vérifie que le ML GPU fonctionne de bout en bout
    _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 indisponible, repli sur scikit-learn : {e}")
    GPU = False

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

def to_pd(df):
    """Convertit la sortie cuML/cuDF en pandas. Utilisez cela au lieu de .to_pandas() directement."""
    if not GPU:
        return df
    try:
        return df.to_pandas()
    except Exception as e:
        print(f"[GPU] .to_pandas() a échoué, utilisation du repli Arrow : {e}")
        return df.to_arrow().to_pandas()

Modèles d'import

# Mode GPU
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
# Repli CPU
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 absent de sklearn — ignorer ou pip install umap-learn

Référence rapide

Division train/test (Commencez ici)

X = df[["feature1", "feature2", "feature3"]].astype("float32")
y = df["target"]

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

Classification

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

predictions = model.predict(X_test)
accuracy = float(accuracy_score(to_pd(y_test), to_pd(predictions)))
print(f"Précision : {accuracy:.4f}")

# Importances des caractéristiques (modèles arborescents uniquement)
importances = to_pd(model.feature_importances_)
for name, imp in zip(feature_names, importances):
    print(f"  {name} : {imp:.4f}")

Régression

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

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

# Coefficients
coeffs = to_pd(model.coef_)
print(f"Ordonnée à l'origine : {float(model.intercept_):.4f}")

Clustering (KMeans)

X = df[["feature1", "feature2"]].astype("float32")

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

labels = to_pd(model.labels_)
centroids = to_pd(model.cluster_centers_)
inertia = float(model.inertia_)

print(f"Inertie : {inertia:.2f}")
print(f"Tailles des clusters : {labels.value_counts().sort_index().to_dict()}")
print(f"Centroïdes :\n{centroids}")

Réduction de dimensionnalité (PCA)

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

pca = PCA(n_components=3)
X_reduced = pca.fit_transform(X_scaled)

variance_ratio = to_pd(pca.explained_variance_ratio_)
print(f"Variance expliquée : {[f'{v:.4f}' for v in variance_ratio]}")
print(f"Total expliqué : {float(sum(variance_ratio)):.4f}")

Réduction de dimensionnalité (UMAP — GPU uniquement)

if GPU:
    reducer = UMAP(n_components=2, n_neighbors=15, min_dist=0.1, random_state=42)
    embedding = to_pd(reducer.fit_transform(X_scaled))
    print(f"Forme du plongement UMAP : {embedding.shape}")

Prétraitement

# Normaliser les caractéristiques numériques
scaled = StandardScaler()
X_scaled = sc.al.fit_transform(X.astype("float32"))

# Encoder les colonnes catégorielles
le = LabelEncoder()
df["category_encoded"] = le.fit_transform(df["category"])

Exigences de type de données

• cuML nécessite des caractéristiques en float32 ou float64. Convertissez toujours : X.astype("float32")
• Les cibles entières (étiquettes de classification) fonctionnent directement
• Les colonnes catégorielles doivent être encodées au préalable (LabelEncoder ou OneHotEncoder)
• cuML ne prend PAS en charge les matrices creuses — utilisez toujours des données denses

Pièges courants

Problème	Correction
TypeError: sparse input	Convertir en dense : X.toarray() ou ne pas utiliser de creuse
PCA solver='randomized' échoue	Utiliser solver='full' ou omettre (cuML sélectionne automatiquement)
UMAP indisponible sur CPU	Ignorer UMAP en mode CPU ou pip install umap-learn
Float64 plus lent que float32	Convertir en float32 : X.astype("float32")
Grand jeu de données OOM	Réduire les caractéristiques ou échantillonner les données avant l'ajustement

Directives de sortie

Lors du rapport des résultats ML :

• Inclure la forme du jeu de données (lignes × caractéristiques) et la distribution de la cible
• Afficher les tailles des divisions train/test
• Rapporter les métriques clés dans un tableau formaté (précision, R², MSE, etc.)
• Pour la classification : afficher les métriques par classe si multi-classe
• Pour le clustering : afficher les tailles des clusters et les résumés des centroïdes
• Pour la réduction de dimensionnalité : afficher les ratios de variance expliquée
• Lister les importances des caractéristiques classées par ordre de grandeur
• Noter tout problème de qualité des données (déséquilibre de classe, valeurs manquantes, outliers)