Entendendo Regressão Linear com Sklearn

Nesse post quero trazer uma explicação superficial de como funciona um modelo de Machine Learning supervisionado utilizando a regressão linear múltipla da biblioteca scikit-learn.

Após um tempo de pesquisa, encontrei uma forma consideravelmente relevante para iniciar o entendimento do funcionamento de um algoritmo de Machine Learning: criar minha própria regressão linear.

Pesquisando sobre datasets, encontrei o Auto MPG, uma base de dados que mostra o consumo de combustível de carros com modelos dos anos 1970 até 1982. Segundo a documentação da base, ela oferece informações como:

• mpg (miles per gallon): Eficiência de combustível — quanto maior o valor, mais econômico é o carro.
• cylinders: Número de cilindros do motor.
• displacement: Volume do motor em polegadas cúbicas — motores maiores tendem a consumir mais.
• horsepower: Potência do motor, medida em HP.
• weight: Peso do carro em libras.
• Origin: A Origem do carro, uma variável classificativa.
• car_name: Contendo o modelo e nome do carro.

Dando início à criação do algoritmo, comecei com uma pequena visualização e tratamento dos dados, utilizando métodos do Pandas como describe e info, além de verificar e corrigir valores nulos, identificar outliers e aplicar o One-Hot Encoding na variável Origin. Enfim, realizei um pré-processamento dos dados para que o algoritmo tivesse um desempenho considerável.

Concluindo o pré-processamento e entendimento do dataset, dei inicio a criação do algoritmo da regressão linear múltipla.

Regressão Linear

Chegamos ao ponto principal: Regressão Linear.
A Regressão Linear Simples e Múltipla tem como objetivo prever valores numéricos contínuos por meio de métodos matemáticos, como Gradiente Descendente ou Álgebra Linear.
Existem outros tipos de regressão, como a Regressão Polinomial ou Regressão Logística, mas aqui o foco é entender os fundamentos da regressão linear simples e múltipla.
A principal diferença entre elas está na quantidade de variáveis independentes:

• Na regressão linear simples, temos uma variável independente (X).
• Na regressão múltipla, utilizamos duas ou mais variáveis independentes.

No modelo, chamamos de variáveis independentes aquelas que influenciam o valor previsto — normalmente representadas por X —, e de variável dependente (representada por y) o valor que queremos prever, pois ele depende dos valores das variáveis independentes.

Dando inicio a criação, defini as variáveis X e a variável y:

X = df.drop(columns=["mpg"]) y = df["mpg"] 

Como o contexto do objetivo da previsão é prever o "mpg" ela será a nossa label/rotulo a nossa variável target.

Definindo as variáveis importamos a função train_test_split da biblioteca scikit-learn:

from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) 

• Então como essa função funciona ? Ela tem como um objetivo, divir os dados em X e y, separando-os em subconjuntos de treino e teste, mas mantendo o seu parâmetro, no caso, se é uma label(variável target que queremos prever) ou se ela é uma variável que vai influenciar na previsão, podemos definir como feature

Fluxo da função

test_size

• No inicio ele recebe os parâmetros e os dados de X e y, realizando um cálculos dos índices para separar em conjunto de teste com base no test_size(parâmentros que define a quantidade de dado que vai ser separado em treino e teste), se o test_size for 0.2 ele vai multiplicar esse valor pelo o total de dados realizando a separação do treino e teste, ou seja, 20% teste e 80% treino. Se a nossa base de dados tem 400 linhas ele vai realizar o seguinte calculo. 400 × 0.2 = 80 linhas para teste 400 - 80 = 320 linhas para treino
• Ele também verifica se os dados tem a mesma correspondência, exemplo se o valor de X (entrada) tem o mesmo valor de y (Rotulo).

random_state

• É executado junto com o .fit o embaralhamento para evitar que o algoritmo treine com dados que apresentem padrões específicos, que poderiam levar ao overfitting. Ele também ajuda a equilibrar a divisão dos dados, garantindo que os conjuntos de treino e teste sejam mais representativos e aleatórios.
• O random_state é definido para que essa aleatoriedade se torna reproduzível, ou seja, o mesmo embaralhamento ocorre em cada execução, permitindo resultados consistentes. Isso facilita o debugging e garante que outras pessoas possam reproduzir o algoritmo com os mesmos resultados.

Regressão Linear

Após a separação e o treinamento dos dados iniciei a criação da regressão linear.

from sklearn.linear_model import LinearRegression modelo = LinearRegression() modelo.fit(X_train, y_train) 

Essa classe implementa um modelo de regressão linear, que ajusta uma linha ou hiperplano aos dados, prevendo valores contínuos.

• Como funciona esse classe ?

Após instanciarmos a classe, ela realiza o método .fit que calcula o Coeficiente w e o Intercepto b, eles são parâmetros principais da equação de uma regressão linear e servem para definir a Reta de ajuste que melhor representa os dados.

Coeficiente

• Os coeficientes da regressão linear representam a inclinação da reta de regressão em relação ás variáveis independentes (X), eles são determinados resolvendo o problema de mínimos quadrados ordinários (OLS): A formula seria Após o calculo da equação, nós temos o coeficiente.

Intercepto

• O intercepto é o ponto onde a reta cruza o eixo y. Ele representa o valor predito para (y) quando as variáveis X são igual a 0. Exemplo: Durante o treinamento, o modelo ajusta automaticamente o valor do intercepto 𝑏 — junto com os coeficientes — de forma a minimizar o erro entre as previsões e os valores reais. O valor de 𝑏 que melhor se encaixar nos dados (gerar menor erro total) é o que será aprendido pelo modelo. A formula seria:

Após treinar o modelo com o método .fit, que calcula os coeficientes e o intercepto, usamos o método .predict para obter as previsões do modelo para os dados de teste e quando estiver tudo pronto prever valores de dados futuros.

from sklearn.metrics import mean_squared_error, r2_score y_pred = modelo.predict(X_test) 

Aqui o y_pred recebe valores previstos do X_test.

• Como ele cria essas previsões ? O método .predict aplica a fórmula da regressão linear, neste caso a formula da regressão linear múltipla para cada amostra i (a linha da base de dados) de X_test

Contexto da formula

Então temos:

• O "y de chápeu"
• O intercepto b calculado pelo o .fit
• Cada variável da amostra multiplicada pelo o seu peso(coeficiente w) chegando ao resultado da previsão.

Junto nesse bloco do código, importei 2 métricas de avaliação do nosso modelo, elas explicam o quão bem o modelo aprendeu a prever.

Mean Squared Error (MSE)

• Essa métrica é o Erro Quadrático Médio, ela mede a diferença entre os valores reais (y) e os valores previstos (y"chapéu"), elevando essa diferênça ao quadrado.
• Interpretação: Quanto menor o valor do MSE, melhor é o desempenho do modelo, pois isso significa que os erros de previsão estão menores. No entanto, o MSE é sensível a outliers, já que os erros são elevados ao quadrado.

R2 Score

• Essa métrica é o R² - Coeficiente de Determinação, ela mede o quanto da variabilidade dos dados o modelo conseguiu explicar. Interpretação:

R2 = 1: O modelo explicou 100% da variabilidade dos dados.
R2 = 0: O modelo não conseguiu explicar nada além da média dos valores reais.
R2 < 0: O modelo é pior que um modelo trivial (que simplesmente usaria a média como previsão).

Na prática

Então vamos visualizar como ficou o modelo de regressão da base de dados Auto MPG.

from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error, r2_score modelo = LinearRegression() modelo.fit(X_train, y_train) y_pred = modelo.predict(X_test) print("Erro quadrático médio (MSE):", mean_squared_error(y_test, y_pred)) print("R² (coeficiente de determinação):", r2_score(y_test, y_pred)) 

Aqui então temos a utilização dos modelos .fit passando como parâmetros os nossos dados de treino e .predict passando os nossos dados de testes para prever os valores com base no que foi aprendido no treino.
E por fim chamando o as métricas para a visualização do quando o nosso modelo foi preciso.
Erro quadrático médio (MSE): 8.3391425002559
R² (coeficiente de determinação): 0.8449006123776617
MSE = 8.33 --> 8.33 significa que, em média, os quadrados das diferenças entre os valores previstos e os valores reais é 8.33. Tirando o valor MSE ao quadrado, temos um valor de 2.89, que significa que nosso modelo tem um erro médio de 2.89.
R² = 0.84 --> O modelo explicou 84% da variabilidade dos dados com base nos padrões que encontrou.

Agora visualizando isso de uma forma gráfica, vamos gerar um gráfico utilizando a biblioteca matplotlib, e comparar o MPG real com o MPG previsto.

import matplotlib.pyplot as plt df_compare = pd.DataFrame({ 'Real MPG': y_test, 'Previsto MPG': y_pred }) print(df_compare.head()) plt.figure(figsize=(8,6)) plt.scatter(df_compare['Real MPG'], df_compare['Previsto MPG'], alpha=0.7) plt.plot([df_compare['Real MPG'].min(), df_compare['Real MPG'].max()], [df_compare['Real MPG'].min(), df_compare['Real MPG'].max()], color='red', lw=2) plt.xlabel('MPG Real') plt.ylabel('MPG Previsto') plt.title('Comparação entre MPG real e previsto') plt.show() 

Por fim temos este resultado, onde:
Linha Vermelha é a nossa linha que o modelo .fit aprendeu, seria a nossa Reta de ajuste, ou seja, ela é onde fica o ponto de "perfeição" teórico, onde o valor que ficar ali, foi previsto com total precisão.
Bolinhas Azuis São as predições que tivemos, ou seja, se ela ficou em cima da linha vermelha, foi prevista com exatidão, se ficou mais abaixo o modelo subestimou o MPG e acima o modelo superestimou o MPG.

Conclusão

Por fim, temos o nosso modelo de regressão múltipla. Não chegamos à previsão perfeita, o que é esperado, pois a regressão linear tem limitações, especialmente em cenários onde as relações nos dados são mais complexas, ou a nossa base de dados é relativamente pequena, como a Auto MPG que contém menos de 400 linhas. Contudo, conseguimos compreender como funciona um modelo de machine learning supervisionado, onde ele aprende com os dados fornecidos com base em cálculos matemáticos para fazer previsões. Esse processo é um marco inicial para entender modelos mais avançados e suas aplicações em cenários reais.