top of page
  • Geovana Sousa

Entendendo os Modelos de Regressão

Dentro da área de Machine Learning, existem diversos problemas que possuem o objetivo de explorar as relações entre duas ou mais variáveis. Estes problemas são resolvidos aplicando os modelos de Regressão, que é o tema do artigo de hoje.


Confira abaixo os temas que serão abordados ao longo do texto.


Lembrando que todos os modelos vão ser implementados utilizando Python e Scikit-Learn.




O que é uma Regressão Linear


A análise de regressão linear é uma técnica estatística utilizada para modelar e investigar a relação entre uma variável dependente e uma ou mais variáveis independentes. Essa relação é representada por um modelo matemático que estima os coeficientes da equação linear que melhor preveem o valor da variável dependente.

A regressão linear é um dos algoritmos supervisionados de Machine Learning mais conhecidos e utilizados por ser um modelo simples de previsão, que apresenta uma fórmula fácil de ser interpretada. Basicamente, na regressão você tem um fenômeno de interesse e um número de observações, onde cada um possui uma ou mais features. Assumindo que, pelo menos, uma das features depende de outras, você tenta encontrar um relacionamento entre elas.


Um exemplo simples de regressão, é pensar em colaboradores de uma empresa. Dizemos que cada colaborador representa uma observação, e que seu salário depende de algumas variáveis, como experiência, nível de educação, cargo, cidade, e afim.


Para entender melhor como funciona uma regressão linear e essa relação entre as variáveis (features), antes precisamos entender um conceito muito importante, a correlação.


Definindo e Interpretando a Correlação


Basicamente, a existência da correlação entre duas variáveis indica que o valor da variável dependente se altera de acordo com a variável independente. Mas o que isso significa?


Pense na seguinte frase, quanto mais se pratica programação, melhor programador você será. O que podemos entender desta frase? Que você ser um programador melhor, depende de quanto você pratica. Vamos visualizar essa afirmação.


Gráfico Tempo (min) x Bugs

Pelo gráfico, vemos que se o programador pratica 60 minutos a cada semana, ele comete 120 erros (apenas um exemplo, eu sei que na realidade são muitos mais kk). Mas quando ele aumenta a sua frequência de estudos para 30 minutos por dia, o número de erros cai para 20. Este é um clássico caso de uma correlação negativa.


As variáveis podem apresentar 3 tipos de correlações, positiva, negativa ou nula.

  • Positiva: Quando o valor de uma variável aumenta, o outro acompanha

  • Nula: Não há relação entre as variáveis

  • Negativa: Quando o valor de uma variável sobe, o outra desce (ou vice-versa)


Uma correlação linear é medida estatisticamente utilizando o coeficiente de correlação de Pearson (r de Pearson). Ao encontrar este coeficiente é possível identificar, ao mesmo tempo, a força e o tipo de relação.


O coeficiente de correlação será sempre um número entre -1 e 1, sendo 1 uma correlação linear positiva perfeita, -1 uma correlação linear negativa perfeita. Quando temos o resultado sendo 0 devemos ter um pouco mais de cautela, pois pode ser um indicativo de que não existe uma correlação linear, mas pode sim haver algum outro tipo de correlação entre as variáveis.


Apesar de existirem essas classificações, é muito raro encontrar correlações perfeitas em dados reais. Por conta disso, os estudiosos e pesquisadores da área criam diversas categorias para ajudar na interpretação deste coeficiente. Abaixo temos algumas categorias e valores comumente adotados na interpretação, mas estes podem mudar de acordo com o campo de estudo.


Valor do R de Pearson

0 - 0.2

Correlação muito Fraca

​0.2 - 0.4

Correlação Fraca

​0.4 - 0.6

Correlação Moderada

0.6 - 0.8

Correlação Forte

0.8 - 1.0

Correlação Muito Forte


Escala de Correlação
Escala de Correlação


Agora que você entendeu o que é uma correlação, já deve saber o porquê dela estar sendo mencionada neste artigo. Mas se não entendeu, vamos lá que eu te explico!


Podemos dizer que a Regressão é uma forma de aplicar esta ideia de análise de correlação, só que de forma mais avançada. Ao invés de utilizar a força de correlação para entender a relação entre as variáveis, a regressão descreve este relacionamento em uma equação matemática que permite utilizá-la para prever valores futuros.


Formulação do Problema


De forma geral, um modelo de regressão assume uma relação linear entre a variável dependente y e a variável independente x. Assim, consegue realizar predições a partir da combinação linear das variáveis mais uma constante chamada de termo de Bias, o erro padrão. O resultado é a equação de regressão abaixo:

y = 𝛽₀ + 𝛽₁𝑥₁ + ⋯ + 𝛽ᵣ𝑥ᵣ + 𝜀


O objetivo da regressão é encontrar as estimativas para os coeficientes da equação, de forma a minimizar os erros de previsão de y. Esses coeficientes definem a função de regressão estimada (declarada abaixo), que avalia a dependência entre os inputs e outputs.

𝑓(𝐱) = 𝑏₀ + 𝑏₁𝑥₁ + ⋯ + 𝑏ᵣ𝑥ᵣ


A ideia é que a estimativa para cada observação (𝑓(𝐱ᵢ)), seja o mais próximo possível do valor real (𝑦ᵢ), e para avaliar essa diferença, calculamos os resíduos da previsão, ou seja, 𝑦ᵢ - 𝑓(𝐱ᵢ).


Para encontrar os melhores coeficientes, normalmente, utilizamos o método dos mínimos quadrados ordinários, onde fazemos a minimização da soma dos erros ao quadrado (SSR) para todas as observações 𝑖 = 1, …, 𝑛 em:

SSR = Σᵢ(𝑦ᵢ - 𝑓(𝐱ᵢ))²


Medindo a Performance da Regressão


Para determinar quão bem o nosso modelo consegue realizar predições, normalmente, utilizamos uma medida chamada de coeficiente de determinação (). O R-squared é uma medida estatística que avalia qual quantidade de variação de y pode ser explicada pela dependência de x em um modelo de regressão.


O coeficiente é um valor entre 0 e 1, onde quanto mais próximo de 1, melhor o ajuste e mostra que o modelo consegue explicar bem a variação dos outputs de acordo com diferentes inputs.


Um = 1 significa que temos o SSR = 0, ou seja, temos um fit perfeito das previsões com os valores reais.



Agora que sabemos o que é e como funciona uma regressão, vamos entender os diferentes tipos de modelos utilizando exemplos práticos.



Regressão Linear Simples


A regressão linear simples é o modelo onde fazemos a predição do valor de y (𝑓(𝑥)) a partir do seu relacionamento linear com uma variável independente x, tendo como função de regressão:

𝑓(𝑥) = 𝑏₀ + 𝑏₁𝑥


Na equação, o termo 𝑏₀ é o valor onde a regressão intercepta o eixo y, e 𝑏₁ é o coeficiente de inclinação da reta. O objetivo do modelo é encontrar os valores de ambos coeficientes que minimizem o SSR.


Temos outro fator importante que devemos analisar na regressão, os resíduos, que são as diferenças entre os valores previstos e os reais. Essa diferença é calculada com a seguinte equação:

𝑦ᵢ - 𝑓(𝐱ᵢ) = 𝑦ᵢ - 𝑏₀ - 𝑏₁𝑥ᵢ para 𝑖 = 1, …, 𝑛



Agora, vamos entender como isso funciona na prática



Implementação com Python e Scikit-Learn


Para entendermos melhor o conceito, iremos utilizar um dataset sobre Consumo de Combustível, disponibilizado pelo IBM Object Storage. Dentro do csv, temos as especificações de gastos de combustível, assim como a estimativa de emissão de dióxido de carbono para cada modelo de carro sendo vendido no Canadá. O arquivo pode ser encontrado abaixo para download.


FuelConsumptionCo2
.csv
Fazer download de CSV • 73KB

Para acompanhar todo o código e aproveitar para praticar com exercícios, acesse o notebook complementar deste artigo, disponível no Google Colab.


Este é um dataset completo para realizar análises, como queremos apenas entender o conceito básico de uma Regressão, não iremos utilizar todas as features disponíveis.


Vamos para o código!

# Importando as bibliotecas necessárias
import matplotlib.pyplot as plt
import pandas as pd
import pylab as pl
import numpy as np
%matplotlib inline

# Após o download do arquivo, vamos importá-lo
df = pd.read_csv("FuelConsumptionCo2.csv")

# Selecionando as Features que utilizaremos
df = df[['ENGINESIZE', 'CYLINDERS', 'FUELCONSUMPTION_COMB', 'CO2EMISSIONS']]

Agora, temos um dataset com algumas features específicas que podem ser usadas no nosso modelo. Com isso, podemos analisar graficamente as features para saber quais possuem uma relações linear com a quantidade de CO2 emitido pelo carro.



Analisando os gráficos acima, vemos que ambos apresentam um comportamento linear entre as features. Para este exemplo, apenas iremos criar o modelo de machine learning para o segundo gráfico, 'Tamanho do Motor' X 'Emissão de CO2'.


Antes de trabalhar na construção do modelo, precisamos separar os datasets de treino e teste, para isso fazemos:

mask = np.random.rand(len(df)) < 0.8
treinamento = df[mask]
teste = df[~mask]

Em seguida, importamos a biblioteca do python Scikit-Learn para gerar o modelo de forma rápida e eficaz.

### Usando o pacote sklearn (Scikit-Learn) para modelar o algoritmo
from sklearn import linear_model
regressao = linear_model.LinearRegression()
treino_x = np.asanyarray(treinamento[['ENGINESIZE']])
treino_y = np.asanyarray(treinamento[['CO2EMISSIONS']])
regressao.fit(treino_x, treino_y)

# Coeficientes
print("Coeficientes:", regressao.coef_)
print("Interceptação:", regressao.intercept_)
Output
Coeficientes: [[39.02845648]] 
Interceptação: [127.08197097]
### Plotando a linha da regressão
plt.scatter(treinamento.ENGINESIZE, treinamento.CO2EMISSIONS, color='#8390A2', s=20)
plt.plot(treino_x, regressao.coef_[0][0]*treino_x + regressao.intercept_[0], color='#FC5C65')
plt.xlabel("Engine Size")
plt.ylabel("CO2 Emission")
plt.show();


Com isso, temos o nosso modelo de Regressão, agora podemos fazer a predição e avaliar sua performance da seguinte maneira.

### Predição
from sklearn.metrics import r2_score
teste_x = np.asanyarray(teste[['ENGINESIZE']])
teste_y = np.asanyarray(teste[['CO2EMISSIONS']])
y_prev = regressao.predict(treino_x)

### Avaliando
print("Erro Médio Absoluto: %.2f" % np.mean(np.absolute(y_prev - teste_y)))
print("Soma dos Erros ao Quadrado (MSE): %.2f" % np.mean((y_prev - teste_y) ** 2))
print("R2-score: %.2f" % r2_score(teste_y, y_prev))
Output
Erro Médio Absoluto: 23.38
Soma dos Erros ao Quadrado (MSE): 939.31 
R2-score: 0.76

Regressão Linear Múltipla


A regressão linear múltipla ou multivariada é aquela onde temos duas ou mais variáveis independentes. No caso se serem apenas duas, a função de regressão é a seguinte:


𝑓(𝑥₁, 𝑥₂) = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥


Este modelo, representa um plano no espaço tridimensional de 𝑓(𝑥₁, 𝑥₂), 𝑥₁ e 𝑥₂, onde 𝑏₀ é a interseção do plano, 𝑏₁ e 𝑏₂ são os coeficientes parciais de regressão. No caso de existirem mais de duas variáveis, temos a seguinte equação, conhecida como modelo de regressão linear múltipla com r variáveis regressoras:


𝑓(𝑥₁, …, 𝑥ᵣ) = 𝑏₀ + 𝑏₁𝑥₁ + ⋯ +𝑏ᵣ𝑥ᵣ


Nas duas equações, 𝑏ᵣ representa a variação esperada em 𝑓(𝑥₁, 𝑥₂), e temos como objetivo encontrar seus valores de forma a reduzir ao máximo o SSR do plano previsto.


Implementação com Python e Scikit-Learn


Para implementação da regressão linear múltipla, iremos utilizar o mesmo dataset disponibilizados anteriormente. Porém, a maior diferença aqui, será na hora de selecionar a quantidade de features para serem modeladas.

## Criando o dataframe
df = pd.read_csv("FuelConsumptionCo2.csv")
df = df[['ENGINESIZE', 'CYLINDERS', 'FUELCONSUMPTION_CITY', 'FUELCONSUMPTION_HWY', 'FUELCONSUMPTION_COMB', 'CO2EMISSIONS']]

### Criando os datasets de treino e teste
msk  = np.random.rand(len(df)) < 0.8
train = df[msk]
test = df[msk]

Agora que realizamos os passos iniciais do processo, vamos para a parte de selecionar as features que queremos realizar a regressão.

### Usando o pacote sklearn (Scikit-Learn) para treinar o algoritmo
regr = linear_model.LinearRegression()
x = np.asanyarray(train[['ENGINESIZE', 'CYLINDERS', 'FUELCONSUMPTION_COMB']])
y = np.asanyarray(train[['CO2EMISSIONS']])
regr.fit(x, y)

# Coeficientes
print ('Coeficientes: ', regr.coef_)
Output
Coeficientes:  [[10.46249293  7.66791251  9.6188157 ]]

Aqui, já vemos que para treinar o modelo, selecionamos 3 variáveis que acreditamos terem uma relação com a emissão de carbono de cada carro, diferentemente do que fizemos anteriormente ao selecionarmos apenas uma feature.

### Predição
x_teste = np.asanyarray(test[['ENGINESIZE', 'CYLINDERS', 'FUELCONSUMPTION_COMB']])
y_teste = np.asanyarray(test[['CO2EMISSIONS']])
y_prev = regr.predict(x_teste)

# Avaliando a Performance do modelo
print("Soma dos Erros ao Quadrado (MSE): %.2f" % np.mean((y_prev - y_teste) ** 2))
Output
Soma dos Erros ao Quadrado (MSE): 534.09

Regressão Polinomial


Na regressão polinomial, o modelo faz o fit de uma curva nos dados. Você precisa estimar uma dependência polinomial entre os outputs e inputs para estimar a função de regressão. Mas como isso realmente funciona?


Vamos analisar o seguinte exemplo, com a função polinomial:

y = 𝑏₀ + 𝑏₁𝑥 + 𝑏₂𝑥² + 𝑏₃𝑥³


Esta função, pode ser transformada em um modelo de regressão linear, assumindo:

𝑥₁ = 𝑥

𝑥₂ = 𝑥²

𝑥₃ = 𝑥³


Com isso, o modelo é convertido em uma regressão linear simples com novas variáveis:

y = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂ + 𝑏₃𝑥₃


Essa regressão pode ser considerada um caso especial de regressão linear múltipla, e assim, podemos utilizar os mesmos métodos para chegar em uma predição.


Implementação com Python e Scikit-Learn


Aqui, iremos utilizar novamente o mesmo dataset de emissão de CO2. Vamos começar importando o dataframe e separando os datasets de treino e teste.

## Criando o dataframe
df = pd.read_csv("FuelConsumptionCo2.csv")
df = df[['ENGINESIZE', 'CYLINDERS', 'FUELCONSUMPTION_COMB', 'CO2EMISSIONS']]

### Criando os datasets de treino e teste
msk  = np.random.rand(len(df)) < 0.8
train = df[msk]
test = df[msk]

Agora, podemos começar a modelar o problema de forma a transformá-lo em uma regressão linear múltipla. Para isso, iremos utilizar uma função do Scikit-Learn chamada fit_transform, ela é responsável por receber os valores de 𝑥 e os devolve como outputs em formato de lista, onde cada valor é o próprio elemento elevado da potência 0 a 2 (neste caso, até 2 por se tratar de uma função de segundo grau).

fit_transform operation

Então, para poder usar esse recurso, vamos utilizar o código abaixo:

### Usando o pacote sklearn (Scikit-Learn) para treinar o algoritmo
from sklearn.preprocessing import PolynomialFeatures
from sklearn import linear_model
treino_x = np.asanyarray(train[['ENGINESIZE']])
treino_y = np.asanyarray(train[['CO2EMISSIONS']])

test_x = np.asanyarray(test[['ENGINESIZE']])
test_y = np.asanyarray(test[['CO2EMISSIONS']])

poly = PolynomialFeatures(degree=2)
treino_x_poly = poly.fit_transform(treino_x)
treino_x_poly
Output
array([[ 1.  ,  2.  ,  4.  ],        
       [ 1.  ,  2.4 ,  5.76],        
       [ 1.  ,  3.5 , 12.25],        
       ...,        
       [ 1.  ,  3.  ,  9.  ],        
       [ 1.  ,  3.2 , 10.24],        
       [ 1.  ,  3.2 , 10.24]])

Agora, podemos modelar a regressão da mesma maneira que já estávamos fazendo acima.

 ### Usando o pacote sklearn (Scikit-Learn) para treinar o algoritmo
modelo_L = linear_model.LinearRegression()
treino_y_hat = modelo_L.fit(treino_x_poly, treino_y)

# Coeficientes
print('Coeficientes:', modelo_L.coef_)
print('Interceptação:', modelo_L.intercept_)

Vamos ver como ficou a curva de regressão que acabamos de modelar.

Como vemos, a curva está alinhada com a distribuição dos dados que foram fornecidos ao modelo. Por último, podemos avaliar a performance deste modelo.

### Predição
teste_x_poly = poly.fit_transform(test_x)
y_prev = modelo_L.predict(teste_x_poly)

# Avaliando a Performance do modelo
print("Erro Médio Absoluto: %.2f" % np.mean(np.absolute(y_prev - test_y)))
print("Soma dos Erros ao Quadrado (MSE): %.2f" % np.mean((y_prev - test_y) ** 2))
print("R2-score: %.2f" % r2_score(test_y, y_prev))
Output
Erro Médio Absoluto: 23.65 
Soma dos Erros ao Quadrado (MSE): 958.16 
R2-score: 0.77


Conclusão


Chegamos ao final de mais um artigo, e para recapitular o que aprendemos, devemos lembrar que existem diversos modelos de regressão utilizados em Machine Learning. Hoje, falamos sobre os três principais, a Regressão Linear simples que é utilizada quando temos apenas uma variável que influencia nosso output, a Regressão Linear Múltipla que recebe duas ou mais variáveis independentes, e por último, a Regressão Polinomial que é um caso mais especial tratado como uma regressão múltipla.


Lembrando que caso você queira guardar o código deste artigo ou realizar os exercícios complementares, acesse este notebook do Google Colab.


 

Espero que tenham gostado do conteúdo. Se desejam aprender mais sobre Data Science, Machine Learning, Inteligência Artificial e outros assuntos relacionados, me sigam no LinkedIn para não perderem as próximas atualizações. 😉

Posts Relacionados

Ver tudo

Comments


bottom of page