cuML Aprendizado de Máquina

Habilidade de Aprendizado de Máquina cuML

Aprendizado de máquina acelerado por GPU usando NVIDIA RAPIDS cuML. cuML fornece uma API compatível com scikit-learn que executa em GPUs NVIDIA, permitindo acelerações massivas em grandes conjuntos de dados.

Quando Usar Esta Habilidade

Use esta habilidade quando:

• Treinar modelos de classificação (prever categorias, detectar fraudes, classificar texto)
• Treinar modelos de regressão (prever valores, prever preços, estimar quantidades)
• Agrupar dados (segmentar clientes, agrupar documentos, encontrar padrões)
• Redução de dimensionalidade (visualizar dados de alta dimensão, comprimir features)
• Pré-processamento e engenharia de features em grandes conjuntos de dados
• Qualquer tarefa de ML em conjuntos de dados com 10K+ linhas onde a aceleração por GPU ajuda

Inicialização (OBRIGATÓRIO)

Sempre inicie cada script com este boilerplate. Ele testa operações reais de GPU ML.

import pandas as pd
import numpy as np

try:
    import cudf
    import cuml
    # Teste de fumaça: verifica se GPU ML funciona de ponta a ponta
    _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 indisponível, utilizando scikit-learn como fallback: {e}")
    GPU = False

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

def to_pd(df):
    """Converte saída cuML/cuDF para pandas. Use isto em vez de .to_pandas() diretamente."""
    if not GPU:
        return df
    try:
        return df.to_pandas()
    except Exception as e:
        print(f"[GPU] .to_pandas() falhou, usando fallback Arrow: {e}")
        return df.to_arrow().to_pandas()

Padrões de Importação

# 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
# Fallback 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 não está no sklearn — pule ou instale com pip install umap-learn

Referência Rápida

Divisão Treino/Teste (Comece Aqui)

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)

Classificação

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"Acurácia: {accuracy:.4f}")

# Importância de features (apenas modelos de árvore)
importances = to_pd(model.feature_importances_)
for name, imp in zip(feature_names, importances):
    print(f"  {name}: {imp:.4f}")

Regressão

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"Pontuação R²: {r2:.4f}")
print(f"MSE: {mse:.4f}")

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

Agrupamento (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"Inércia: {inertia:.2f}")
print(f"Tamanhos dos clusters: {labels.value_counts().sort_index().to_dict()}")
print(f"Centroides:\n{centroids}")

Redução de Dimensionalidade (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"Variância explicada: {[f'{v:.4f}' for v in variance_ratio]}")
print(f"Total explicado: {float(sum(variance_ratio)):.4f}")

Redução de Dimensionalidade (UMAP — apenas 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 do embedding UMAP: {embedding.shape}")

Pré-processamento

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

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

Requisitos de Tipo de Dado

• cuML requer float32 ou float64 para features. Sempre converta: X.astype("float32")
• Alvos inteiros (rótulos de classificação) funcionam diretamente
• Colunas categóricas devem ser codificadas primeiro (LabelEncoder ou OneHotEncoder)
• cuML NÃO suporta matrizes esparsas — sempre use dados densos

Armadilhas

Problema	Correção
TypeError: sparse input	Converta para denso: X.toarray() ou não use esparso
PCA solver='randomized' falha	Use solver='full' ou omita (cuML seleciona automaticamente)
UMAP indisponível na CPU	Pule UMAP no modo CPU ou pip install umap-learn
Float64 mais lento que float32	Converta para float32: X.astype("float32")
Grande conjunto de dados OOM	Reduza features ou amostre dados antes do ajuste

Diretrizes de Saída

Ao relatar resultados de ML:

• Inclua a forma do conjunto de dados (linhas × features) e distribuição do alvo
• Mostre os tamanhos da divisão treino/teste
• Reporte métricas chave em uma tabela formatada (acurácia, R², MSE, etc.)
• Para classificação: mostre métricas por classe se multi-classe
• Para agrupamento: mostre tamanhos dos clusters e resumos dos centroides
• Para redução de dimensionalidade: mostre taxas de variância explicada
• Liste importâncias de features ranqueadas por magnitude
• Note quaisquer problemas de qualidade de dados (desequilíbrio de classes, valores ausentes, outliers)