Vectores de Soporte Regresión – Práctica con Python
A continuación aprenderás cómo implementar el algoritmo de Vectores de Soporte Regresión utilizando la librería de Python Scikit Learn, tomando en cuenta cada uno de los parámetros que debes considerar para ajustar y mejorar tus resultados.
Posteriormente desarrollaremos un proyecto de Machine Learning enfocándonos en el algoritmo de Vectores de Soporte Regresión. Cada una de las explicaciones dadas acá será paso a paso para que puedas entender con detalle cada uno de los métodos explicados acá y que los puedas implementar en tus propios proyectos.
Empecemos con la explicación del proyecto.
Vectores de Soporte Regresión con Scikit Learn
Si aún no lo sabes, Scikit Learn es una de las más grandes librerías de Machine Learning con la que cuenta Python, pero no solamente eso, es de las más utilizadas al momento de crear los modelos implementando los algoritmos de Machine Learning, por estas razones es muy importante que aprendas a trabajar con ella si apenas te estás iniciando.
Veamos cómo se puede utilizar esta librería para implementar el algoritmo de Vectores de Soporte Regresión.
El objetivo de los Vectores de Soporte Regresión es la de individualizar el hiperplano maximizando el margen, teniendo en cuenta que se tolera parte del error.
Lo primero que debes saber es que Scikit Learn cuenta con un módulo llamado sklearn.svm en donde se incluye todo lo referente al algoritmo de Vectores de Soporte tanto clasificación como regresión. Para esta publicación nos enfocaremos solamente en regresión y más específicamente en SVR.
Con Scikit Learn es extremadamente sencillo implementar este algoritmo, lo primero que debemos hacer es importar el módulo e importar la clase SVR, crear los parámetros a utilizar, “x” y “y” y llamar al método fit() junto con los datos de entrenamiento.
Toda la información para implementar esta librería la pueden encontrar directamente en la página web, por lo que si tenemos alguna duda en la implementación de las instrucciones solamente tenemos que leer esta información.
Implementación de Vectores de Soporte Regresión con Scikit Learn
La instrucción SVR se puede configurar con ciertos parámetros que puedes ver en la página web con más detalle, acá te voy a explicar los más importantes y los que debes considerar al momento de configurar el modelo.
Comencemos con C, te acuerdas que cuando vimos la teoría del algoritmo de vectores de soporte regresión, en la fórmula se disponía de una variable llamada C, la cual la definimos como una constante 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, bueno este valor lo puedes definir acá, por defecto este valor es de 1 pero tu lo puedes definir a tu conveniencia.
Otro parámetro que puedes modificar es el de “épsilon”,
Ambas variables las puedes modificar a tu conveniencia, pero tradicionalmente esto valores se dejan por defecto, sobretodo si apenas estas empezando en Machine Learning y no tienes la suficiente destreza para manipularlos.
Una configuración que cuenta este algoritmo en Scikit Learn y que en ocasiones si se modifica es la de Kernel, pero hasta los momentos no he explicado mucho al respecto, por lo que acá solamente la voy a nombrar y más adelante habrá un video dedicado completamente a explicar de qué se trata los Kernel y porque son bastante útiles sobretodo para este tipo de algoritmos.
Por los momentos me voy a limitar a decir que acá se puede definir uno de los tres tipos de Kernel que se manejan, lineal, que se utiliza cuando los datos son lineales, y para los datos no lineales se cuenta con “poly”, “rbf” y “sigmoid”. Si este parámetro no se configura al momento de utilizar este algoritmo, se utilizará “rbf” como Kernel por defecto.
Recuerda que estos son solo algunos de los parámetros que cuenta este algoritmo para su configuración.
Precisión de Regresión Lineal con Scikit Learn
Teniendo toda esta información ya tenemos nuestro modelo de Vectores de Soporte Regresión listo, ahora el último paso es el de evaluar el rendimiento del algoritmo, este paso es particularmente importante para comparar qué tan bien funcionan diferentes algoritmos en un conjunto de datos particular. Como lo explicamos en una anterior publicación para conocer la precisión debemos implementar la estadística R al cuadrado, pero, obviamente, la librería Scikit Learn cuenta con una instrucción que hace nuestro trabajo mucho más sencillo. Para este caso solamente tenemos que utilizar la instrucción “score” junto con los datos de pruebas y nos devolverá la precisión del modelo con los datos utilizados.
Recuerda que todos estos datos los podemos obtener después de haber entrenado el modelo de lo contrario nuestro programa nos arrojará un error.
Resumen de comandos Scikit Learn
En resumen, los comandos a utilizar para implementar un algoritmo de Regresión Lineal serían los siguientes:
Sabiendo cómo implementar el algoritmo de Vectores de Soporte Regresión con la librería de Scikit Learn, ha llegado el momento de desarrollar un proyecto práctico.
Definición del proyecto
En esta práctica del algoritmo de Vectores de Soporte Regresión, se desarrollará 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. Si no lo sabías dentro de la librería sckit-learn se dispone de varios conjuntos de datos, muy básicos, con los que puedes practicar tus conocimientos de Machine Learning, no son muchos, pero cubre los principales tipos de algoritmos como regresión y clasificación.
El algoritmo específico que se utilizará será Vectores de Soporte Regresión.
Obtener los de datos
El primer paso que daremos será el de importar las librerías que vamos utilizar, en especial las necesarias para importar los datos que utilizaremos.
En este caso vamos a importar de sklearn el datasets, que es donde se guardan todos los conjuntos de datos que dispone esta librería y a su vez importamos de una vez linear_model.
#Se importan la librerias a utilizar
from sklearn import datasets, linear_model
Seguidamente importamos los datos, para ello utilizamos la instrucción datasets.load_boston().
#Importamos los datos de la misma librería de scikit-learn
boston = datasets.load_boston()
Tenemos mucha información dentro de esta variable lo que se nos hace difícil entender la información, por lo tanto, ahora procedemos a entender la data.
Entender los datos
Para entender los datos que estaremos utilizando el proyecto nos vamos a valor de varias instrucciones propias de Python y así verificar la información contenida en el conjunto de datos que acabamos de importar. Para este fin utilizamos la instrucción keys.
#Verifico la información contenida en el dataset
print('Información en el dataset:')
print(boston.keys())
Como puedes observar el conjunto de datos cuenta con la siguiente información: primeramente, la data, seguidamente target que sería la columna con las etiquetas o respuestas, posteriormente tenemos feature_names que serían los nombres de cada una de las columnas de la data y finalmente tenemos DESCR que sería la descripción total del dataset.
Sabiendo ya esto podemos ahora utilizar estos nombres para entender mejor los datos, lo primero que vamos a hacer es utilizar DESCR para ver las características del dataset.
#Verifico las características del dataset
print('Características del dataset:')
print(boston.DESCR)
Como puedes leer en la descripción este dataset cuenta con 506 datos y 13 atributos, la columna 14 es el target y es la media del valor de las viviendas.
Seguidamente tenemos la descripción del significado de cada una de las columnas o atributos de los datos. De igual forma, nos indica un dato importante para nuestro análisis y es que indica que no existe ningún valor perdido, en consecuencia, nuestros datos están completos por lo que no es necesario realizar mucho preprocesamiento a los datos.
Ahora utilizaremos la instrucción shape para determinar la cantidad de datos contamos, aunque este es un paso de más ya que esta información nos la había dado previamente la descripción del dataset, pero de todas formas lo hacemos.
#Verifico la cantidad de datos que hay en los dataset
print('Cantidad de datos:')
print(boston.data.shape)
Como ya nos lo visto anteriormente este conjunto de datos cuenta con 506 muestras y 13 columnas.
Finalmente veamos las etiquetas de cada columna para ello utilizamos feature_names.
#Verifico la información de las columnas
print('Nombres columnas:')
print(boston.feature_names)
Sabiendo toda esta información entonces procedemos a preparar los datos que vamos a utilizar para crear el modelo.
Procesamiento de los datos
#Seleccionamos solamente la columna 6 del dataset
X_svr = boston.data[:, np.newaxis, 5]
#Definimos los datos correspondientes a las etiquetas
y_svr = boston.target
#Graficamos los datos correspondientes
plt.scatter(X_svr, y_svr)
plt.show()
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)
Con esto ya tenemos nuestros datos divididos en datos de entrenamiento y prueba.
Desarrollo del algoritmo
Con los datos separados en entrenamiento y prueba ha llegado el momento de construir el modelo de Machine Learning, por lo que lo primero que hacemos es importar SVR desde el módulo 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.
#Definimos el algoritmo a utilizar
svr = SVR(kernel='linear', C=1.0, epsilon=0.2)
Lo primero que definimos es el kernel, para este caso definimos uno básico como lo es el kernel lineal.
Como te lo explique anteriormente, en este algoritmo, se puede configurar el kernel de distintas formas una de ellas es lineal en caso de que utilizáramos datos lineales. Pero también se puede configurar como 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 fórmula 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.
Definido todas estas variables, ahora si podemos entrenar el algoritmo utilizando la instrucción fit y los datos de entrenamiento.
#Entrenamos el modelo
svr.fit(X_train, y_train)
#Realizamos una predicción
Y_pred = svr.predict(X_test)
Visualicemos los datos de entrenamiento junto con el modelo, para ello utilizamos las instrucciones 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()
Cómo 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.
Análisis de los resultados
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))
Como ya lo habíamos visto comparando los resultados de “y_predict” podríamos deducir que la precisión no iba a ser muy buena. Recuerda que mientras este valor sea más cercano a 1 mejor será nuestro modelo.
Programa completo
A continuación se encuentra el código completo:
"""
Vectores de Soporte Regresión
"""
########## 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)
Si te llamo la atención todo este contenido y te animaste a empezar a estudiar Inteligencia Artificial, he desarrollado un curso que te ayudará, de igual forma a iniciar tu camino dentro de está tecnología. Este curso te sentará las bases y te dará más claridad para poder seleccionar el enfoque o área que más te interese sobre la Inteligencia Artificial, de igual forma te ayudará tener más claridad en muchos conceptos que seguramente en estos momentos te parece confusos. Este curso es ideal si apenas estás empezando. Si quieres más información puedes ingresar a este enlace.
Hola, tengo una pregunta en cuanto al visualizar esta regresión, y es si hay alguna forma de poder visualizar las líneas de vectores de soporte. No he encontrado nada al respecto, solo con SVC, pero no puedo hacerlo en SVR. Gracias de antemano.
Hola Javier, si lo puedes hacer pero tienes que realizarlo utilizando programación tradicional de Python. Saludos.
Hola! Muy buenos tus videos.
Yo uso Databricks, y me gustaria saber si existe alguna forma de comparar los valores obtenidos en nuestra predicción con los valores reales, para ver que tal es el comportamiento del modelo creado. Por lo que he visto, tú lo haces en Spyder. Pero me gustaria saber si puedo visualizar al menos algunos datos del y_test y compararlos con su valor correspondiente en y_predict.
Gracias por todo, excelente contenido, de gran ayuda.
Saludos,
Valentín Lorbeer.
Hola Valentin, como te lo comento en tu comentario de YT, no utilizo Databricks, pero yo diría que si es posible hacer lo que estás explicando acá. Saludos.