Sklearn linear regression: um guia completo com exemplos

A regressão linear é uma técnica fundamental em estatística e em machine learning para modelar a relação entre variáveis. Em termos simples, ela permite prever um resultado com base em um ou mais fatores que o influenciam. É amplamente usada em precificação de imóveis, previsão de vendas, avaliação de risco e muitos outros contextos.

Neste tutorial, vamos explorar regressão linear no scikit-learn: como funciona, por que é útil e como implementá-la na prática. Ao final, você será capaz de construir e avaliar um modelo de regressão linear para fazer previsões orientadas por dados.

Gráfico de dispersão: preço de casas versus número de cômodos

Regressão linear e machine learning

Além de sua utilidade imediata em estimar preços de casas, a regressão linear tem um papel importante em machine learning.

• É um modelo de base para compreender técnicas mais avançadas, como regressão logística, redes neurais e máquinas de vetores de suporte.
• Treina rápido, ideal para prototipagem ágil.
• Funciona como baseline de comparação. Se modelos mais avançados não superarem significativamente sua performance, a complexidade extra pode não se justificar.
• Ao contrário de algumas técnicas (como deep learning), é facilmente interpretável.
• Pode ajudar na seleção de features, identificando os preditores mais úteis.

Apesar da simplicidade, a regressão linear continua indispensável em machine learning pela eficiência, interpretabilidade e versatilidade.

Regressão linear e a biblioteca scikit-learn

A biblioteca scikit-learn facilita a implementação de regressão linear. Ela traz várias vantagens.

• Interface consistente: o código para implementar diferentes algoritmos de ML é semelhante.
• Código simples: a matemática e os detalhes de implementação ficam abstraídos. Por exemplo, para ajustar um modelo aos dados de treino, basta usar model.fit(X_train, y_train).
• Acesso fácil aos coeficientes do modelo.
• Métricas embutidas para avaliar a performance do modelo.
• Integração simples de regressão linear (ou qualquer outro algoritmo de ML) com etapas de pré-processamento, como escalonamento e seleção de features, usando Pipeline.

Se você é novo no scikit-learn, confira nosso curso Machine Learning com scikit-learn para uma introdução prática a essa biblioteca Python.

Entendendo a regressão linear

Como vimos, na regressão linear simples os dados são modelados por uma "reta de melhor ajuste". A fórmula dessa reta é: 

em que m é a inclinação da reta e b é o intercepto.

A "regressão linear múltipla" generaliza o caso de um preditor para vários (número de cômodos, proximidade do oceano, renda média do bairro). A fórmula geral é: 

em que cada x_i é uma variável independente e o b_i correspondente é seu coeficiente. Em três dimensões, a reta vira um plano. Em dimensões mais altas, o plano vira um "hiperplano".

Como interpretar os coeficientes e o intercepto? O intercepto é o valor previsto de y quando todas as variáveis independentes são 0; em outras palavras, é o valor base da variável dependente sem contribuição dos preditores. Cada coeficiente b_i representa a variação de y para um aumento de uma unidade em x_i, mantendo as demais variáveis independentes constantes.

Configurando o ambiente

Instalar o scikit-learn é fácil. Basta usar pip install scikit-learn. Se quiser instalar uma versão específica, por exemplo 1.2.2, inclua a versão: pip install scikit-learn==1.2.2. Se você usa Anaconda, o scikit-learn já deve vir instalado. Se por algum motivo ainda precisar instalá-lo na distribuição Anaconda, use conda install scikit-learn.

Algumas bibliotecas são necessárias ou recomendadas com o scikit-learn. A numpy é usada para armazenar features e rótulos. A pandas é recomendada para carregar, pré-processar e explorar conjuntos de dados. 

Se você usa scikit-learn, provavelmente já está usando pandas na preparação dos dados. Para visualizar resultados, você deve usar matplotlib ou seaborn, ou ambos. Qualquer uma dessas bibliotecas pode ser instalada via pip, como no exemplo acima. Dá até para instalar várias de uma vez:

pip install scikit-learn numpy pandas matplotlib seaborn.

Implementando regressão linear no sklearn

Antes de carregar o dataset, vamos importar os suspeitos de sempre.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

Carregando o dataset

Vamos usar o famoso dataset de habitação da Califórnia.

# Read in California housing dataset.
from sklearn.datasets import fetch_california_housing


housing = fetch_california_housing()

Preparando os dados

Vamos dividir os dados em treino e teste. Importamos o método train_test_split() de sklearn.model_selection, depois o chamamos especificando a porcentagem do conjunto de teste e um random_state. Usaremos também regressão linear simples, com a feature correspondente ao número médio de cômodos.

# Import train_test_split.
from sklearn.model_selection import train_test_split


# Create features X and target y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)[["AveRooms"]]
y = housing.target  # Median house value in $100,000s


# Split the dataset into training (80%) and testing (20%) sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Agora que separamos treino e teste, vamos padronizar as features. Esse processo coloca todas as variáveis na mesma escala, o que pode melhorar a performance e a estabilidade numérica do modelo.

# Import StandardScaler.
from sklearn.preprocessing import StandardScaler

# Instantiate StandardScaler.
scaler = StandardScaler()

# Fit and transform training data.
X_train_scaled = scaler.fit_transform(X_train)

# Also transform test data.
X_test_scaled = scaler.transform(X_test)

Neste código, o StandardScaler é uma ferramenta de pré-processamento que remove a média e escala as features para variância unitária. Isso evita que certas variáveis dominem o modelo por estarem em escalas diferentes.

O scaler é ajustado nos dados de treino com fit_transform(). Os dados de teste são transformados separadamente com transform(), garantindo o uso dos mesmos fatores do treino e evitando vazamento de dados.

Treinando o modelo de regressão linear

Para criar um modelo de regressão linear, importe LinearRegression() de sklearn.linear_model. Instancie e atribua a uma variável.

# Import LinearRegression.
from sklearn.linear_model import LinearRegression


# Instantiate linear regression model.
model = LinearRegression()

Ajustar o modelo com os dados de treino é direto.

# Fit the model to the training data.
model.fit(X_train_scaled, y_train)

Fazendo previsões

Com o modelo treinado, geramos previsões no conjunto de teste.

# Make predictions on the testing data.
y_pred = model.predict(X_test_scaled)

Avaliando a performance do modelo

Depois de prever no conjunto de teste, precisamos saber o quão bem as previsões batem com a realidade. Há várias métricas para avaliar um algoritmo de regressão. Algumas das mais comuns são o coeficiente de determinação (R²), o erro quadrático médio (MSE) e a raiz do erro quadrático médio (RMSE).

O coeficiente de determinação, R², mede o quanto um modelo de regressão explica a variabilidade da variável alvo. Em outras palavras, quantifica quanta variação da variável alvo é explicada pelos preditores — a chamada qualidade do ajuste (goodness of fit).

Para entender melhor, veja a fórmula:

em que yactual são os valores reais da variável alvo, ypredicted são os valores previstos pelo modelo, e ȳ é a média dos valores reais. A fórmula mostra quanta variância é explicada pelo modelo: o denominador representa a variância total nos dados, enquanto o numerador representa a variância não explicada após aplicar a regressão. A razão dá a porcentagem de variância explicada pelo modelo.

Como interpretar o R²?

• R² = 1: o modelo explica perfeitamente toda a variância da variável alvo.
• R² = 0: o modelo não explica a variância; prever a média seria equivalente.
• R² < 0: pior que usar apenas a média, indicando ajuste ruim.

Alguns pontos importantes.

• Um R² maior nem sempre é melhor. Valores altos podem indicar overfitting, especialmente em modelos complexos.
• Adicionar mais features pode inflar artificialmente o R²; portanto, um valor maior não é necessariamente melhor.
• Para regressão múltipla, use o R² ajustado, que considera o número de preditores e evita melhorias enganosas por variáveis desnecessárias.

Avaliar a performance com o coeficiente de determinação é simples no scikit-learn.

# Import metrics.
from sklearn.metrics import mean_squared_error, r2_score


# Calculate and print R^2 score.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")

R-squared: 0.0138

Outras métricas comuns são o erro quadrático médio (MSE) e a raiz do erro quadrático médio (RMSE). Elas medem o quanto as previsões do modelo se desviam dos valores reais.

O MSE calcula a média dos quadrados das diferenças entre valores reais e previstos: 

para o total de observações n. Como os erros são elevados ao quadrado antes da média, erros maiores são mais penalizados que os menores, tornando o MSE sensível a outliers. Quanto menor o MSE, melhor o ajuste.

Para lidar com isso, usa-se o RMSE, que é simplesmente a raiz quadrada do MSE. Como o RMSE está nas mesmas unidades da variável alvo, oferece uma medida mais interpretável de quão distantes, em média, estão as previsões.

Calcular MSE e RMSE no scikit-learn é fácil.

# Calculate and print MSE.
mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


# Calculate and print RMSE.
rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

Mean squared error: 1.2923
Root mean squared error: 1.1368

Trabalhando com regressão linear múltipla no scikit-learn

Vamos executar o modelo novamente usando todas as features disponíveis, não só o número médio de cômodos. Você espera resultados melhores ou piores?

# Uses all features.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load data set.
housing = fetch_california_housing()


# Split into X, y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)
y = housing.target  # Median house value in $100,000s
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data.
scaler = StandardScaler()


X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create model and fit it to the training data.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions.
y_pred = model.predict(X_test_scaled)


# Calculate and print errors.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")


mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5758
Mean squared error: 0.5559
Root mean squared error: 0.7456

Os resultados são bem melhores do que usando apenas uma feature. Porém, surge a dúvida: precisamos de todas as features? Algumas são mais relevantes que outras? A escolha das features mais relevantes do dataset é chamada de seleção de features.

A seleção de features é importante por vários motivos.

• Reduz overfitting. Menos features significam menos complexidade, reduzindo o risco de overfitting.
• Melhora a acurácia. Remover features irrelevantes ou redundantes ajuda o modelo a focar em padrões significativos.
• Aumenta a interpretabilidade. Facilita entender o modelo, destacando os fatores mais importantes.
• Acelera o treino. Menos features diminuem o tempo de processamento e o uso de memória.

Quando várias features são altamente correlacionadas, elas são redundantes — essencialmente fornecendo a mesma informação ao modelo. Essa situação é chamada de multicolinearidade. Embora nem sempre afete a acurácia de modelos preditivos, complica a seleção e a interpretação de features, especialmente em regressão linear e modelos relacionados.

O Fator de Inflação da Variância (VIF) é uma métrica para detectar multicolinearidade entre preditores. Para cada preditor, o VIF é calculado como: 

em que R_i² é o R² obtido ao regredir o preditor X_i contra todos os demais preditores do modelo. VIF alto indica que o preditor é altamente correlacionado com outras variáveis.

• VIF = 1: sem multicolinearidade (cenário ideal).
• VIF < 5: multicolinearidade baixa a moderada (geralmente aceitável).
• VIF > 5: multicolinearidade alta (considere remover ou combinar variáveis correlacionadas).
• VIF > 10: multicolinearidade severa (forte indicação de redundância).

# Import libraries.
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing
from statsmodels.stats.outliers_influence import variance_inflation_factor


# Load the dataset.
housing = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names)


# Compute the correlation matrix.
corr_matrix = X.corr()


# Identify pairs of features with high collinearity (correlation > 0.8 or < -0.8).
high_corr_features = [(col1, col2, corr_matrix.loc[col1, col2])
                     for col1 in corr_matrix.columns
                     for col2 in corr_matrix.columns
                     if col1 != col2 and abs(corr_matrix.loc[col1, col2]) > 0.8]


# Convert to a DataFrame for better visualization.
collinearity_df = pd.DataFrame(high_corr_features, columns=["Feature 1", "Feature 2", "Correlation"])
print("\nHighly Correlated Features:\n", collinearity_df)


# Compute Variance Inflation Factor (VIF) for each feature.
vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]


# Print VIF values.
print("\nVariance Inflation Factor (VIF) for each feature:\n", vif_data)

   Highly Correlated Features:
       Feature 1  Feature 2  Correlation
   0   AveRooms  AveBedrms     0.847621
   1  AveBedrms   AveRooms     0.847621
   2   Latitude  Longitude    -0.924664
   3  Longitude   Latitude    -0.924664
  
   Variance Inflation Factor (VIF) for each feature:
          Feature         VIF
   0      MedInc   11.511140
   1    HouseAge    7.195917
   2    AveRooms   45.993601
   3   AveBedrms   43.590314
   4  Population    2.935745
   5    AveOccup    1.095243
   6    Latitude  559.874071
   7   Longitude  633.711654

Vamos remover AveBedrms do modelo.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load California housing dataset.
housing = fetch_california_housing()


# Create DataFrame and remove "AveBedrms" feature.
X = pd.DataFrame(housing.data, columns=housing.feature_names).drop(columns=["AveBedrms"])
y = housing.target  # Median house value in $100,000s


# Split data into training and testing sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data (Standardization).
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create a linear regression model and train it.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions on the test set.
y_pred = model.predict(X_test_scaled)


# Calculate performance metrics.
r2 = r2_score(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
# Print evaluation metrics
print(f"R-squared: {r2:.4f}")
print(f"Mean squared error: {mse:.4f}")
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5823
Mean squared error: 0.5473
Root mean squared error: 0.7398

Os resultados melhoraram (marginalmente).

Extraindo insights do modelo

Construir um modelo de regressão é só o primeiro passo; entender seus resultados é igualmente importante. Ao analisar os coeficientes, dá para identificar quais features têm maior impacto nas previsões.

Entendendo os coeficientes da regressão

Depois de treinar um modelo de regressão linear, os coeficientes podem ser acessados com model.coef_. O intercepto é acessado com model.intercept_.

Depois de treinar um modelo de regressão linear com LinearRegression(), os coeficientes podem ser acessados com model.coef_ e o intercepto com model.intercept_.

print("Intercept:", model.intercept_)


coeff_df = pd.DataFrame({"Feature": X.columns, "Coefficient": model.coef_})
print("\nFeature Coefficients:\n", coeff_df)

   Intercept: 2.0719469373788777  

   Feature Coefficients:

         Feature  Coefficient

   0     MedInc     0.725747

   1   HouseAge     0.121519

   2   Latitude    -0.943105

   3  Longitude    -0.900735

Resumindo os resultados do modelo

Como o Scikit-Learn não oferece um método summary() como o Statsmodels, podemos extrair e visualizar manualmente a importância de cada feature via coeficientes. Features com coeficientes absolutos maiores têm impacto mais forte na variável alvo. Considere o código a seguir.

# Sort dataframe by coefficients.
coef_df_sorted = coef_df.sort_values(by="Coefficient", ascending=False)


# Create plot.
plt.figure(figsize=(8,6))
plt.barh(coef_df["Feature"], coef_df_sorted["Coefficient"], color="blue")
plt.xlabel("Coefficient Value")
plt.ylabel("Feature")
plt.title("Feature Importance (Linear Regression Coefficients)")
plt.show()

Gráfico de importância das features com base nos coeficientes

Agora, vamos visualizar os resíduos e o ajuste da regressão.

# Compute residuals.
residuals = y_test - y_pred


# Create plots.
plt.figure(figsize=(12,5))


# Plot 1: Residuals Distribution.
plt.subplot(1,2,1)
sns.histplot(residuals, bins=30, kde=True, color="blue")
plt.axvline(x=0, color='red', linestyle='--')
plt.title("Residuals Distribution")
plt.xlabel("Residuals (y_actual - y_predicted)")
plt.ylabel("Frequency")


# Plot 2: Regression Fit (Actual vs Predicted).
plt.subplot(1,2,2)
sns.scatterplot(x=y_test, y=y_pred, alpha=0.5)
plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], color='red', linestyle='--')  # Perfect fit line
plt.title("Regression Fit: Actual vs Predicted")
plt.xlabel("Actual Prices (in $100,000s)")
plt.ylabel("Predicted Prices (in $100,000s)")


# Show plots.
plt.tight_layout()
plt.show()

Gráficos para visualizar resíduos e o ajuste da regressão

A distribuição dos resíduos (gráfico da esquerda) deve estar centrada em zero, indicando erros distribuídos aleatoriamente. Se os resíduos seguirem uma distribuição normal, o modelo tende a se ajustar bem; se houver assimetria ou tendência, pode haver erros sistemáticos. O ajuste da regressão (gráfico da direita) compara valores reais e previstos; a linha vermelha tracejada representa o ajuste perfeito. Se os pontos seguem de perto a linha, as previsões são precisas — se surgir um padrão (por exemplo, curvatura), a relação pode não ser realmente linear. 

Essas visualizações ajudam a diagnosticar overfitting ou underfitting, revelar padrões nos resíduos que indiquem relações ausentes e oferecer uma avaliação clara da eficácia do modelo.

Aplicações no mundo real

A regressão linear é amplamente usada em diversos setores para previsão e tomada de decisão. No mercado imobiliário, estima preços de casas com base em fatores como tamanho e localização. 

Vendas e marketing a utilizam para previsão de demanda e otimização de orçamento; na saúde, é aplicada para avaliar risco de doenças. Em finanças, auxilia na previsão de preços de ações e no credit scoring; na manufatura, apoia o controle de qualidade e a previsão de falhas. 

Quando usar regressão linear

• As features e a variável alvo têm relação linear.
• Interpretabilidade e simplicidade são mais importantes que modelagem complexa.
• Os dados exigem pouco feature engineering.

Quando não usar regressão linear

• A relação entre a variável alvo e as features é complexa e não linear.
• Os dados são altamente correlacionados.
• Existem outliers que não podem ser removidos. Nesse caso, você pode aplicar transformações nos dados ou usar estratégias para mitigar seu impacto.

Conclusão

A regressão linear continua sendo uma das técnicas mais fundamentais e utilizadas em machine learning e modelagem estatística. Apesar de simples, é poderosa para entender relações entre variáveis e fazer previsões em várias aplicações do mundo real.

Principais aprendizados deste tutorial:

• Aplicações versáteis. A regressão linear gera insights valiosos em múltiplos setores e tipos de problema.
• Interpretável. Ao contrário de modelos complexos e de caixa‑preta, a regressão linear oferece interpretações claras baseadas em coeficientes.
• Seleção de features. Selecionar bem as features e tratar a multicolinearidade mantém os modelos mais precisos, estáveis e confiáveis. 

Para continuar aprendendo sobre interpolação de strings em Python, confira os materiais da DataCamp.

• Simple Linear Regression: Everything You Need to Know - Tutorial
• How to Do Linear Regression in R - Tutorial
• Linear Regression in Excel: A Comprehensive Guide For Beginners - Tutorial
• Introduction to Regression in R - Course
• Supervised Learning with scikit-learn - Course
• Scikit-Learn Cheat Sheet: Python Machine Learning - Cheat Sheet
• Understanding Logistic Regression in Python - Tutorial