Aprendizado Supervisionado
O aprendizado supervisionado mapeia recursos de entrada para rótulos conhecidos. Regressão prevê valores contínuos; classificação atribui categorias discretas. O sklearn fornece uma API consistente entre os algoritmos.
Receita
Cartão de referência rápida - pronto para copiar e colar.
from sklearn.linear_model import Ridge, LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingRegressor
# Classificação
clf = LogisticRegression(max_iter=1000)
clf.fit(X_train, y_train)
# Regressão
reg = Ridge(alpha=1.0)
reg.fit(X_train, y_train)Quando usar isso:
- Prever um resultado numérico (preço, demanda, latência) - regressão.
- Atribuir categorias (churn, fraude, sentimento) - classificação.
- Dados tabulares com exemplos de treinamento rotulados.
- Modelagem de linha de base antes do ajuste de deep learning ou gradient boosting.
Exemplo de Trabalho
"""supervised_learning.py - regressão e classificação com sklearn."""
from __future__ import annotations
import pandas as pd
from sklearn.datasets import fetch_california_housing, load_breast_cancer
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.linear_model import LogisticRegression, Ridge
from sklearn.metrics import mean_absolute_error, roc_auc_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
# --- Classificação ---
cancer = load_breast_cancer(as_frame=True)
Xc, yc = cancer.data, cancer.target
Xc_train, Xc_test, yc_train, yc_test = train_test_split(Xc, yc, test_size=0.2, random_state=42)
clf_pipe = Pipeline([
("scale", StandardScaler()),
("clf", LogisticRegression(max_iter=1000, random_state=42)),
])
clf_pipe.fit(Xc_train, yc_train)
proba = clf_pipe.predict_proba(Xc_test)[:, 1]
print("classificação AUC:", roc_auc_score(yc_test, proba))
# --- Regressão ---
housing = fetch_california_housing(as_frame=True)
Xr, yr = housing.data, housing.target
Xr_train, Xr_test, yr_train, yr_test = train_test_split(Xr, yr, test_size=0.2, random_state=42)
reg = RandomForestRegressor(n_estimators=200, random_state=42, n_jobs=-1)
reg.fit(Xr_train, yr_train)
print("regressão MAE:", mean_absolute_error(yr_test, reg.predict(Xr_test)))O que isso demonstra:
- Mesma API
fit/predictpara regressão e classificação. - Escalonamento antes da regressão logística; modelos de árvore ignoram o escalonamento.
- Saídas de probabilidade para métricas de classificação de ranking.
- MAE como uma métrica de regressão interpretável (dólares, unidades).
Mergulho Profundo
Como Funciona
- Treinamento minimiza uma função de perda sobre exemplos rotulados (log loss, MSE, hinge loss).
- Modelos lineares aprendem somas ponderadas de recursos; rápidos e interpretáveis.
- Ensembles de árvores particionam o espaço de recursos com divisões alinhadas aos eixos; capturam interações não lineares.
- Regularização (L1/L2) penaliza pesos grandes para reduzir o overfitting.
- A fronteira de decisão a complexidade cresce com a capacidade do modelo - equilibre com métricas de validação.
Seleção de Algoritmo
| Problema | Comece Com | Atualize Para |
|---|---|---|
| Classificação binária | LogisticRegression | RandomForest, XGBoost |
| Multiclasse | LogisticRegression (multinomial) | RandomForestClassifier |
| Regressão (linear-ish) | Ridge | GradientBoostingRegressor |
| Regressão (não linear) | RandomForestRegressor | LightGBM |
| Poucos dados, interpretabilidade | Modelos lineares | - |
| Grande volume tabular, precisão | Gradient boosting | - |
Notas de Python
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
# SVM: forte com recursos escalonados, mais lento em grandes volumes de dados
svm = Pipeline([("scale", StandardScaler()), ("clf", SVC(probability=True))])
# k-NN: aprendiz preguiçoso, sensível à escala e dimensionalidade
knn = Pipeline([("scale", StandardScaler()), ("clf", KNeighborsClassifier(n_neighbors=5))])Armadilhas
- Usar métricas de classificação para regressão - precisão em alvos contínuos é sem sentido. Correção: MAE, RMSE, R-quadrado para regressão.
- Não escalonar para SVM/k-NN/regressão logística - métodos de distância e gradiente falham em recursos não escalonados. Correção:
StandardScalerem um pipeline. - Ignorar desequilíbrio de classe - a precisão parece boa enquanto o modelo prevê a classe majoritária. Correção: F1, ROC-AUC ou reamostragem.
- Overfitting com árvores profundas -
max_depth=Nonememoriza ruído em poucos dados. Correção: limite a profundidade, aumentemin_samples_leaf, use CV. - Multicolinearidade em regressão linear - coeficientes instáveis com recursos correlacionados. Correção: regressão Ridge ou seleção de recursos.
- Prever sem
predict_proba- alguns modelos precisam deprobability=True(SVC) para saídas de probabilidade. Correção: verifique o suporte do estimador antes de usar proba.
Alternativas
| Alternativa | Use Quando | Não Use Quando |
|---|---|---|
| Modelos lineares | Interpretabilidade, linha de base rápida | Interações não lineares complexas dominam |
| Random Forest | Padrão robusto, pouco ajuste | Necessita de precisão máxima em dados tabulares grandes |
| Gradient boosting | Melhor precisão tabular | Necessita de iteração de treinamento rápida ou interpretabilidade |
| Deep learning | Imagens, texto, sequências | Dados tabulares pequenos com <10k linhas |
FAQs
Qual é a diferença entre regressão e classificação?
- Regressão produz valores contínuos (preço = 249,99).
- Classificação produz rótulos discretos (spam = sim/não).
- Classificação multiclasse tem 3+ categorias.
Quando devo usar regressão logística?
- Forte linha de base linear para classificação.
- Coeficientes interpretáveis para revisão de stakeholders.
- Treinamento rápido em recursos de texto esparsos de alta dimensionalidade.
O que o alpha de regularização faz no Ridge?
- Um
alphamaior encolhe os coeficientes em direção a zero, reduzindo o overfitting. alpha=0é mínimos quadrados ordinários.- Ajuste com validação cruzada (
RidgeCV).
Como os modelos de árvore lidam com valores ausentes?
- O
RandomForestdo sklearn não lida nativamente com NaN - impute primeiro. - XGBoost e LightGBM aprendem direções ótimas para valores ausentes.
- Impute dentro de um pipeline para árvores do sklearn.
Qual é o trade-off viés-variância?
- Modelos simples subajustam (alto viés); modelos complexos sobreajustam (alta variância).
- Métricas de validação revelam o ponto ideal.
- Regularização e ensembles reduzem a variância.
Posso usar o mesmo pipeline para treinamento e produção?
- Sim -
joblib.dumpo pipeline ajustado. - Produção chama
pipe.predict(new_row)com os mesmos nomes de coluna.
Como lidar com classificação multiclasse?
LogisticRegression(multi_class="multinomial", max_iter=1000)
# ou
RandomForestClassifier() # lida com multiclasse nativamente- Use F1 com
average="macro"quando as classes estiverem desequilibradas.
Qual é um bom primeiro modelo para um novo conjunto de dados?
- Regressão logística ou Ridge para linhas de base.
- RandomForest para uma verificação não linear sem ajuste pesado.
- Compare ambos antes de investir em gradient boosting.
Como interpreto a importância de recursos?
for name, imp in zip(feature_names, reg.feature_importances_):
print(f"{name}: {imp:.3f}")- Modelos de árvore expõem
feature_importances_. - Modelos lineares usam magnitudes de coeficientes (após escalonamento).
Devo sempre usar métodos de ensemble?
- Ensembles vencem em dados tabulares estilo Kaggle.
- Modelos lineares vencem quando interpretabilidade e velocidade importam.
- Comece simples, atualize quando a validação justificar a complexidade.
Como o sklearn lida com rótulos de string?
- A maioria dos classificadores aceita rótulos y de string diretamente.
- Codificados internamente; as previsões retornam o tipo de rótulo original.
Quando preciso de recursos polinomiais?
- Quando modelos lineares subajustam, mas as relações são suaves.
- Aumenta a contagem de recursos rapidamente - combine com regularização.
- Modelos de árvore geralmente tornam os polinomiais desnecessários.
Relacionados
- Avaliação de Modelo - escolhendo as métricas corretas
- Engenharia de Recursos - pré-processamento por algoritmo
- Gradient Boosting - XGBoost e LightGBM
- Ajuste de Hiperparâmetros - otimizando parâmetros do modelo
- Dados Desequilibrados - peso de classe e reamostragem
Versões da Stack: Esta página foi escrita para Python 3.14.0 (estável 3.14, manutenção 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, e uv 0.6+.