Bibliotecas Clássicas de Machine Learning

Visão geral

Bibliotecas de aprendizado de máquina “clássico” (classical ML) se concentram em modelos não neurais (ou não predominantemente de aprendizado profundo) como modelos lineares, máquinas de vetores de suporte (support vector machines), árvores de decisão (decision trees) e métodos de conjunto (ensemble methods) como florestas aleatórias (random forests) e árvores de decisão com boosting de gradiente (gradient-boosted decision trees, GBDT). Elas são especialmente fortes para:

• Dados tabulares (planilhas, tabelas relacionais, logs de eventos)
• Conjuntos de dados pequenos a médios (em que o aprendizado profundo pode sofrer overfitting ou ser desnecessário)
• Iteração rápida e linhas de base (baselines) fortes
• Dinâmica de treinamento bem compreendida e boas ferramentas de interpretabilidade

Três bibliotecas dominam esse espaço em Python:

• scikit-learn: a caixa de ferramentas padrão para aprendizado de máquina clássico, com APIs consistentes e fluxos de trabalho de ponta a ponta.
• XGBoost: uma biblioteca de boosting de gradiente altamente otimizada e regularizada — frequentemente uma das melhores em problemas tabulares.
• LightGBM: uma biblioteca de boosting de gradiente rápida e escalável, com treinamento eficiente e recursos práticos fortes (incluindo suporte nativo a categorias).

Essas bibliotecas frequentemente aparecem juntas em projetos reais: scikit-learn para pré-processamento, avaliação e pipelines; XGBoost/LightGBM para modelagem tabular de estado da arte.

Quando o “aprendizado de máquina clássico” é a escolha certa

Bibliotecas de aprendizado de máquina clássico tendem a ser uma boa opção quando:

• Você tem atributos estruturados/tabulares (colunas numéricas + categóricas).
• Os dados não são enormes (ou você quer uma infraestrutura de treinamento mais simples).
• Você precisa de linhas de base fortes rapidamente, ou está construindo um modelo em produção com comportamento previsível.
• Você quer fluxos de trabalho transparentes: validação cruzada, importância de atributos, calibração, análise de erros.

Frameworks de aprendizado profundo (deep learning) (ver Frameworks) normalmente são preferidos para modalidades não estruturadas como imagens, áudio e texto em larga escala, mas mesmo aí modelos clássicos ainda podem brilhar em certas tarefas (por exemplo, TF‑IDF + modelos lineares para classificação de texto).

Fundamentos compartilhados: estimadores, funções objetivo e generalização

A maior parte do treinamento em aprendizado de máquina clássico pode ser vista como a minimização de um objetivo:

[ \min_{\theta} \ \mathcal{L}(\theta; X, y) + \lambda \Omega(\theta) ]

• (\mathcal{L}) é uma função de perda (por exemplo, perda logística, erro quadrático).
• (\Omega) é um regularizador (por exemplo, penalidades L1/L2, restrições em árvores).
• (\lambda) controla a força da regularização.

Ideias-chave que você verá nessas bibliotecas:

• Generalização depende de controlar a complexidade (ver Trade-off Viés-Variância).
• Regularização combate overfitting (ver Regularização).
• Validação cruzada fornece estimativas robustas de desempenho (ver Validação Cruzada).
• Engenharia de atributos pode melhorar dramaticamente o desempenho (ver Engenharia de Atributos).

scikit-learn

O que é

scikit-learn (frequentemente sklearn) é a biblioteca Python fundamental para aprendizado de máquina clássico. Ela oferece:

• Uma ampla gama de algoritmos: modelos lineares, SVMs, árvores, ensembles, agrupamento, redução de dimensionalidade.
• Uma API de estimadores (Estimator API) consistente (fit, predict, transform).
• Ferramentas de primeira linha para:
  • pré-processamento (imputação, escalonamento, codificação)
  • pipelines
  • seleção de modelo (busca em grade/aleatória, validação cruzada)
  • métricas de avaliação e calibração

Casos de uso típicos

1. Linhas de base e prototipação rápida
   • Regressão logística, SVM linear, floresta aleatória, boosting de gradiente como linhas de base rápidas.
2. Pipelines tabulares de ponta a ponta
   • Tratamento de valores ausentes, codificação categórica, escalonamento e modelagem em um único pipeline reproduzível.
3. Classificação de texto com atributos esparsos
   • TF‑IDF + classificador linear frequentemente é competitivo e muito eficiente.
4. Agrupamento e redução de dimensionalidade
   • K-means, DBSCAN, PCA, t-SNE (t-SNE principalmente para visualização).

Pontos fortes

• Excelente biblioteca de “cola”: pré-processamento + validação cruzada + métricas + seleção de modelo.
• APIs estáveis e documentação forte.
• Ótima para colocar modelos clássicos em produção via Pipelines.

Limitações

• As implementações de boosting de gradiente no sklearn são sólidas, mas XGBoost/LightGBM frequentemente superam e escalam melhor em dados tabulares.
• Conjuntos de dados muito grandes podem exigir ferramentas fora da memória (out-of-core) ou distribuídas (ver Dados).

Exemplo prático: um pipeline tabular robusto

Esse padrão é extremamente comum: use ColumnTransformer para colunas heterogêneas, Pipeline para reprodutibilidade e validação cruzada para uma avaliação confiável.

import numpy as np
import pandas as pd

from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression

# Example: X is a pandas DataFrame, y is a binary label
# X = ...
# y = ...

numeric_features = ["age", "income"]
categorical_features = ["country", "device_type"]

numeric_pipe = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
])

categorical_pipe = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("onehot", OneHotEncoder(handle_unknown="ignore")),
])

preprocess = ColumnTransformer(
    transformers=[
        ("num", numeric_pipe, numeric_features),
        ("cat", categorical_pipe, categorical_features),
    ]
)

model = LogisticRegression(max_iter=2000, n_jobs=-1)

clf = Pipeline(steps=[
    ("preprocess", preprocess),
    ("model", model),
])

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(clf, X, y, cv=cv, scoring="roc_auc")
print("Mean ROC-AUC:", scores.mean(), "±", scores.std())

Essa abordagem:

• evita vazamento (leakage) (o pré-processamento é ajustado apenas nos folds de treino),
• é fácil de ajustar,
• é fácil de implantar (serializar o pipeline como um único objeto).

Exemplo prático: TF‑IDF + modelo linear para texto

Para muitos problemas de classificação com textos de comprimento moderado, um modelo linear sobre atributos TF‑IDF é uma linha de base poderosa.

from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import SGDClassifier
from sklearn.model_selection import cross_val_score

text_clf = Pipeline([
    ("tfidf", TfidfVectorizer(ngram_range=(1, 2), min_df=2)),
    ("clf", SGDClassifier(loss="log_loss", alpha=1e-5, random_state=42)),
])

scores = cross_val_score(text_clf, texts, labels, cv=5, scoring="f1")
print(scores.mean())

XGBoost

O que é

XGBoost (eXtreme Gradient Boosting) é uma implementação altamente otimizada de árvores de decisão com boosting de gradiente. Ela ficou famosa por dominar competições tabulares no estilo Kaggle e segue sendo uma escolha preferida para aprendizado de máquina tabular de alto desempenho.

Conceitualmente, o boosting de gradiente ajusta um modelo aditivo:

[ \hat{y}(x) = \sum_{t=1}^{T} f_t(x) ]

em que cada (f_t) é uma árvore de decisão. Cada nova árvore é treinada para reduzir a perda sobre os erros residuais (mais precisamente, o gradiente negativo da perda). O XGBoost usa aproximações de segunda ordem e regularização forte para melhorar estabilidade e desempenho (ver Boosting de Gradiente).

Casos de uso típicos

1. Classificação/regressão tabular
   • previsão de churn, risco de crédito, detecção de fraude, previsão de demanda.
2. Ranqueamento
   • objetivos de aprendizagem para ranqueamento (learning-to-rank) para busca/recomendação.
3. Atributos esparsos e de alta dimensionalidade
   • atributos categóricos com codificação one-hot, atributos no estilo saco de palavras (bag-of-words).
4. Linha de base forte de “melhor esforço”
   • quando você precisa de um dos melhores modelos rapidamente sem modelagem neural pesada.

Por que funciona bem na prática

• Lida com interações não lineares entre atributos sem cruzamentos manuais de atributos.
• Tipicamente exige pouco pré-processamento:
  • não precisa de escalonamento,
  • lida com valores ausentes internamente (direções padrão aprendidas nas árvores).
• Regularização forte controla overfitting:
  • L1/L2 nos pesos das folhas, limites de profundidade da árvore, subamostragem, amostragem de colunas.

Exemplo prático: XGBoost com a API do scikit-learn

O XGBoost se integra bem a pipelines do scikit-learn e às ferramentas de validação cruzada.

from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

X_train, X_val, y_train, y_val = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

xgb = XGBClassifier(
    n_estimators=2000,
    learning_rate=0.03,
    max_depth=6,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_lambda=1.0,
    reg_alpha=0.0,
    tree_method="hist",        # fast histogram algorithm
    eval_metric="auc",
    random_state=42,
)

xgb.fit(
    X_train, y_train,
    eval_set=[(X_val, y_val)],
    verbose=100,
)

pred = xgb.predict_proba(X_val)[:, 1]
print("ROC-AUC:", roc_auc_score(y_val, pred))

Notas:

• Use um conjunto de validação e monitore uma métrica.
• Para conjuntos de dados grandes e velocidade, tree_method="hist" (ou variantes em GPU) é comum.
• Na prática, ajuste max_depth, min_child_weight, subsample, colsample_bytree e reg_lambda.

Considerações práticas

• Calibração: GBDTs podem produzir probabilidades mal calibradas; considere CalibratedClassifierCV quando probabilidades importam.
• Interpretabilidade: use a importância de atributos com cuidado; valores SHAP (SHAP values) são comuns para explicações locais/globais confiáveis (ver Interpretabilidade de Modelos).
• Categóricas: o XGBoost suporta divisões categóricas em versões mais novas, mas muitos pipelines ainda usam codificação one-hot; compare com o suporte categórico nativo do LightGBM dependendo da sua configuração.

LightGBM

O que é

LightGBM (Light Gradient Boosting Machine) é outra biblioteca de GBDT de alto desempenho, projetada para velocidade e escalabilidade. Ela é conhecida por:

• Treinamento muito rápido usando algoritmos baseados em histogramas (histogram-based algorithms)
• Tratamento eficiente de conjuntos de dados grandes
• Crescimento de árvore folha-a-folha (leaf-wise) (frequentemente com convergência mais rápida do que crescimento nível-a-nível (level-wise), mas pode sofrer overfitting sem restrições)
• Suporte nativo a atributos categóricos (comum e altamente prático para dados tabulares)

Casos de uso típicos

1. Aprendizado de máquina tabular em larga escala
   • milhões de linhas, muitas colunas, orçamentos apertados de tempo de treinamento.
2. Atributos categóricos de alta cardinalidade
   • IDs de usuário, IDs de produto, CEPs (com cuidado para evitar vazamento).
3. Tarefas de ranqueamento
   • objetivos de ranqueamento fortes, amplamente usados em pipelines de recomendação/busca.
4. Iteração rápida
   • treinamento rápido torna a busca de hiperparâmetros mais barata.

Exemplo prático: LightGBM para classificação

O LightGBM tem uma API compatível com scikit-learn (LGBMClassifier) e uma API de treinamento de nível mais baixo. A interface no estilo sklearn é a mais fácil para começar:

from lightgbm import LGBMClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import average_precision_score

X_train, X_val, y_train, y_val = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

lgbm = LGBMClassifier(
    n_estimators=5000,
    learning_rate=0.03,
    num_leaves=63,            # key complexity parameter for leaf-wise trees
    subsample=0.8,
    colsample_bytree=0.8,
    reg_lambda=1.0,
    random_state=42,
)

lgbm.fit(
    X_train, y_train,
    eval_set=[(X_val, y_val)],
    eval_metric="average_precision",
)

pred = lgbm.predict_proba(X_val)[:, 1]
print("Average precision:", average_precision_score(y_val, pred))

Tratamento de atributos categóricos no LightGBM

Uma das vantagens práticas do LightGBM é o tratamento categórico nativo (dependendo da API e dos tipos de dados). Em muitas configurações, você pode passar colunas categóricas como dtype category no pandas e especificar atributos categóricos. Isso pode superar a codificação one-hot para categorias de alta cardinalidade e reduz a dimensionalidade.

Tenha cuidado:

• Garanta que sua divisão treino/validação evite vazamento (por exemplo, divisões baseadas em tempo para séries temporais).
• Categorias de alta cardinalidade ainda podem sofrer overfitting; regularize com min_data_in_leaf, feature_fraction e validação cuidadosa.

Considerações práticas

• Risco de overfitting: o crescimento folha-a-folha pode ajustar padrões complexos rapidamente; use restrições (num_leaves, min_data_in_leaf, max_depth) e validação forte.
• Velocidade: frequentemente mais rápido do que XGBoost em conjuntos de dados grandes, especialmente com muitas linhas.

Escolhendo entre scikit-learn, XGBoost e LightGBM

Um guia simples de decisão

• Use scikit-learn quando você precisa de:

  • pipelines de ponta a ponta com pré-processamento e seleção de modelo
  • algoritmos clássicos além de GBDT (modelos lineares, SVMs, agrupamento, PCA)
  • linhas de base rápidas e experimentação limpa

• Use XGBoost quando você quer:

  • desempenho robusto e altamente competitivo em dados tabulares
  • regularização forte e comportamento confiável em muitos conjuntos de dados
  • atributos esparsos / pipelines com muito one-hot

• Use LightGBM quando você quer:

  • treinamento muito rápido em conjuntos de dados tabulares grandes
  • suporte nativo a atributos categóricos (frequentemente uma grande vantagem prática)
  • busca eficiente de hiperparâmetros devido a iterações mais rápidas

Como as diferenças de desempenho normalmente se apresentam

Em muitas tarefas tabulares do mundo real:

• XGBoost e LightGBM frequentemente ficam próximos; as características do conjunto de dados determinam o vencedor.
• LightGBM pode ser mais rápido; XGBoost pode parecer mais “robusto por padrão” para alguns profissionais.
• Ambos geralmente superam variantes antigas de GBDT do sklearn em dados tabulares grandes e complexos, embora os modelos modernos HistGradientBoosting* do sklearn possam ser boas linhas de base.

Padrões comuns de fluxo de trabalho na prática

1) Comece com uma linha de base forte e depois aumente a complexidade

Uma progressão comum:

1. linha de base com regressão logística / floresta aleatória do scikit-learn
2. modelo ajustado de XGBoost ou LightGBM
3. Adicionar engenharia de atributos, checagens de vazamento, calibração, interpretabilidade
4. Considerar aprendizado profundo apenas se necessário (dados não estruturados ou aprendizado de representações em escala muito grande)

2) Use scikit-learn para o “loop externo”

Mesmo quando seu modelo central é XGBoost/LightGBM, o scikit-learn frequentemente gerencia:

• divisão treino/validação
• validação cruzada
• métricas (ver Métricas de Avaliação)
• pipelines de pré-processamento

3) Ajuste de hiperparâmetros

GBDTs são sensíveis a hiperparâmetros. Alvos típicos de ajuste:

• Complexidade: max_depth, num_leaves, min_child_weight, min_data_in_leaf
• Regularização: reg_lambda, reg_alpha
• Amostragem: subsample, colsample_bytree/feature_fraction
• Dinâmica de aprendizado: learning_rate, n_estimators (+ early stopping)

Métodos automatizados de ajuste (busca aleatória, otimização bayesiana (Bayesian optimization)) são comuns (ver Otimização de Hiperparâmetros).

4) Monitoramento de modelos, rastreamento e reprodutibilidade

Em fluxos de trabalho de produção, você tipicamente combina essas bibliotecas com rastreamento de experimentos e registros de modelos:

• Rastrear parâmetros, métricas, artefatos (ver Ferramentas de Experimentos)
• Armazenar e versionar modelos e pipelines de atributos
• Monitorar deriva (drift) e mudanças de desempenho

Dicas práticas e armadilhas

Vazamento de dados é o modo de falha silenciosa #1

Fontes comuns de vazamento:

• Usar informação futura em atributos (séries temporais)
• Codificação do alvo (target encoding) sem dobramento adequado
• Ajustar o pré-processamento nos dados completos antes da validação cruzada

Use pipelines e divisões sensíveis ao tempo quando necessário.

Não confie demais em “importância de atributos”

A importância de atributos embutida pode ser enganosa:

• atributos correlacionados dividem a importância
• atributos de alta cardinalidade podem parecer artificialmente fortes
• importância não é causalidade

Prefira importância por permutação (permutation importance) ou análises baseadas em SHAP quando o impacto é alto (ver Interpretabilidade de Modelos).

Classificação desbalanceada exige métricas e limiares cuidadosos

Para fraude/detecção de eventos raros:

• Prefira AUC-PR / precisão média (average precision) em vez de ROC-AUC em muitos casos
• Ajuste limiares de decisão com base em custos de negócio
• Considere pesos de classe ou objetivos especializados

Resumo

• scikit-learn é o kit essencial de aprendizado de máquina clássico: APIs consistentes, pré-processamento, pipelines e seleção de modelo.
• XGBoost é uma biblioteca de boosting de gradiente de nível superior: sua forte acurácia o torna uma escolha padrão para modelagem tabular competitiva.
• LightGBM é uma biblioteca de boosting de gradiente rápida e escalável: excelente para conjuntos de dados grandes e tratamento categórico prático.

Em sistemas modernos de aprendizado de máquina, essas bibliotecas continuam indispensáveis — frequentemente entregando a melhor relação acurácia-esforço de engenharia em problemas tabulares e formando a espinha dorsal de linhas de base confiáveis, modelos de produção e fluxos de trabalho com dados estruturados.

---