Regressão Linear
A Regressão Linear é uma técnica estatística e de aprendizado de máquina utilizada para modelar e analisar relações entre variáveis. No contexto de Machine Learning, é empregada para prever o valor de uma variável dependente (ou variável de resposta) com base nos valores de uma ou mais variáveis independentes (ou preditores), assumindo que a relação entre as variáveis é linear. Isso significa que se espera que a variável dependente mude conforme as variáveis independentes mudam, de uma maneira que possa ser descrita usando uma linha reta.
A regressão linear é uma das técnicas estatísticas mais fundamentais e amplamente utilizadas para análise preditiva e modelagem estatística. Ela é usada para modelar a relação entre uma variável dependente (Y) e uma ou mais variáveis independentes (X). O objetivo é encontrar uma linha (em regressão linear simples) que melhor se ajuste aos dados, de modo a prever os valores da variável dependente com base nos valores das variáveis independentes.
A formulação matemática da regressão linear pode ser simples (com uma única variável independente) ou múltipla (com várias variáveis independentes). A forma mais básica da regressão linear é a regressão linear simples, que é modelada pela equação:
\(y = \beta_0 + \beta_1x +\epsilon\)
Onde:
- \(y\) é a variável dependente que queremos prever;
- \(x\) é a variável independente usada para fazer a previsão;
- \(\beta_0\) é o intercepto, ou seja, o valor de (y) quando (x) é 0;
- \(\beta_1\) é o coeficiente da variável (x), indicando o tamanho do efeito que (x) tem sobre (y);
- \(\epsilon\) representa o erro do modelo, ou seja, a diferença entre os valores observados e os valores previstos pelo modelo.
No Machine Learning, a regressão linear pode ser ajustada usando vários métodos, sendo o mais comum o Método dos Mínimos Quadrados. Esse método busca minimizar a soma dos quadrados das diferenças entre os valores observados e os valores previstos pela linha de regressão.
Avaliação:
Para avaliar a acurácia de um modelo de regressão linear, especialmente no contexto de aprendizado de máquina, utilizamos métricas de desempenho específicas para tarefas de regressão, ao invés de “acurácia”, que é mais comumente usada em tarefas de classificação. Algumas das métricas mais comuns para avaliar a performance de modelos de regressão incluem o Coeficiente de Determinação (R²), o Erro Quadrático Médio (MSE) e o Erro Absoluto Médio (MAE). Vou mostrar como calcular essas métricas para o exemplo de regressão linear apresentado anteriormente, utilizando a biblioteca scikit-learn.
Coeficiente de Determinação \((R^2)\)
O R² mede a proporção da variância na variável dependente que é previsível a partir das variáveis independentes. Ele fornece uma indicação de quão bom é o modelo em prever os resultados. Um valor de R² de 1 indica um ajuste perfeito.
Erro Quadrático Médio (MSE)
O MSE é a média dos quadrados dos erros, ou seja, a média das diferenças quadradas entre os valores observados e os valores previstos. Quanto menor o MSE, melhor o modelo.
Erro Absoluto Médio (MAE)
O MAE é a média do valor absoluto dos erros, que fornece uma ideia da magnitude dos erros, sem considerar a sua direção (positiva ou negativa). Um MAE menor indica um melhor modelo.
Exemplo Simples com Valores Aleatórios :
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
# Gerando dados simulados
# np.random.seed(0) # Descomente para resultados consistentes
x = np.random.rand(100, 1) * 10 # 100 valores aleatórios de x entre 0 e 10
y = 2 * x + 1 + np.random.randn(100, 1) * 2 # y = 2x + 1 mais algum ruído
# Criando o modelo de regressão linear
modelo = LinearRegression()
# Treinando o modelo com os dados gerados
modelo.fit(x, y)
# Coeficientes do modelo
print(f"Intercepto (b0): {modelo.intercept_[0]}")
print(f"Coeficiente (b1): {modelo.coef_[0][0]}")
# Previsões com o modelo treinado
x_novo = np.linspace(0, 10, 100).reshape(-1, 1) # Gerando novos valores de x para fazer previsões
y_pred = modelo.predict(x_novo)
# Calculando as métricas
mse = mean_squared_error(y, modelo.predict(x))
mae = mean_absolute_error(y, modelo.predict(x))
r2 = r2_score(y, modelo.predict(x))
print(f"MSE (Erro Quadrático Médio): {mse}")
print(f"MAE (Erro Absoluto Médio): {mae}")
print(f"R² (Coeficiente de Determinação): {r2}")
# Visualizando os dados e o modelo de regressão linear
plt.scatter(x, y, color='blue', label='Dados reais')
plt.plot(x_novo, y_pred, color='red', label='Linha de regressão linear')
plt.title('Regressão Linear Simples')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.show()
Outro Exemplo:
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
# Gerando dados simulados
# np.random.seed(0) # Descomente para resultados consistentes
x = np.random.rand(100, 1) * 10 # 100 valores aleatórios de x entre 0 e 10
y = 2 * x + 1 + np.random.randn(100, 1) * 6 # y = 2x + 1 mais algum ruído
# Criando o modelo de regressão linear
modelo = LinearRegression()
# Treinando o modelo com os dados gerados
modelo.fit(x, y)
# Coeficientes do modelo
print(f"Intercepto (b0): {modelo.intercept_[0]}")
print(f"Coeficiente (b1): {modelo.coef_[0][0]}")
# Previsões com o modelo treinado
x_novo = np.linspace(0, 10, 100).reshape(-1, 1) # Gerando novos valores de x para fazer previsões
y_pred = modelo.predict(x_novo)
# Calculando as métricas
mse = mean_squared_error(y, modelo.predict(x))
mae = mean_absolute_error(y, modelo.predict(x))
r2 = r2_score(y, modelo.predict(x))
print(f"MSE (Erro Quadrático Médio): {mse}")
print(f"MAE (Erro Absoluto Médio): {mae}")
print(f"R² (Coeficiente de Determinação): {r2}")
# Visualizando os dados e o modelo de regressão linear
plt.scatter(x, y, color='blue', label='Dados reais')
plt.plot(x_novo, y_pred, color='red', label='Linha de regressão linear')
plt.title('Regressão Linear Simples')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.show()
Dataset de Diabetes com Redução de Dimensionalidade:
O dataset de diabetes consiste em 442 amostras com 10 variáveis baseadas em medidas fisiológicas de 442 pacientes. Essas variáveis são indicadores biomédicos potencialmente relacionados ao diabetes, como pressão sanguínea, índice de massa corporal (IMC), concentração de glicose, e outros.
Variáveis do Dataset:
As 10 características (variáveis independentes) são quantitativas e incluem:
Idade: em anos.
Sexo.
IMC: Índice de Massa Corporal.
BP: Pressão arterial média.
S1: TC, concentrações de T-Cells (um tipo de célula branca).
S2: LDL, baixa densidade de lipoproteínas.
S3: HDL, alta densidade de lipoproteínas.
S4: TCH, hormônio estimulante da tireoide.
S5: LTG, lamotrigina.
S6: Glicose.
É possível reduzir a dimensionalidade do dataset de Diabetes (ou de qualquer outro dataset com múltiplas características) para facilitar a visualização e o entendimento dos modelos de regressão, especialmente quando se deseja aplicar uma regressão linear simples para fins didáticos. Uma técnica comum para redução de dimensionalidade é a Análise de Componentes Principais (PCA – Principal Component Analysis).
A PCA transforma os dados para um novo sistema de coordenadas, reduzindo o número de variáveis e mantendo as que mais contribuem para a variação nos dados. Isso pode ser particularmente útil para visualizar a relação entre múltiplas características e a variável alvo em um espaço de menor dimensão.
# Carregar Bibliotecas
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
# Carregar Dataset
diabetes = datasets.load_diabetes()
X = diabetes.data # Usar todas as características
y = diabetes.target
# Aplicar PCA para reduzir a dimensionalidade
pca = PCA(n_components=1)
X_pca = pca.fit_transform(X)
# Treinamento e Teste
X_train, X_test, y_train, y_test = train_test_split(X_pca, y, test_size=0.2, random_state=42)
# Treinar o Modelo de Regressão Linear
model = LinearRegression()
model.fit(X_train, y_train)
# Fazer previsões
y_pred = model.predict(X_test)
# Visualizar os Resultados
plt.scatter(X_test, y_test, color='black')
plt.plot(X_test, y_pred, color='blue', linewidth=3)
plt.xlabel('Componente Principal')
plt.ylabel('Progressão da Doença')
plt.title('Regressão Linear Após PCA - Dataset Diabetes')
plt.show()
# Avaliar o Modelo
print('MSE:', mean_squared_error(y_test, y_pred))
print('R² score:', r2_score(y_test, y_pred))
Ao aplicar a PCA antes da regressão linear, você reduz a complexidade do modelo e facilita a visualização e interpretação dos resultados, especialmente em casos de datasets com múltiplas dimensões. No entanto, é importante notar que a redução de dimensionalidade pode também resultar na perda de informações importantes, o que pode afetar o desempenho do modelo. Portanto, é uma questão de balancear a simplicidade e a eficácia do modelo.