cuml-machine-learning — Быстрое машинное обучение с использованием GPU

--- name: cuml-machine-learning description: Use for GPU-accelerated machine learning on tabular data using NVIDIA cuML. Triggers when tasks involve classification, regression, clustering, dimensionality reduction, or model training on datasets. --- # cuML Machine Learning Skill GPU-accelerated machine learning using NVIDIA RAPIDS cuML. cuML provides a scikit-learn-compatible API that runs on NVIDIA GPUs, enabling massive speedups on large datasets. ## When to Use This Skill Use this skill when: - Training classification models (predict categories, detect fraud, classify text) - Training regression models (forecast values, predict prices, estimate quantities) - Clustering data (segment customers, group documents, find patterns) - Dimensionality reduction (visualize high-dimensional data, compress features) - Preprocessing and feature engineering on large datasets - Any ML task on datasets with 10K+ rows where GPU acceleration helps ## Initialization (REQUIRED) Always start every script with this boilerplate. It tests actual GPU ML operations. ```python import pandas as pd import numpy as np try: import cudf import cuml # Smoke-test: verify GPU ML works end-to-end _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 unavailable, falling back to 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): """Convert cuML/cuDF output to pandas. Use this instead of .to_pandas() directly.""" if not GPU: return df try: return df.to_pandas() except Exception as e: print(f"[GPU] .to_pandas() failed, using Arrow fallback: {e}") return df.to_arrow().to_pandas() ``` ## Import Patterns ```python # GPU mode 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 not in sklearn — skip or pip install umap-learn ``` ## Quick Reference ### Train/Test Split (Start Here) ```python 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 ```python 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"Accuracy: {accuracy:.4f}") # Feature importances (tree models only) importances = to_pd(model.feature_importances_) for name, imp in zip(feature_names, importances): print(f" {name}: {imp:.4f}") ``` ### Regression ```python 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"R² Score: {r2:.4f}") print(f"MSE: {mse:.4f}") # Coefficients coeffs = to_pd(model.coef_) print(f"Intercept: {float(model.intercept_):.4f}") ``` ### Clustering (KMeans) ```python 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"Inertia: {inertia:.2f}") print(f"Cluster sizes: {labels.value_counts().sort_index().to_dict()}") print(f"Centroids:n{centroids}") ``` ### Dimensionality Reduction (PCA) ```python 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"Explained variance: {[f'{v:.4f}' for v in variance_ratio]}") print(f"Total explained: {float(sum(variance_ratio)):.4f}") ``` ### Dimensionality Reduction (UMAP — GPU only) ```python 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"UMAP embedding shape: {embedding.shape}") ``` ### Preprocessing ```python # Scale numeric features scaler = StandardScaler() X_scaled = scaler.fit_transform(X.astype("float32")) # Encode categorical columns le = LabelEncoder() df["category_encoded"] = le.fit_transform(df["category"]) ``` ## Data Type Requirements - cuML requires **float32 or float64** for features. Always cast: `X.astype("float32")` - Integer targets (classification labels) work directly - Categorical columns must be encoded first (LabelEncoder or OneHotEncoder) - cuML does NOT support sparse matrices — always use dense data ## Gotchas | Issue | Fix | |-------|-----| | `TypeError: sparse input` | Convert to dense: `X.toarray()` or don't use sparse | | PCA `solver='randomized'` fails | Use `solver='full'` or omit (cuML auto-selects) | | UMAP not available on CPU | Skip UMAP in CPU mode or `pip install umap-learn` | | Float64 slower than float32 | Cast to float32: `X.astype("float32")` | | Large dataset OOM | Reduce features or sample data before fitting | ## Output Guidelines When reporting ML results: - Include dataset shape (rows × features) and target distribution - Show train/test split sizes - Report key metrics in a formatted table (accuracy, R², MSE, etc.) - For classification: show per-class metrics if multi-class - For clustering: show cluster sizes and centroid summaries - For dimensionality reduction: show explained variance ratios - List feature importances ranked by magnitude - Note any data quality issues (class imbalance, missing values, outliers)