3.3 Regressão polinomial

E se os seus dados forem realmente mais complexos do que uma simples reta? Surpreendentemente, pode realmente usar um modelo linear para ajustar dados não lineares. Uma maneira simples de fazer isso é adicionar poderes de cada recurso como novos recursos e, em seguida, treinar um modelo linear sobre esse conjunto estendido de recursos. Esta técnica é chamada de Regressão Polinomial.

Regressão Polinomial é um algoritmo de regressão que modela a relação entre uma variável dependente(y) e independente(x) como polinômio de nono grau. A equação de Regressão Polinomial é dada abaixo:

\(y= β_0+β_1x_1^1+ β_2x_1^2+ β_3x_1^3+...... β_nx_1^n\)

É também chamado de caso especial de Regressão Linear Múltipla em ML. Porque adicionamos alguns termos polinomiais à equação de regressão linear múltipla para convertê-la em regressão polinomial.

É um modelo linear com algumas modificações a fim de aumentar a precisão.

O conjunto de dados utilizado na regressão polinomial para treinamento é de natureza não linear.

Ele faz uso de um modelo de regressão linear para ajustar as funções e conjuntos de dados complicados e não lineares.

Assim, "Na regressão polinomial, as características originais são convertidas em características polinomiais de grau requerido (2,3,..,n) e, em seguida, modeladas usando um modelo linear."

A necessidade de Regressão Polinomial em ML pode ser entendida nas seguintes situações:

• Se aplicarmos um modelo linear a um conjunto de dados linear, ele fornece-nos um bom resultado, como vimos na Regressão Linear Simples, mas se aplicarmos o mesmo modelo sem qualquer modificação em um conjunto de dados não linear, então ele produzirá uma saída drástica. Devido ao qual a função de perda aumentará, a taxa de erro será alta e a precisão será diminuída.
• Portanto, para esses casos, onde os pontos de dados são organizados de forma não linear, precisamos do modelo de Regressão Polinomial. Podemos entendê-lo de uma maneira melhor usando o diagrama de comparação abaixo do conjunto de dados linear e do conjunto de dados não linear.

• Na imagem acima, tomamos um conjunto de dados que está organizado de forma não linear. Então, se tentarmos cobri-lo com um modelo linear, podemos ver claramente que ele quase não cobre qualquer ponto de dados. Por outro lado, uma curva é adequada para cobrir a maioria dos pontos de dados, que é do modelo Polinomial.
• Assim, se os conjuntos de dados são organizados de forma não linear, então devemos usar o modelo de Regressão Polinomial em vez de Regressão Linear Simples.

  Nota: Um algoritmo de Regressão Polinomial também é chamado de Regressão Linear Polinomial porque não depende das variáveis, em vez disso, depende dos coeficientes, que são organizados de forma linear.

Implementação de Regressão Polinomial utilizando Python:

Aqui vamos implementar a Regressão Polinomial usando Python. Vamos entendê-lo comparando o modelo de Regressão Polinomial com o modelo de Regressão Linear Simples. Então, primeiro, vamos entender o problema para o qual vamos construir o modelo.

Descrição do problema: Existe uma empresa de Recursos Humanos, que vai contratar um novo candidato. O candidato disse o seu salário anterior 160 mil por ano, e o RH tem que verificar se ele está dizendo a verdade ou não. Então, para verificar isso, eles têm apenas um conjunto de dados de sua empresa anterior em que os salários dos 10 primeiros cargos são mencionados com seus níveis. Ao verificar o conjunto de dados disponíveis, verificamos que existe uma relação não linear entre os níveis de Cargos e os salários. O nosso objetivo é construir um  modelo de regressão do detetor Bluffing, para que o RH possa contratar um candidato honesto. Abaixo estão os passos para construir tal modelo.

Etapas para Regressão Polinomial:

As principais etapas envolvidas na Regressão Polinomial são dadas abaixo:

• Pré-processamento de dados
• Crie um modelo de Regressão Linear e ajuste-o ao conjunto de dados
• Crie um modelo de Regressão Polinomial e ajuste-o ao conjunto de dados
• Visualize o resultado para o modelo de Regressão Linear e Regressão Polinomial.
• Prevendo a saída.

Etapa de pré-processamento de dados:

A etapa de pré-processamento de dados permanecerá a mesma dos modelos de regressão anteriores, exceto por algumas alterações. No modelo de Regressão Polinomial, não usaremos dimensionamento de recursos e também não dividiremos nosso conjunto de dados em conjunto de treinamento e teste. Tem duas razões:

• O conjunto de dados contém muito menos informações que não são adequadas para dividi-lo em um conjunto de teste e treinamento, caso contrário, nosso modelo não será capaz de encontrar as correlações entre os salários e níveis.
• Neste modelo, queremos previsões muito precisas para o salário, por isso o modelo deve ter informações suficientes.

O código para a etapa de pré-processamento é dado abaixo:

# importing libraries  
import numpy as nm  
import matplotlib.pyplot as mtp  
import pandas as pd  
  
#importing datasets  
data_set= pd.read_csv('Position_Salaries.csv')  
  
#Extracting Independent and dependent Variable  
x= data_set.iloc[:, 1:2].values  
y= data_set.iloc[:, 2].values  

Construindo o modelo de regressão linear:

Agora, vamos construir e ajustar o modelo de regressão linear ao conjunto de dados. Na construção da regressão polinomial, tomaremos como referência o modelo de regressão linear e compararemos ambos os resultados. O código é dado abaixo:

#Fitting the Linear Regression to the dataset  
from sklearn.linear_model import LinearRegression  
lin_regs= LinearRegression()  
lin_regs.fit(x,y)  

Out[5]: LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)

#Fitting the Polynomial regression to the dataset  
from sklearn.preprocessing import PolynomialFeatures  
poly_regs= PolynomialFeatures(degree= 2)  
x_poly= poly_regs.fit_transform(x)  
lin_reg_2 =LinearRegression()  
lin_reg_2.fit(x_poly, y)  

Out[11]: LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)

#Visulaizing the result for Linear Regression model  
mtp.scatter(x,y,color="blue")  
mtp.plot(x,lin_regs.predict(x), color="red")  
mtp.title("Bluff detection model(Linear Regression)")  
mtp.xlabel("Position Levels")  
mtp.ylabel("Salary")  
mtp.show()  

#Visulaizing the result for Polynomial Regression  
mtp.scatter(x,y,color="blue")  
mtp.plot(x, lin_reg_2.predict(poly_regs.fit_transform(x)), color="red")  
mtp.title("Bluff detection model(Polynomial Regression)")  
mtp.xlabel("Position Levels")  
mtp.ylabel("Salary")  
mtp.show()  

lin_pred = lin_regs.predict([[6.5]])  
print(lin_pred)

[330378.78787879]

poly_pred = lin_reg_2.predict(poly_regs.fit_transform([[6.5]]))  
print(poly_pred)  

[158862.45265153]