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/predict para 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

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: StandardScaler em 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=None memoriza ruído em poucos dados. Correção: limite a profundidade, aumente min_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 de probability=True (SVC) para saídas de probabilidade. Correção: verifique o suporte do estimador antes de usar proba.

Alternativas

FAQs

LogisticRegression(multi_class="multinomial", max_iter=1000)
# ou
RandomForestClassifier()  # lida com multiclasse nativamente

for name, imp in zip(feature_names, reg.feature_importances_):
    print(f"{name}: {imp:.3f}")

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+.