Entenda a Regressão Linear: Conceitos e Aplicações

A regressão linear em Python é uma ferramenta estatística essencial para prever valores contínuos, usando a relação entre variáveis. Imagine que você quer prever o preço de uma casa com base no tamanho dela: a regressão linear pode te ajudar! Neste artigo, vamos explorar os diferentes tipos de regressão linear e como você pode implementá-la usando Python, de forma simples e prática.

Tipos de Regressão Linear

Existem três tipos principais de regressão linear em Python, cada um adequado para diferentes situações:

1. Regressão Linear Simples: Utilizada para prever uma variável dependente com base em uma única variável independente.
2. Regressão Linear Múltipla: Emprega múltiplas variáveis independentes para prever uma variável dependente.
3. Regressão Linear Polinomial: Utiliza uma relação polinomial entre as variáveis independentes e dependentes para realizar a previsão.

1. Regressão Linear Simples

A regressão linear simples é usada para prever uma resposta com base em uma única característica. Ela parte do princípio de que existe uma relação linear entre a variável dependente e a independente. A equação da reta de regressão é representada da seguinte forma:

h(x_i) = β_0 + β_1 * x_i

Onde:

• (h(x_i)) é a resposta prevista para a i-ésima observação.
• (β_0) é o ponto onde a reta intercepta o eixo y.
• (β_1) é a inclinação da reta de regressão.

Para estimar (β_0) e (β_1), o objetivo é minimizar o erro residual total, representado pela função de custo (J):

J(β_0, β_1) = (1/2n) * Σ(ε_i²)

Onde (ε_i) é o erro residual para a i-ésima observação.

Implementação em Python da Regressão Linear Simples

Para implementar a regressão linear simples em Python, podemos usar bibliotecas como numpy e matplotlib. Veja como fazer:

import numpy as np
import matplotlib.pyplot as plt

def estimate_coef(x, y):
    n = np.size(x)
    m_x = np.mean(x)
    m_y = np.mean(y)
    SS_xy = np.sum(y * x) - n * m_y * m_x
    SS_xx = np.sum(x * x) - n * m_x * m_x
    b_1 = SS_xy / SS_xx
    b_0 = m_y - b_1 * m_x
    return (b_0, b_1)

def plot_regression_line(x, y, b):
    plt.scatter(x, y, color="m", marker="o", s=30)
    y_pred = b[0] + b[1] * x
    plt.plot(x, y_pred, color="g")
    plt.xlabel('x')
    plt.ylabel('y')
    plt.show()

def main():
    x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    y = np.array([1, 3, 2, 5, 7, 8, 8, 9, 10, 12])
    b = estimate_coef(x, y)
    print("Estimated coefficients:\nb_0 = {}\nb_1 = {}".format(b[0], b[1]))
    plot_regression_line(x, y, b)

main()

2. Regressão Linear Múltipla

A regressão linear múltipla é uma extensão da regressão linear simples, utilizando múltiplas características para prever uma variável de resposta. A equação para a regressão linear múltipla é:

h(x_i) = β_0 + β_1 * x_i1 + β_2 * x_i2 + ... + β_p * x_ip

Onde (p) representa o número de características. Os coeficientes (β_0, β_1, …, β_p) são estimados utilizando o método dos mínimos quadrados. Para entender melhor, imagine que você quer prever o preço de um MacBook Air M4, e para isso, analisa diferentes características, como processador, tamanho da tela e quantidade de memória RAM.

Implementação em Python da Regressão Linear Múltipla

Como exemplo de regressão linear múltipla, podemos usar o conjunto de dados de habitação de Boston:

from sklearn.model_selection import train_test_split
from sklearn import datasets, linear_model
import pandas as pd

# Load the Boston Housing dataset
data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)

# Preprocessing data
X = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
y = raw_df.values[1::2, 2]

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

# Create and train the linear regression model
reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)

# Print regression coefficients
print('Coefficients: ', reg.coef_)
print('Variance score: {}'.format(reg.score(X_test, y_test)))

3. Regressão Linear Polinomial

A regressão polinomial ajusta uma relação não linear entre a variável independente (x) e a variável dependente (y) através do uso de termos polinomiais. Este método pode modelar relações que não são lineares de forma eficaz. Por exemplo, essa regressão pode ser usada para analisar o preço do Bitcoin, que não tem um crescimento linear.

Implementação em Python da Regressão Linear Polinomial

Veja como implementar a regressão polinomial usando Python:

from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# Load dataset
df = pd.read_csv('Position_Salaries.csv')
X = df.iloc[:, 1:2].values
y = df.iloc[:, 2].values

# Create polynomial features
poly_reg = PolynomialFeatures(degree=2)
X_poly = poly_reg.fit_transform(X)

# Fit the polynomial regression model
lin_reg_2 = LinearRegression()
lin_reg_2.fit(X_poly, y)

# Visualize the results
plt.scatter(X, y, color='red')
plt.plot(X, lin_reg_2.predict(X_poly), color='green')
plt.title('Polynomial Regression')
plt.xlabel('Position Level')
plt.ylabel('Salary')
plt.show()

Perguntas Frequentes (FAQs)

1. Como usar a regressão linear para fazer previsões?

   Depois que um modelo de regressão linear é treinado, ele pode ser usado para fazer previsões para novos pontos de dados usando o método predict().

2. O que é regressão linear?

   A regressão linear é um algoritmo de aprendizado de máquina supervisionado usado para prever uma saída numérica contínua com base em relações lineares entre variáveis independentes e dependentes.

3. Como realizar a regressão linear em Python?

   Bibliotecas como scikit-learn fornecem implementações simples para regressão linear. Você pode ajustar um modelo usando a classe LinearRegression.

4. Quais são algumas aplicações da regressão linear?

   As aplicações incluem prever preços de casas, preços de ações, diagnosticar condições médicas e avaliar a rotatividade de clientes.

5. Como a regressão linear é implementada no scikit-learn?

   A classe LinearRegression em scikit-learn permite ajustar um modelo de regressão linear aos dados de treinamento e prever valores-alvo para novos dados.

Ao entender e implementar a regressão linear, você pode modelar e analisar efetivamente as relações dentro de seus dados, gerando insights e previsões em vários domínios.

Com a regressão linear, você pode modelar e analisar as relações dentro de seus dados, obtendo insights valiosos e fazendo previsões precisas em diversas áreas. A capacidade de prever resultados com base em dados existentes é uma ferramenta poderosa no mundo da análise de dados.

Este conteúdo foi auxiliado por Inteligência Artificial, mas escrito e revisado por um humano.

Via dev.to