Regresión Lineal Simple – Práctica con Python

En la entrada de hoy veremos la parte práctica del algoritmo de Regresión Lineal Simple, 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 no nos vamos a complicar mucho y utilizaremos uno de los dataset disponible en la librería sckit-learn y es el correspondiente al de Boston Housing o las casas de Boston.

Si no lo sabías dentro de la librería sckit-learn se dispone de varios dataset, 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.

Como todos los programas que hemos desarrollados hasta ahora lo primero que debemos hacer es importar las librerías que vamos a utilizar.

En este caso vamos a importar numpy, y de sklearn importamos 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 ya que vamos a hacer el programa basándonos únicamente en Regresión Lineal.

A su vez importamos matplotlib ya que graficaremos los resultados obtenidos.

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

Seguidamente importamos los datos, para ello utilizamos la instrucción datasets punto load_boston().

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

Como 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.

Para ello lo primero que vamos hacer es verificar la información contenida en el dataset, 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())

Regresión-Lineal-simple-practica-1

Como podemos observar el dataset 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)

En la descripción de 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 nos indican que no existe ningún valor perdido, en consecuencia, nuestra data esta completa 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)

Regresión-Lineal-simple-practica-2

Como ya nos lo habían indicado 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)

Regresión-Lineal-simple-practica-3

Como podemos observar tenemos muchos datos, pero para nuestro análisis solamente vamos a tomar la columna correspondiente al número de habitaciones con las que cuenta la casa, esta sería la que lleva por nombre “RM”.

Sabiendo toda esta información entonces procedemos a preparar los datos que vamos a utilizar para crear el modelo.

Para este ejemplo vamos a implementar un predictor de Regresión Lineal Simple, si te acuerdas un poco de la teoría explicada en videos anteriores, para este algoritmo solamente se requiere una variable independiente, para nuestro caso será la correspondiente al número de habitaciones, pero también puedes tomar la columna correspondiente a los años de construcción de la vivienda o cualquier otra que consideres prudente, lo importante acá es que debes seleccionar solamente una de ellas.

Para nuestro caso las variables se encuentran ubicadas en la columna número 5, recuerda que el conteo de columnas y filas siempre comienza desde 0, esta columna sería los datos correspondientes a “X” en nuestro análisis.

Es importante detallar acá que los datos se encuentran almacenados como numpy por lo que tenemos que tratarlos como tal.

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

Definido “X” ahora definimos “y” el cual será igual a los datos contenidos en target, como ya lo habíamos visto anteriormente.

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

Grafiquemos los datos utilizando una gráfica de dispersión para ver exactamente la distribución de los datos.

#Graficamos los datos correspondientes
plt.scatter(X, y)
plt.xlabel('Número de habitaciones')
plt.ylabel('Valor medio')
plt.show()

Regresión-Lineal-simple-practica-4

A simple vista ya puedo deducir que el modelo de Regresión Lineal que vamos a construir tendrá un error muy alto, pero esto lo explicaré más adelante, pero continuemos con nuestro análisis.

Como lo primero que debemos hacer es separar los datos en entrenamiento y prueba lo hacemos utilizando la instrucción train_test_split, no si antes importando la respectiva librería.

Para la separación de los datos, vamos a tomar un 20% de los mismos para utilizarlos como prueba una vez que hayamos obtenido el modelo.

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, y, test_size=0.2)

Seguidamente definimos el algoritmo a utilizar que es el de LinearRegression.

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

Entrenamos nuestro modelo con los datos de entrenamiento y utilizando la instrucción fit.

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

Y finalmente realizamos la predicción utilizando los datos de prueba.

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

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.

Regresión-Lineal-simple-practica-5

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 veamos 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, y_test)
plt.plot(X_test, Y_pred, color='red', linewidth=3)
plt.title('Regresión Lineal Simple')
plt.xlabel('Número de habitaciones')
plt.ylabel('Valor medio')
plt.show()

Regresión-Lineal-simple-practica-6

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.

Si nos recordamos un poco el objetivo de este algoritmo 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, es por esta razón que cuando realizamos la comparación de los datos anteriormente nos encontramos que varios tenían una diferencia considerable, bueno la razón de esto es que el modelo no abarcó todos los puntos.

De igual forma, te acuerdas que cuando graficamos los datos primeramente te comenté que no íbamos a obtener buenos resultados con este algoritmo, y la razón es muy simple los datos se encuentran muy dispersos por lo que es difícil que la línea cubriera la mayoría de los datos por lo que íbamos a obtener una mala precisión, esto no quiere decir que este algoritmo sea malo sino más bien que este algoritmo no es bueno para este conjunto de datos.

Calculemos ahora los valores de la pendiente e intersección para ver como queda la ecuación del modelo.

print('DATOS DEL MODELO REGRESIÓN LINEAL SIMPLE')
print()
print('Valor de la pendiente o coeficiente "a":')
print(lr.coef_)
print('Valor de la intersección o coeficiente "b":')
print(lr.intercept_)
print()
print('La ecuación del modelo es igual a:')
print('y = ', lr.coef_, 'x ', lr.intercept_)

Recuerda que la Regresión Lineal Simple viene representada como y es igual a “a” por “x” + “b”, por lo tanto, para el modelo construido “a” es igual a 8,66 y “b” es igual a -31,99 y la ecuación queda como se muestra.

Regresión-Lineal-simple-practica-7

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.

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

Regresión-Lineal-simple-practica-8

El resultado obtenido acá es de 0,458, como ya lo habíamos visto comparando las 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.

Por todo esto es que es bueno saber exactamente de que se trata cada uno de los algoritmos de Machine Learning, para que de una vez que veamos la data podamos deducir qué algoritmo es el más adecuado implementar y de esta forma no perder tiempo en el desarrollo de algoritmos que no vayan a funcionar.

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

"""
Regresión Lineal Simple

@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 LINEAL SIMPLE ##########

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

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

#Graficamos los datos correspondientes
plt.scatter(X, y)
plt.xlabel('Número de habitaciones')
plt.ylabel('Valor medio')
plt.show()

########## IMPLEMENTACIÓN DE REGRESIÓN LINEAL SIMPLE ##########

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, y, test_size=0.2)

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

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

#Realizo una predicción
Y_pred = lr.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.title('Regresión Lineal Simple')
plt.xlabel('Número de habitaciones')
plt.ylabel('Valor medio')
plt.show()

print()
print('DATOS DEL MODELO REGRESIÓN LINEAL SIMPLE')
print()
print('Valor de la pendiente o coeficiente "a":')
print(lr.coef_)
print('Valor de la intersección o coeficiente "b":')
print(lr.intercept_)
print()
print('La ecuación del modelo es igual a:')
print('y = ', lr.coef_, 'x ', lr.intercept_)

print()
print('Precisión del modelo:')
print(lr.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 *