Vectores de Soporte Regresión – Práctica con Python

En esta entrada explicaremos la parte práctica del algoritmo de Vectores de Soporte Regresión, 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.

Te recomiendo que, si no has revisado las entradas anteriores referente a la teoría de Vectores de Soporte Regresión y cómo implementar este algoritmo utilizando la librería Scikit Learn, lo hagas primero antes de continuar ya que esta explicación son las bases para entender lo que se explicará acá.

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, por lo que te recomiendo que lo revises previamente.

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

Lo primero que debemos hacer es separar los datos en “x” y “y”, a estas variables las vamos a llamar X_svr y y_svr, la primera será igual a la columna 6 del dataset que previamente procesamos, por su parte y_svr será igual a la columna de target.

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

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

Grafiquemos estos datos para observar con más detalle los datos que esteremos manejando.

#Graficamos los datos correspondientes
plt.scatter(X_svr, y_svr)
plt.show()

maquina-de-vectores-de-soporte-regresión-práctica-con-python

Como podemos observar estos datos tienen un comportamiento lineal, por lo que acá implementaremos el algoritmo de Vectores de Soporte Regresión, con un kernel línea, de la misma forma que lo explicamos en la teoría.

Procedemos ahora a separar los datos en entrenamiento y prueba, para ello utilizamos la instrucción train_test_split.

from sklearn.model_selection import train_test_split

#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train, X_test, y_train, y_test = train_test_split(X_svr, y_svr, test_size=0.2)

Realizado esto procedemos a definir el algoritmo. Por lo que lo primero que hacemos es importar SVR desde el modulo sklearn punto svm.

from sklearn.svm import SVR

Una vez realizado esto podemos proceder a definir el algoritmo que lo vamos a llamar svr. Acá vamos a detenernos un momento para explicar la configuración que le estamos dando.

#Defino el algoritmo a utilizar
svr = SVR(kernel='linear', C=1.0, epsilon=0.2)

Lo primero que definimos es el kernel, como ya le he dicho en varios videos anteriores este tema tendrá un video dedicado completamente a este, pero por lo momentos nos limitamos a utilizar un kernel lineal.

Se acuerdan que en el video de Scikit Learn referente a este algoritmo les explique que podían configurar, el kernel, de distintas formas y una de ellas es que fuera lineal en caso de que utilizáramos datos lineales. Bueno, acá vamos a definir el kernel igual a linear, de esta forma le decimos que los datos que estamos utilizando son lineales, sino definimos esto este valor será igual a rbf que es un kernel para datos no lineales.

En caso de que estés utilizando otros datos y estos no sean lineales, no te recomiendo definir el kernel lineal ya que no se puede aplicar para ese conjunto de datos.

Otra valor que definimos en la configuración del algoritmo es el de C que será igual a 1, C es una constante dentro de la formula de Vectores de Soporte Regresión, que determina el equilibrio entre la regularidad de la función y la cuantía hasta la cual toleramos desviaciones mayores que las bandas de soporte. Si colocamos un valor de C muy bajo nuestro modelo aceptará más errores por lo que colocar un valor igual a 1 es adecuado para construir este modelo.

Otra variable que configuramos es la de epsilon que será igual a 0,2, para recordarles epsilon, son las variables que controlan el error cometido por la función de regresión al aproximar a la bandas.

Recuerda que la explicación de todo esto esta en las entradas anteriores, por lo que te recomiendo que lo revises para entender mejor lo explicado acá.

Definido todas estas variables, ahora si podemos entrenar el algoritmo utilizando la instrucción fit y los datos de entrenamiento.

#Entreno el modelo
svr.fit(X_train, y_train)

Seguidamente realizamos una predicción utilizando los datos de prueba.

#Realizo una predicción
Y_pred = svr.predict(X_test)

Visualicemos los datos de entrenamiento junto con el modelo, para ello utilizamos las intrucciones que se encuentran dentro de la librería matplotlib.

#Graficamos los datos junto con el modelo
plt.scatter(X_test, y_test)
plt.plot(X_test, Y_pred, color='red', linewidth=3)
plt.show()

maquina-de-vectores-de-soporte-regresión-práctica-con-python-1

Como definimos, al momento de configurar el algoritmo, el kernel que estamos utilizando es lineal por lo que el modelo es una línea, la cual va a tratar de cubrir la mayor cantidad de datos. Pero si observamos acá la línea acá tiene un comportamiento similar a los datos de entrenamiento.

maquina-de-vectores-de-soporte-regresión-práctica-con-python-2

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.

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 en otros casos los datos son totalmente distintos.

Veamos ahora la precisión del modelo utilizando la instrucción score, el cual devuelve el resultado de la estadística R al cuadrado. El resultado obtenido acá es de 0,458, este valor es muy parecido a lo que hemos obtenido con los otros algoritmos que hemos evaluado anteriormente.

print('DATOS DEL MODELO VECTORES DE SOPORTE REGRESIÓN')
print()

print('Precisión del modelo:')
print(svr.score(X_train, y_train))

maquina-de-vectores-de-soporte-regresión-práctica-con-python-3

A continuación se encuentra el código completo:

"""
Vectores de Soporte Regresión

@author: ligdigonzalez
"""

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

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


########## 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 VECTORES DE SOPORTE REGRESIÓN ##########

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

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

#Graficamos los datos correspondientes
plt.scatter(X_svr, y_svr)
plt.show()

########## IMPLEMENTACIÓN DE VECTORES DE SOPORTE REGRESIÓN ##########

from sklearn.model_selection import train_test_split

#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train, X_test, y_train, y_test = train_test_split(X_svr, y_svr, test_size=0.2)

from sklearn.svm import SVR

#Defino el algoritmo a utilizar
svr = SVR(kernel='linear', C=1.0, epsilon=0.2)

#Entreno el modelo
svr.fit(X_train, y_train)

#Realizo una predicción
Y_pred = svr.predict(X_test)

#Graficamos los datos junto con el modelo
plt.scatter(X_test, y_test)
plt.plot(X_test, Y_pred, color='red', linewidth=3)
plt.show()

print()
print('DATOS DEL MODELO VECTORES DE SOPORTE REGRESIÓN')
print()

print('Precisión del modelo:')
print(svr.score(X_train, y_train))

 

Deja un comentario

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