En este proyecto implementaremos el algoritmo de DBSCAN en Python, analizaremos un conjunto de datos que contiene información sobre los montos de gasto anual de varios clientes de diversas categorías de productos para la estructura interna.
Nuestro objetivo es agrupar los datos para que podamos ver los productos que son comprados juntos por los clientes. Por ejemplo, si una persona va a la tienda a comprar algún comestible, es muy probable que también compre “leche”, por lo tanto podemos colocar la “leche” cerca de los comestibles de la tienda; de la misma manera es muy poco probable que la misma persona compre las verduras frescas al mismo tiempo.
Si podemos predecir este comportamiento del cliente, podemos organizar la tienda, en consecuencia aumentará las ventas de artículos.
El conjunto de datos de este proyecto se puede encontrar en Kaggle bajo el nombre de “Wholesale Customers data set”, el link es el siguiente: https://bit.ly/2KECiHq.
Como todo proyecto de Machine Learning, lo primero que vamos a hacer será importar las librerías que vamos a utilizar. Por los momentos solo importaremos las de Pandas, para manipular los datos y la de Matplotlib, para analizar visualmente los datos. Posteriormente importaremos las librerías correspondientes al algoritmo de agrupamiento, por los momentos nos enfocaremos a entender los datos.
#### IMPORTAR LAS LIBRERÍAS #### import pandas as pd import matplotlib.pyplot as plt
El siguiente paso es cargar los datos que vamos a utilizar. En este punto ya debiste haber descargado los datos de Kaggle y haberlos guardado en tu computador, como siempre recomiendo es preferible guardar estos datos en la misma carpeta en donde estamos guardando el programa, de esta forma será más fácil importarlos y trabajar con ellos.
Para importar los datos usamos la instrucción read_csv junto con el nombre del archivo en donde se encuentran los datos o, si es necesario, se debe incluir la ruta en donde se encuentran guardados.
Los datos se encuentran guardados dentro de la variable “data” por lo que el siguiente paso es analizarlos.
#### CARGAR LOS DATOS ####
data = pd.read_csv('Wholesale customers data.csv')
Antes de realizar el análisis veamos de que se trata cada una de las columnas con las que cuenta el conjunto de datos.
La primera columna corresponde a “Channel” o Canal y se refiere al canal de clientes que vendría siendo hoteles, restaurantes o cafetería o canal de venta al por menor.
La segunda columna se refiere a la de “Region” o Región de venta, que sería Lisboa, Oporto u otra.
A partir de la tercera columna podemos encontrar la información que realmente nos interesa, que serían los productos que se venden. Recuerda que en cada columna nos mostrará los datos correspondientes al gasto anual de los productos correspondientes a cada categoría.
Comenzamos con “Fresh” o Fresco que son los productos frescos, como verduras o vegetales.
La siguiente columna es “Milk” o Leche correspondiente a los productos lácteos.
Seguidamente encontramos “Grocery” o Comestibles referente a todos los productos que consumimos.
La siguiente columna es “Frozen” o Congelados correspondiente a los alimentos congelados.
La penúltima columna se refiere a “Detergents Paper” o Papel y Detergentes que vendría siendo todos los productos detergentes y productos de papel.
La última columna corresponde a “Delicassen” o Delicateses referente a todos esos productos que no son incluidos en las categorías mencionadas anteriormente.
Realizado este análisis inicial ahora procedemos a analizar los datos utilizando instrucciones de Python.
Veamos primero la forma de los datos para esto utilizamos la instrucción “shape”. El conjunto de datos con los que trabajaremos cuenta con 440 filas o datos y 8 columnas que vendrían siendo las características.
#Conocer la forma de los datos data.shape
Recuerda que estamos trabajando en un proyecto de aprendizaje no supervisado por lo que acá el conjunto de datos no contará con una columna de variables dependientes o en todo caso “y”, acá todas las columnas serán variables independientes o “x”.
Seguidamente verificamos si el conjunto de datos con el que estamos trabajando cuenta con datos nulos, para esto implementamos las instrucciones de Python, “isnull()” y “sum()”, con esto verificamos si existen datos nulos y a su vez los sumamos en cada columna. Una vez ejecutado este código podemos observar que ninguna columna cuenta con datos perdidos por lo que no tenemos que realizar ningún procesamiento de datos al respecto.
#Conocer los datos nulos data.isnull().sum()
Por último, verificamos el formato de los datos de cada una de las columnas del conjunto de datos, para esto utilizamos la instrucción “dtypes”. Una vez ejecutado esta línea de código podemos observar que todos los datos son enteros, es decir numéricos, por lo que no tenemos que realizar ningún procesamiento especial sobre los mismos.
#Conocer el formato de los datos data.dtypes
En este punto ya debemos entender los datos con los que estamos trabajando.
Antes de realizar el procesamiento de los datos separemos tres filas que vendrían a ser nuestros datos de muestras, los cuales utilizaremos posteriormente para verificar en qué clúster pertenecen. Estos datos los elegimos al alzar, perfectamente tu puedes elegir otros, e inclusive más.
Como te lo mencione antes, recuerda que este es un problema de aprendizaje no supervisado, acá no contamos con datos para comparar los resultados que obtenemos por lo que debemos buscar alguna forma de ver y analizar el resultado para ello separamos estos datos para ver si corresponde a algún clúster que encontremos finalizado nuestro análisis.
Para realizar esto primero definimos las filas que utilizaremos como muestra, en mi caso he seleccionado la número 26, 176 y 392, recuerda que deberán ser números entre 0 y 400 que es número de datos con el que contamos.
Como te lo mencione anteriormente estos son datos al azar tu puedes seleccionar otros sin ningún problema.
Definido esto y almacenado en la variable “índice”, ahora procedemos a ubicar esta información en nuestro conjunto de datos y almacenarla en la variable “muestras”. Para realizar esto utilizamos la instrucción “loc” junto con los números de las filas definidas anteriormente, incluimos el nombre de cada una de las columnas y eliminamos el resto de la información.
En este momento ya tenemos en la variable “muestras” las tres filas que utilizaremos posteriormente para conocer a que clúster corresponde.
Finalmente eliminamos estas filas de nuestro conjunto de datos original para que el modelo no se entrene con esta información, por lo tanto utilizamos la instrucción “drop()” junto la variable “índices”, fíjate que acá utilizamos “axis” igual a 0, esto es porque estamos eliminando filas y no columnas como normalmente hacemos.
### DATOS DE MUESTRA ###
#Se selecionan unos datos al azar para posteriormente verificar el clúster
#al que pertenecen
indices = [26, 176, 392]
muestras = pd.DataFrame(data.loc[indices],
columns = data.keys()).reset_index(drop = True)
data = data.drop(indices, axis = 0)
En este punto ya entendemos los datos con los que estamos trabajando y hemos separado los datos correspondientes a la muestra por lo que podemos proceder a realizar el siguiente paso que es el de procesamiento de los datos.
El procesamiento de los datos consistirá en solamente dos acciones, la primera es eliminar las columnas que no afecta a nuestro análisis y la última acción será el escalamiento de los datos ya que si observas los datos se encuentran rangos muy variantes por lo que es conveniente realizar un procesamiento de los mismos.
El primer paso para el procesamiento de los datos es eliminar las columnas que no aporta alguna información importante para nuestro análisis y esas columnas corresponden a la región y el canal, estas dos características no son importantes para nuestro objetivo final que sería conocer las relaciones de los productos más vendidos, en caso que queramos conocer la región o el canal de venta si los deberías dejar e incluir en el análisis pero para nuestro caso esta información no es necesaria por lo tanto podemos eliminar ambas columnas.
Para eliminarlas solamente debemos utilizar la instrucción “drop” junto los nombres de ambas columnas, acá también podíamos utilizar la ubicación de las mismas, ambas opciones son correctas. Al eliminar ambas columnas ya nuestro conjunto de datos no cuenta con 8 columnas sino con 6.
Este mismo procedimiento lo debemos realizar con la variable “muestras”, ya que esta es un espejo a los datos con los que vamos a trabajar. Cualquier cambio que hagamos al conjunto de datos original también lo debemos hacer a este mini conjunto de lo contrario al momento de utilizarlo nos dará error.
### PROCESAMIENTO DE LOS DATOS ### #Eliminamos las columnas de región y canal data = data.drop(['Region', 'Channel'], axis = 1) muestras = muestras.drop(['Region', 'Channel'], axis = 1)
El siguiente paso es el de realizar el escalamiento de los datos. Si observas el conjunto de datos te podrás cuenta que los rangos de datos que se manejan son muy variantes y esto puede afectar el análisis cuando apliquemos el algoritmo, por lo que es conveniente realizar el escalamiento de los datos.
Para realizar esto importamos de “sklearn” el modulo correspondiente a “preprocessing”. Acá utilizamos “normalizer()” y “fit_transform” junto con el conjunto de datos para transformar los datos.
Fíjate que ahora nuestro conjunto de datos se llama data_escalada y como puedes observar los datos son flotantes y se encuentran en una misma escala.
Exactamente como hicimos en el paso anterior, debemos escalar los datos correspondientes a las “muestras”, ahora nuestras muestras se llamarán “muestras_escalada”.
#Se realiza el escalamiento de los datos from sklearn import preprocessing data_escalada = preprocessing.Normalizer().fit_transform(data) muestras_escalada = preprocessing.Normalizer().fit_transform(muestras)
En este punto ya tenemos nuestros datos listos para que podamos trabajar con ellos con nuestro algoritmo de agrupamiento.
Ha llegado el momento de realizar el análisis de Machine Learning y más específicamente aplicar el algoritmo de Agrupamiento Jerárquico.
Procedemos a determinar las variables a evaluar, para ello simplemente definimos la variable “X” igual a data_escalada. Esto lo hacemos simplemente para utilizar la variable “X” como siempre se realiza en los proyectos de Machine Learning.
#Se determina las variables a evaluar X = data_escalada
Seguidamente importamos el algoritmo, por lo tanto escribimos de sklearn.cluster importamos DBSCAN.
Utilizamos la variable “algoritmo” para configurar el algoritmo, expliquemos cada uno de los parámetros con que configuramos al algoritmo.
El primero es eps o épsilon esta es la distancia máxima entre dos muestras para que una sea considerada como el clúster de la otra. Para nuestro caso este valor será 0,12.
El siguiente parámetro es min_samples, que se refiere al número mínimo de puntos para formar un clúster, para nuestro caso utilizaremos 1.
El último parámetro es metric que es el tipo de métrica a utilizar cuando se calcula la distancia entre los puntos de un conjunto de características. Acá utilizaremos la euclidiana.
from sklearn.cluster import DBSCAN Se define el algoritmo algoritmo = DBSCAN(eps = 0.12, min_samples = 1) Se entrena el algoritmo algoritmo.fit(X) pred1 = algoritmo.fit_predict(X)
Recuerda que cada uno de estos parámetros fueron explicados anteriormente, por lo que te recomiendo que revises esa información para que entiendas mejor lo que estamos explicando acá.
Definido el algoritmo y los parámetros del mismo ahora procedemos a entrenarlo junto con los datos que ya hemos procesado previamente y se encuentran almacenados en la variable “X”. Fíjate que acá se utiliza a instrucción “fit()” para entrenar el modelo, esta es la misma instrucción de los algoritmos de aprendizaje supervisado.
Seguidamente realizamos una predicción de todos los datos, acá utilizamos fit_predict junto con los datos de X. Si vemos los datos podemos observar que se crearon varios clúster y cada datos corresponde a uno de ellos.
Ahora utilicemos los datos de muestras que separamos al principio para determinar a qué clúster pertenece.
Para esto simplemente utilizamos el modelo obtenido que se encuentra en la variable “algoritmo” y la instrucción “fit_predict()” junto con los datos de muestra que fueron escalados.
#Utilicemos los datos de muestras y verifiquemos en que cluster se encuentran
muestra_prediccion = algoritmo.fit_predict(muestras_escalada)
for i, pred in enumerate(muestra_prediccion):
print( "Muestra", i, "se encuentra en el clúster:", pred)
En caso de que tengamos nuevos datos, tenemos que ingresarlos de la misma forma que hicimos con “muestras_escalada”, recuerda que esta información deberá estar escalada y en el mismo formato que esta variable.
A continuación el código completo:
IMPORTAR LAS LIBRERÍAS
import pandas as pd
CARGAR LOS DATOS
data = pd.read_csv('Wholesale customers data.csv')
ANALIZAR LOS DATOS
Conocer la forma de los datos
data.shape
Conocer los datos nulos
data.isnull().sum()
Conocer el formato de los datos
data.dtypes
Se selecionan unos datos al azar para posteriormente probar los resultados
indices = [26,176,392]
muestras = pd.DataFrame(data.loc[indices],
columns = data.keys()).reset_index(drop = True)
data = data.drop(indices, axis = 0)
PROCESAMIENTO DE LOS DATOS
Eliminamos las columnas de región y canal
data = data.drop(['Region', 'Channel'], axis = 1,)
muestras = muestras.drop(['Region', 'Channel'], axis = 1,)
Se realiza el escalmiento de los datos
from sklearn import preprocessing
data_escalada = preprocessing.Normalizer().fit_transform(data)
muestras_escalada = preprocessing.Normalizer().fit_transform(muestras)
ANÁLISIS DE MACHINE LEARNING
Se determina las variables a evaluar
X = data_escalada
from sklearn.cluster import DBSCAN
Se define el algoritmo
algoritmo = DBSCAN(eps = 0.12, min_samples = 1)
Se entrena el algoritmo
algoritmo.fit(X)
pred1 = algoritmo.fit_predict(X)
Utilicemos los datos de muestras y verifiquemos en que cluster se encuentran
muestra_prediccion = algoritmo.fit_predict(muestras_escalada)
for i, pred in enumerate(muestra_prediccion):
print( "Muestra", i, "se encuentra en el clúster:", pred)
