Regresión Polinomial – Práctica con Python

En esta entrada veremos la parte práctica del algoritmo de Regresión Polinomial, en donde desarrollaremos un modelo para predecir el precio de las casas en Boston de acuerdo al número de habitaciones que cuenta la vivienda.

Para este análisis vamos a utilizar el dataset disponible en la librería scikit-learn correspondiente al Boston Housing o las casas de Boston. Este es el mismo dataset que utilizamos para la práctica de los anteriores algoritmos que hemos desarrollados anteriormente por lo que no explicare cómo obtener los datos, su análisis ni su preprocesamiento, todo esto está explicado en las primeras entradas de práctica, que te recomiendo que revises en caso si no lo haz hecho aún.

Acá vamos arrancar a preparar los datos para implementar el algoritmo de Regresión Polinomial.

Como dijimos al principio vamos a hacer el análisis con los datos correspondientes al número de habitaciones que cuenta la vivienda, estos datos se encuentran ubicados en la columna número 6 de nuestro dataset, por lo que debemos definir esta columna a la variable “X”, en este caso vamos a utilizar “X_p” para representar el algoritmo que estamos utilizando, Regresión Polinomial o Polynomial Regression.

#Seleccionamos solamente la columna 6 del dataset
X_p = boston.data[:, np.newaxis, 5]

Seguidamente definimos los datos de “y” o “y_p”, para este ejemplo, los cuales serán igual a la columna de target de nuestro dataset.

#Defino los datos correspondientes a las etiquetas
y_p = boston.target

Definidas ambas variables podemos graficarlas utilizando la instrucción scatter. Como podemos observar los datos no se encuentran distribuidos de manera lineal sobre en la parte inferior izquierda por lo que perfectamente podemos utilizar el algoritmo de Regresión Polinomial.

#Graficamos los datos correspondientes
plt.scatter(X_p, y_p)
plt.show()

Regresión-lineal-practica

Ahora separamos los datos de entrenamiento y prueba, para ello importamos train_test_split de la librería scikit learn y lo implementamos a nuestros datos “X_p” y “y_p”.

from sklearn.model_selection import train_test_split

#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train_p, X_test_p, y_train_p, y_test_p = train_test_split(X_p, y_p, test_size=0.2)

En este punto tenemos los datos “X” y “y” de entrenamiento y prueba. Pero antes de definir el algoritmo y empezarlo a entrenar debemos definir el grado del polinomio, para ello se importa de la librería scikit learn las características polinomiales o PolynomialFeatures, y procedemos a definir el grado.

from sklearn.preprocessing import PolynomialFeatures

En este caso lo definimos igual a 2. Recuerda que en este punto tu puedes definir este número, lo ideal es comenzar con un valor bajo como el 2 y después ir subiendo poco a poco para ver si se mejora lo resultados de la predicción, pero debes tener mucho cuidado porque en ocasiones puedes ajustar de más el modelo ocasionando un sobreajuste u overfitting.

#Se define el grado del polinomio
poli_reg = PolynomialFeatures(degree = 2)

Definido el grado se procede a transformar las características de existentes, en este caso tanto X_train como X_test en características de mayor grado, para ello utilizamos el polinomio definido anteriormente y lo entrenamos a estos datos.

#Se transforma las características existentes en características de mayor grado
X_train_poli = poli_reg.fit_transform(X_train_p)
X_test_poli = poli_reg.fit_transform(X_test_p)

En este punto lo que estamos haciendo es calculando los valores de “X” para cada uno de los elementos dentro de la formula, te acuerdas que en la teoría vimos que “X” estaba elevado a la n potencia dependiendo del valor del coeficiente del polinomio, bueno es acá donde se calcula el valor de “X”.

Como seleccionamos un polinomio de grado 2, entonces tenemos la formula sería esta:

Regresión-Polinomial-teoría-1

Entonces acá estamos calculando los datos de  y , para tenerlos listo para calcular el modelo. Esto lo hacemos tanto para X_train como para X_test.

Realizado esto llego el momento de definir el algoritmo en nuestro modelo, que en este caso sería LinearRegression, con esta misma instrucción se puede calcular el modelo de Regresión Polinomial.

#Defino el algoritmo a utilizar
pr = linear_model.LinearRegression()

Definido el algoritmo lo utilizamos para entrenar los datos, recuerda que acá utilizamos los datos que transformamos con las características de mayor grado.

#Entreno el modelo
pr.fit(X_train_poli, y_train_p)

Realizado todo esto comparemos los valores obtenidos en nuestra predicción con los valores reales, para ver que tal es el comportamiento de nuestro modelo.

#Realizo una predicción
Y_pred_pr = pr.predict(X_test_poli)

Regresión-lineal-practica-1

Como podemos observar en este recuadro tenemos los datos reales mientras que en este otro están los datos obtenidos de nuestra predicción implementando el modelo. Si observamos con detenimiento estos datos nos podemos dar cuenta que en ciertos momentos los datos reales son muy parecidos con los datos que se han calculados mientras que otros casos los datos son totalmente distintos.

Con esta pequeña comparación podemos determinar que nuestro modelo no es del todo eficiente, pero veámoslo gráficamente para detallarlo con más cuidado, para ello utilizamos la librería de matplotlib.

#Graficamos los datos junto con el modelo
plt.scatter(X_test_p, y_test_p)
plt.plot(X_test_p, Y_pred_pr, color='red', linewidth=3)
plt.show()

Regresión-lineal-practica-2

Como podemos observar en la gráfica, la línea roja sería nuestro modelo y los puntos azules son los datos de pruebas con los que lo entrenamos.

Igual que todos los algoritmos de regresión que hemos desarrollado hasta ahora el objetivo de este es que el modelo o la línea abarque el mayor número de muestras y de esta forma disminuir el error que vendría siendo la distancia desde la línea hasta el punto, entonces todos los datos fuera de la línea serían errores.

Recordando este concepto podemos observar que el modelo cubre una buena parte de los datos y tiene un comportamiento correcto muy parecido al de los datos. Por lo tanto, calculemos los datos relacionados a este algoritmo incluyendo la precisión del mismo.

print('Valor de la pendiente o coeficiente "a":')
print(pr.coef_)

Regresión-lineal-practica-3

Comencemos calculando los coeficientes de la formula de Regresión Polinomeal, calculamos primeramente los coeficientes danto como resultado: -19,257 para a1, 2,221 para a2. Ignora el primer valor que es 0, siempre vas a obtener este valor igual a cero para este algoritmo.

print('Valor de la intersección o coeficiente "b":')
print(pr.intercept_)

Regresión-lineal-practica-4

Seguidamente calculamos el valor de la intersección o coeficiente “b”, este dato será igual a: 54,743.

print('Precisión del modelo:')
print(pr.score(X_train_poli, y_train_p))

Regresión-lineal-practica-5

Ahora calculemos la precisión del algoritmo para ello empleamos la instrucción “score” el cual devuelve el resultado de la estadística R al cuadrado. El resultado obtenido acá es de 0,563, como ya lo habíamos visto comparando los resultados de “y_predict” y viendo la gráfica podíamos deducir que la precisión no iba a ser muy buena.

Recuerda que esto no significa que el algoritmo sea malo sino que no es el mejor para este conjunto de datos.

"""
Regresión Polinomial

@author: ligdigonzalez
"""

########## LIBRERÍAS A UTILIZAR ##########

#Se importan la librerias a utilizar
import numpy as np
from sklearn import datasets, linear_model
import matplotlib.pyplot as plt

########## PREPARAR LA DATA ##########

#Importamos los datos de la misma librería de scikit-learn
boston = datasets.load_boston()
print(boston)
print()

########## ENTENDIMIENTO DE LA DATA ##########

#Verifico la información contenida en el dataset
print('Información en el dataset:')
print(boston.keys())
print()

#Verifico las características del dataset
print('Características del dataset:')
print(boston.DESCR)

#Verifico la cantidad de datos que hay en los dataset
print('Cantidad de datos:')
print(boston.data.shape)
print()

#Verifico la información de las columnas
print('Nombres columnas:')
print(boston.feature_names)

########## PREPARAR LA DATA REGRESIÓN POLINOMIAL ##########

#Seleccionamos solamente la columna 6 del dataset
X_p = boston.data[:, np.newaxis, 5]

#Defino los datos correspondientes a las etiquetas
y_p = boston.target

#Graficamos los datos correspondientes
plt.scatter(X_p, y_p)
plt.show()

########## IMPLEMENTACIÓN DE REGRESIÓN POLINOMIAL ##########

from sklearn.model_selection import train_test_split

#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train_p, X_test_p, y_train_p, y_test_p = train_test_split(X_p, y_p, test_size=0.2)

from sklearn.preprocessing import PolynomialFeatures

#Se define el grado del polinomio
poli_reg = PolynomialFeatures(degree = 2)

#Se transforma las características existentes en características de mayor grado
X_train_poli = poli_reg.fit_transform(X_train_p)
X_test_poli = poli_reg.fit_transform(X_test_p)

#Defino el algoritmo a utilizar
pr = linear_model.LinearRegression()

#Entreno el modelo
pr.fit(X_train_poli, y_train_p)

#Realizo una predicción
Y_pred_pr = pr.predict(X_test_poli)

#Graficamos los datos junto con el modelo
plt.scatter(X_test_p, y_test_p)
plt.plot(X_test_p, Y_pred_pr, color='red', linewidth=3)
plt.show()

print()
print('DATOS DEL MODELO REGRESIÓN POLINOMIAL')
print()

print('Valor de la pendiente o coeficiente "a":')
print(pr.coef_)

print('Valor de la intersección o coeficiente "b":')
print(pr.intercept_)

print('Precisión del modelo:')
print(pr.score(X_train_poli, y_train_p))

4 thoughts on “Regresión Polinomial – Práctica con Python”

  1. Hola Jesús, gracias por la sugerencia. Pero tu puedes hacerlo por tu cuenta también con este proyecto, cuando definas X en vez de solo seleccionar una sola columna puedes seleccionar varias y de esta forma ya tendrás varias variables independientes. Saludos.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *