cuML-aprendizaje-automático

Skill de Aprendizaje Automático cuML

Aprendizaje automático acelerado por GPU usando NVIDIA RAPIDS cuML. cuML proporciona una API compatible con scikit-learn que se ejecuta en GPUs NVIDIA, permitiendo aceleraciones masivas en grandes conjuntos de datos.

Cuándo Usar Este Skill

Usa este skill cuando:

• Entrenes modelos de clasificación (predecir categorías, detectar fraude, clasificar texto)
• Entrenes modelos de regresión (pronosticar valores, predecir precios, estimar cantidades)
• Agrupes datos (segmentar clientes, agrupar documentos, encontrar patrones)
• Reduzcas dimensionalidad (visualizar datos de alta dimensión, comprimir características)
• Preproceses e ingeniería de características en grandes conjuntos de datos
• Cualquier tarea de ML en conjuntos de datos con 10K+ filas donde la aceleración por GPU ayude

Inicialización (OBLIGATORIO)

Siempre comienza cada script con este código estándar. Prueba operaciones ML reales en GPU.

import pandas as pd
import numpy as np

try:
    import cudf
    import cuml
    # Prueba rápida: verificar que GPU ML funcione de extremo a extremo
    _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 no disponible, usando scikit-learn como respaldo: {e}")
    GPU = False

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

def to_pd(df):
    """Convierte salida de cuML/cuDF a pandas. Usa esto en lugar de .to_pandas() directamente."""
    if not GPU:
        return df
    try:
        return df.to_pandas()
    except Exception as e:
        print(f"[GPU] .to_pandas() falló, usando respaldo Arrow: {e}")
        return df.to_arrow().to_pandas()

Patrones de Importación

# Modo 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
# Respaldo 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 no está en sklearn — omitir o instalar con pip install umap-learn

Referencia Rápida

División Entrenamiento/Prueba (Comienza Aquí)

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)

Clasificación

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"Precisión: {accuracy:.4f}")

# Importancia de características (solo modelos de árbol)
importances = to_pd(model.feature_importances_)
for name, imp in zip(feature_names, importances):
    print(f"  {name}: {imp:.4f}")

Regresión

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"Puntaje R²: {r2:.4f}")
print(f"ECM: {mse:.4f}")

# Coeficientes
coeffs = to_pd(model.coef_)
print(f"Intersección: {float(model.intercept_):.4f}")

Agrupamiento (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"Inercia: {inertia:.2f}")
print(f"Tamaños de clúster: {labels.value_counts().sort_index().to_dict()}")
print(f"Centroides:\n{centroids}")

Reducción de Dimensionalidad (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"Varianza explicada: {[f'{v:.4f}' for v in variance_ratio]}")
print(f"Total explicada: {float(sum(variance_ratio)):.4f}")

Reducción de Dimensionalidad (UMAP — solo GPU)

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"Forma del embedding UMAP: {embedding.shape}")

Preprocesamiento

# Escalar características numéricas
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X.astype("float32"))

# Codificar columnas categóricas
le = LabelEncoder()
df["category_encoded"] = le.fit_transform(df["category"])

Requisitos de Tipo de Datos

• cuML requiere float32 o float64 para las características. Siempre convierte: X.astype("float32")
• Los objetivos enteros (etiquetas de clasificación) funcionan directamente
• Las columnas categóricas deben codificarse primero (LabelEncoder o OneHotEncoder)
• cuML NO admite matrices dispersas — usa siempre datos densos

Problemas Comunes

Problema	Solución
TypeError: sparse input	Convertir a denso: X.toarray() o no usar disperso
PCA solver='randomized' falla	Usar solver='full' o omitir (cuML selecciona automáticamente)
UMAP no disponible en CPU	Omitir UMAP en modo CPU o pip install umap-learn
Float64 más lento que float32	Convertir a float32: X.astype("float32")
Conjunto grande OOM	Reducir características o muestrear datos antes de ajustar

Pautas de Salida

Al reportar resultados de ML:

• Incluir la forma del conjunto de datos (filas × características) y distribución del objetivo
• Mostrar los tamaños de las divisiones entrenamiento/prueba
• Reportar métricas clave en una tabla formateada (precisión, R², ECM, etc.)
• Para clasificación: mostrar métricas por clase si es multiclase
• Para agrupamiento: mostrar tamaños de clúster y resúmenes de centroides
• Para reducción de dimensionalidad: mostrar proporciones de varianza explicada
• Listar importancias de características ordenadas por magnitud
• Notar cualquier problema de calidad de datos (desequilibrio de clases, valores faltantes, valores atípicos)