Regressão em Python: guia prático para análises (linear, múltipla, polinomial e logística)

Links rápidos

• Regressão Linear Simples: Encontrando Tendências

• Regressão Linear Múltipla: levando a regressão para a terceira dimensão e além

• Regressão Não Linear: Ajustando curvas

• Regressão Logística: Modelando categorias binárias

Por que regressão?

Coletar dados por si só não basta. Planilhas podem armazenar informações, mas muitas vezes você precisa extrair padrões e previsões. Regressão é uma família de métodos estatísticos para modelar a relação entre variáveis e prever valores. Em termos simples:

• Variável independente: a entrada ou preditora (x).
• Variável dependente: o alvo que queremos prever (y).

Definição rápida: Regressão é o processo de ajustar uma função matemática aos dados observados para explicar ou prever a variável alvo.

Importante: antes de modelar, sempre verifique qualidade, valores ausentes, outliers e suposições do modelo.

Como seguir este guia

• Exemplos usam Seaborn para visualizações e Pingouin para regressões (ambos são fáceis de instalar via pip/mamba).
• Código pode ser executado em Jupyter; adicione %matplotlib inline para visualizar gráficos no próprio notebook.

Regressão Linear Simples: Encontrando Tendências

A regressão linear simples modela a relação entre duas variáveis com uma reta: y = m*x + b. Aqui vamos testar se o valor total da conta (total_bill) prediz a gorjeta (tip) usando o dataset “tips” do Seaborn.

Passos iniciais (importar bibliotecas e carregar dados):

import seaborn as sns
import pingouin as pg

# Carregar dataset de exemplo
tips = sns.load_dataset('tips')

Se usar Jupyter, adicione %matplotlib inline para renderizar gráficos no notebook:

%matplotlib inline

Visualizando o scatterplot:

sns.relplot(x='total_bill', y='tip', data=tips)

A nuvem de pontos parece sugerir uma relação aproximadamente linear: quanto maior a conta, maior a gorjeta, em média. Para ajustar uma reta de regressão:

sns.regplot(x='total_bill', y='tip', data=tips)

Para uma análise mais formal (coeficientes e métricas), usamos Pingouin:

pg.linear_regression(tips['total_bill'], tips['tip']).round(2)

O valor r² (coeficiente de determinação) resume quanto da variância em y é explicada por x. Neste exemplo r² ≈ 0.46, o que indica um ajuste razoável. A raiz quadrada de r² aproxima o coeficiente de correlação linear (r ≈ 0.68), sugerindo correlação positiva moderada.

Coeficientes (exemplo): se obtivermos m = 0.11 e b = 0.92, a equação da linha é:

tip = 0.92 + 0.11 * total_bill

Função Python preditiva (lembre-se de indentar 4 espaços no seu código):

def tip(total_bill):
    return 0.92 + 0.11 * total_bill

Previsão para uma conta de US$100:

tip(100)

A gorjeta prevista será aproximadamente US$12 (0.92 + 0.11*100 ≈ 11.92).

Notas de interpretação:

• Coeficiente m indica o aumento esperado na gorjeta por unidade adicional no total da conta.
• Intercepto b é o valor previsto quando total_bill = 0; nem sempre tem interpretação prática, mas é necessário no modelo.

Quando a regressão linear simples falha:

• Relação não é linear (padrões curvilíneos).
• Variância dos erros não é constante (heterocedasticidade).
• Presença de outliers que distorcem a reta.
• Variáveis omitidas que geram viés.

Regressão Linear Múltipla: mais variáveis preditoras

A regressão linear múltipla estende a simples para várias variáveis independentes. Em vez de uma reta, ajustamos um hiperplano. Usando o mesmo dataset de gorjetas, adicionaremos o tamanho da mesa (size) como preditor:

pg.linear_regression(tips[['total_bill', 'size']], tips['tip']).round(2)

Note as duplas colchetes para passar múltiplas colunas. Se r² não muda muito em relação ao modelo simples, pode significar que o novo preditor não adicionou informação substancial.

Exemplo de função com duas variáveis:

def tip(total_bill, size):
    return 0.67 + 0.09 * total_bill + 0.19 * size

Práticas e recomendações:

• Normalizar variáveis quando escalas diferem muito (ex.: preço em dólares vs. número de itens).
• Verificar multicolinearidade entre preditores (VIF). Multicolinearidade alta torna estimativas instáveis.
• Seleção de variáveis: use conhecimento de domínio, testes estatísticos ou métodos automáticos (forward, backward, Lasso).

Checklist rápido antes de confiar no modelo:

• Dados limpos e com valores ausentes tratados.
• Resíduos diagnosticados (normalidade, homocedasticidade).
• Multicolinearidade verificada.
• Validação cruzada ou holdout para testar generalização.

Regressão Não Linear e Polinomial: ajustando curvas

Nem toda relação é bem descrita por uma reta. Para padrões quadráticos ou polinomiais, podemos ajustar termos x², x³ etc. Exemplo com dados artificiais:

Gerando dados quadráticos com NumPy e criando DataFrame:

import numpy as np
import pandas as pd

x = np.linspace(-100, 100, 1000)
y = 4 * x**2 + 2 * x + 3

df = pd.DataFrame({'x': x, 'y': y})

df.head()

Plotando a dispersão:

sns.relplot(x='x', y='y', data=df)

Ajuste polinomial com Seaborn (order=2 para quadrática):

sns.regplot(x='x', y='y', order=2, data=df)

Uma técnica prática é criar colunas polinomiais e usar regressão linear sobre elas (transformação linear dos preditores):

df['x2'] = df['x']**2
pg.linear_regression(df[['x', 'x2']], df['y']).round(2)

Para dados artificiais perfeitos obtemos r² = 1; em dados reais isso é raro.

Função preditiva derivada do modelo:

def quad(x):
    return 3 + 2 * x + 4 * x**2

Extensões e cuidados:

• Cuidado com overfitting ao usar polinômios de grau alto.
• Preferir regularização (Ridge/Lasso) quando há muitos termos.
• Testar generalização com validação cruzada.

Regressão Logística: modelando eventos binários

Regressão logística modela a probabilidade de ocorrência de um evento binário (0/1). Exemplo: prever sobrevivência (survived) no dataset Titanic em função do preço da passagem (fare).

titanic = sns.load_dataset('titanic')
titanic.head()

Plot logístico com Seaborn (lmplot com logistic=True):

sns.lmplot(x='fare', y='survived', logistic=True, data=titanic)

Análise formal com Pingouin:

pg.logistic_regression(titanic['fare'], titanic['survived']).round(2)

Interpretação rápida:

• A saída inclui coeficiente, p-valor e métricas de ajuste.
• p-valor pequeno (ex.: 0.0 no resultado arredondado) indica que a tarifa foi um preditor estatisticamente significativo de sobrevivência.

Boas práticas para regressão logística:

• Avalie métricas além do p-valor: AUC-ROC, matriz de confusão, precisão/recall.
• Verifique separabilidade e linearidade no logit (transformação log-odds).
• Use regularização se houver muitos preditores.

Fluxo de decisão: qual regressão usar?

Abaixo um diagrama simples para orientar a escolha do tipo de regressão.

flowchart TD
  A[Comece: Qual a natureza do alvo?] --> B{Alvo contínuo ou binário?}
  B -- Contínuo --> C{Relação parece linear?}
  C -- Sim --> D[Regressão Linear 'simples ou múltipla']
  C -- Não --> E{Padrão polinomial?}
  E -- Sim --> F[Regressão Polinomial]
  E -- Não --> G[Modelos não lineares 'splines, GAM, regressão por árvores']
  B -- Binário --> H[Regressão Logística]
  G --> I[Considerar Random Forest / Gradient Boosting / SVM]
  D --> Z[Fazer validação cruzada e diagnóstico de resíduos]
  F --> Z
  H --> Z

Heurísticas e mental models rápidos

• Comece simples: um modelo linear simples funciona bem como baseline.
• Sempre visualize os dados antes de ajustar modelos.
• R² explica a proporção de variância explicada — útil, mas não definitivo.
• p-valor informa evidência estatística contra a hipótese nula; combine com tamanho do efeito.
• Prefira validação (holdout, k-fold) para estimar desempenho real.

Quando evitar regressão linear

• Relação claramente não linear e difícil de linearizar.
• Muitos outliers e erros não-gaussianos.
• Preditores correlacionados (multicolinearidade alta).
• Dados temporais com autocorrelação não tratada.

Mini-metodologia para um projeto rápido de regressão

1. Definir objetivo: previsão ou inferência.
2. Coletar e limpar dados: lidar com NA, outliers, formatos.
3. Exploração: scatterplots, correlações, histogramas.
4. Escolher modelo baseline: regressão linear simples/múltipla.
5. Ajustar e diagnosticar: resíduos, VIF, heterocedasticidade.
6. Selecionar features: regularização ou seleção stepwise.
7. Validar: k-fold CV, retenção de holdout.
8. Interpretar e reportar: coeficientes, intervalos de confiança, métricas.
9. Implementar: empacotar função ou API para predição.
10. Monitorar e recalibrar com dados novos.

Checklist por função (papéis)

• Cientista de Dados:

  • Verificou qualidade e suposições do modelo.
  • Testou vários modelos e validou com CV.
  • Documentou decisões de feature engineering.

• Engenheiro de ML:

  • Implementou pipeline reprodutível.
  • Adicionou testes unitários e integração.
  • Monitorou desempenho em produção.

• Product Manager:

  • Validou impacto de negócio esperado.
  • Definiu métricas de sucesso e SLO.
  • Priorizou trade-offs entre precisão e latência.

Testes, critérios de aceitação e casos de uso

Critérios de aceitação típicos para um modelo de regressão preditiva:

• Métrica de desempenho mínima (ex.: RMSE, MAE) definida no conjunto de validação.
• Sem vieses sistemáticos detectáveis por grupo (auditoria rápida).
• Documentação de hipóteses e limitações do modelo.

Exemplo de casos de teste:

• Entrada típica: valores dentro do intervalo de treinamento → saída numérica plausível.
• Entrada limite: valores fora do intervalo → comportamento definido (ex.: clipping, aviso).
• Entrada inválida: tipos incorretos → erro controlado com mensagem clara.

Snippets e cheat sheet rápido

Função preditiva linear simples (exemplo):

def predict_tip(total_bill):
    # Coeficientes estimados previamente
    intercept = 0.92
    coef_bill = 0.11
    return intercept + coef_bill * total_bill

Criar features polinomiais manualmente:

df['x2'] = df['x']  2
# Para grau 3
# df['x3'] = df['x']  3

Verificar multicolinearidade (VIF) usando statsmodels:

from statsmodels.stats.outliers_influence import variance_inflation_factor
X = df[['total_bill', 'size']]
X = add_constant(X)
vif = pd.DataFrame()
vif['feature'] = X.columns
vif['VIF'] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]

Boas práticas de privacidade e ética

• Remova ou anonimiza identificadores pessoais antes de treinar modelos.
• Avalie impacto de decisões automatizadas sobre grupos sensíveis.
• Documente limitações e possíveis vieses do modelo.

Comparação rápida (quando usar cada tipo)

• Regressão Linear: quando target contínuo e relação aproximadamente linear.
• Regressão Múltipla: múltiplos preditores explicando variação no alvo.
• Regressão Polinomial: relação curvilínea conhecida (parabólica, cúbica).
• Regressão Logística: alvo binário (0/1), prever probabilidades.
• Modelos baseados em árvore/ensemble: quando relações são complexas e interações não lineares dominam.

Erros comuns e como mitigá-los

• Ignorar a inspeção visual: sempre visualize antes de ajustar.
• Confiar só em p-valores: combine com tamanho do efeito e métricas de desempenho.
• Não validar: sem validação, o desempenho pode ser enganoso (overfitting).
• Tratar outliers de forma automática sem investigar causas: às vezes outliers indicam problemas reais nos dados.

Exemplo de workflow end-to-end (resumido)

1. Carregar dados (Seaborn, CSV, SQL).
2. Limpeza e EDA (visualizações, estatísticas descritivas).
3. Feature engineering (normalização, polinômios, dummies).
4. Split treino/teste e validação cruzada.
5. Ajuste do modelo e tuning de hiperparâmetros.
6. Teste final no holdout.
7. Empacotamento do modelo e deploy.
8. Monitoramento e recalibração.

Resumo final

A regressão em Python é acessível e poderosa. Seaborn facilita a visualização e Pingouin fornece ferramentas estatísticas diretas. Comece com modelos simples, valide, interprete com cuidado e aumente a complexidade apenas quando necessário.

Importante: não há substituto para conhecimento de domínio — modelos são tão bons quanto as perguntas que fazemos e os dados que temos.

Resumo rápido:

• Regressão ajuda a encontrar relações e a prever alvos contínuos ou binários.
• Sempre visualize e valide; comece com modelos simples.
• Use transformações, regularização e validação cruzada para modelos mais robustos.