Existen muchos modelos para clustering. En este ejemplo vamos a usar el K-medias, que se utiliza mucho en ciencia de datos, especialmente si se necesita de forma rápida descubrir nuevas conclusiones a partir de datos no etiquetados.
Vamos a realizar dos ejemplos: Uno con k-medias en un conjunto de datos generado al azar y otro usando K-medias para la segmentación del cliente
Primero, importemos las librerías necesarias:
[sourcecode language=»python» wraplines=»false» collapse=»false»]
import random
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets.samples_generator import make_blobs
%matplotlib inline
[/sourcecode]
k-Media en un dataset generado aleatoriamente
Necesitamos primero configurar una semilla aleatoria(random seed). Utilizaremos la función numpy’s random.seed(), donde la semilla se establecerá con el valor 0
[sourcecode language=»python» wraplines=»false» collapse=»false»]
np.random.seed(0)
[/sourcecode]
Luego, haremos clusters aleatorios de puntos usando la clase make_blobs. La clase make_blobs puede aceptar varias entradas, pero estaremos usando concretamente estas.
Entradas:
- n_samples: Es el número total de puntos equitativamente divididos entre los clusters. El valor será: 5000
- centers: Es el número de centros a generar. El valor será: [[4, 4], [-2, -1], [2, -3],[1,1]]
- cluster_std: Es el desvío estándar de los clusters. El valor será: 0.9
Salidas:
- X: Array de la forma [n_samples, n_features]. (Matríz de Distancia). Son las muestras generadas.
- y: Array de la forma [n_samples]. (Response Vector). Son las etiquetas de números enteros para la pertenencia de cluster en cada muestra.
[sourcecode language=»python» wraplines=»false» collapse=»false»]
X, y = make_blobs(n_samples=5000, centers=[[4,4], [-2, -1], [2, -3], [1, 1]], cluster_std=0.9)
[/sourcecode]
Mostrar los puntos de los datos generados al azar.
[sourcecode language=»python» wraplines=»false» collapse=»false»]
plt.scatter(X[:, 0], X[:, 1], marker=’.’)
[/sourcecode]
<matplotlib.collections.PathCollection at 0x7f0a31054dd8>
Estableciendo K-Medias
Ahora que tenemos nuestros datos aleatorios, configuremos nuestro Clustering K-Medias.
La clase KMedias tiene muchos parámetros que se pueden utilizar, pero estaremos usando estos tres:
- init: Método de inicialización de los centroides.
- El valor será: «k-means++»
- k-means++: Elije centros de clusters iniciales eficientes para el clustering k-media de forma tal de acelerar la convergencia.
- n_clusters: El número de clusters a formar y la cantidad de centroides a generar.
- El valor será: 4 (tenemos 4 centros)
- n_init: Cantidad de veces que el algoritmo k-medias se ejecutará con diferentes semillas centroides. El resultado final será la mejor salida de consecutivas ejecuciones de n_init en términos de inercia.
- Value will be: 12
Inicializar KMedias con estos parámetros, donde el parámetro de salida se llama k_means.
[sourcecode language=»python» wraplines=»false» collapse=»false»]
k_means = KMeans(init = "k-means++", n_clusters = 4, n_init = 12)
[/sourcecode]
Ahora, unamos el modelo KMedias con la matriz de distancia que creamos anteriormente, X
[sourcecode language=»python» wraplines=»false» collapse=»false»]
k_means.fit(X)
[/sourcecode]
KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
n_clusters=4, n_init=12, n_jobs=None, precompute_distances='auto',
random_state=None, tol=0.0001, verbose=0)
Ahora juntemos las etiquetas de cada punto en el modelo usando el atributo de KMedias .labels_ y lo guardamos como k_means_labels
[sourcecode language=»python» wraplines=»false» collapse=»false»]
k_means_labels = k_means.labels_
k_means_labels
[/sourcecode]
array([0, 3, 3, ..., 1, 0, 0], dtype=int32)
También obtendremos las coordenadas de los centros del cluster usando KMedias .cluster_centers_ y guardémoslo en k_means_cluster_centers
[sourcecode language=»python» wraplines=»false» collapse=»false»]
k_means_cluster_centers = k_means.cluster_centers_
k_means_cluster_centers
[/sourcecode]
array([[-2.03743147, -0.99782524],
[ 3.97334234, 3.98758687],
[ 0.96900523, 0.98370298],
[ 1.99741008, -3.01666822]])
Creando la Trama
En este momento, tenemos los datos generados al azar y el modelo KMedias inicializado. Podemos dibujarlos y ver de qué se trata
[sourcecode language=»python» wraplines=»false» collapse=»false»]
# Inicializar el dibujo con las dimensiones especificadas.
fig = plt.figure(figsize=(6, 4))
# Los colores usan un mapa de color, dónde produciremos un array de colores basados en
# el número de etiquetas que hay. Usaremos set(k_means_labels) para obtener
# etiquetas unívocas.
colors = plt.cm.Spectral(np.linspace(0, 1, len(set(k_means_labels))))
# Crear un dibujo
ax = fig.add_subplot(1, 1, 1)
# Loop For que dibuja los puntos de datos y los centroides.
# k tomará valores entre 0-3, los cuales coincidirán con los clusters posibles en el
# que está cada punto.
for k, col in zip(range(len([[4,4], [-2, -1], [2, -3], [1, 1]])), colors):
# Crear una lista de todos los puntos, donde aquellos que están
# en el cluster (ej. cluster 0) están etiquetados como verdadero, o en su defecto
# estarán etiquetados como falso.
my_members = (k_means_labels == k)
# Definir el centroide o centro del cluster.
cluster_center = k_means_cluster_centers[k]
# Dibujar los puntos de datos con color col.
ax.plot(X[my_members, 0], X[my_members, 1], ‘w’, markerfacecolor=col, marker=’.’)
# Dibujo de los centroides con un color específico pero una linea más oscura
ax.plot(cluster_center[0], cluster_center[1], ‘o’, markerfacecolor=col, markeredgecolor=’k’, markersize=6)
# Título del dibujo
ax.set_title(‘KMeans’)
# Eliminar los ticks del eje x
ax.set_xticks(())
# Eliminar los ticks del eje y
ax.set_yticks(())
# Mostrar el dibujo
plt.show()
[/sourcecode]
Agrupación en 3 clusters
Si queremos agrupar los mismos datos en 3 cluster podemos realizar el siguiente
[sourcecode language=»python» wraplines=»false» collapse=»false»]
k_means3 = KMeans(init = "k-means++", n_clusters = 3, n_init = 12)
k_means3.fit(X)
fig = plt.figure(figsize=(6, 4))
colors = plt.cm.Spectral(np.linspace(0, 1, len(set(k_means3.labels_))))
ax = fig.add_subplot(1, 1, 1)
for k, col in zip(range(len(k_means3.cluster_centers_)), colors):
my_members = (k_means3.labels_ == k)
cluster_center = k_means3.cluster_centers_[k]
ax.plot(X[my_members, 0], X[my_members, 1], ‘w’, markerfacecolor=col, marker=’.’)
ax.plot(cluster_center[0], cluster_center[1], ‘o’, markerfacecolor=col, markeredgecolor=’k’, markersize=6)
plt.show()
[/sourcecode]
Segmentación de Clientes con K-Medias
Imagine que tiene un conjunto de datos de clientes y tiene que aplicar la segmentación de clientes. La segmentación de clientes es la práctica de particionar una base de datos en particiones de individuos que tengan características similares. Es una estrategia significativa ya que un negocio puede poner el foco en estos grupos específicos de clientes y ubicar los recursos de marketing lo más eficientemente posible. Por ejemplo, un grupo podría tener clientes con alto ingreso y bajo riesgo, lo que quiere decir que es muy probable adquieran productos, o se suscriban para un servicio. Una de las tareas del negocio es retener este tipo de clientes. Otro grupo podría incluir clientes de organizacion sin fines de lucro y asi seguiríamos con más ejemplos.
Descargamos el conjunto de datos
[sourcecode language=»python» wraplines=»false» collapse=»false»]
!wget -O Cust_Segmentation.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/Cust_Segmentation.csv
[/sourcecode]
--2020-02-20 17:44:55-- https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/Cust_Segmentation.csv Resolving s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)... 67.228.254.196 Connecting to s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)|67.228.254.196|:443... connected. HTTP request sent, awaiting response... 200 OK Length: 34276 (33K)
[text language=»/csv»][/text]
Saving to: ‘Cust_Segmentation.csv’
Cust_Segmentation.c 100%[===================>] 33.47K –.-KB/s in 0.02s
2020-02-20 17:44:55 (1.61 MB/s) – ‘Cust_Segmentation.csv’ saved [34276/34276]
Cargar los Datos Desde un Archivo CSV
Antes de trabajar con los datos, se deberá usar la URL para obtener el archivo Cust_Segmentation.csv.
[sourcecode language=»python» wraplines=»false» collapse=»false»]
import pandas as pd
cust_df = pd.read_csv("Cust_Segmentation.csv")
cust_df.head()
[/sourcecode]
| Customer Id | Age | Edu | Years Employed | Income | Card Debt | Other Debt | Defaulted | Address | DebtIncomeRatio | |
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 41 | 2 | 6 | 19 | 0.124 | 1.073 | 0.0 | NBA001 | 6.3 |
| 1 | 2 | 47 | 1 | 26 | 100 | 4.582 | 8.218 | 0.0 | NBA021 | 12.8 |
| 2 | 3 | 33 | 2 | 10 | 57 | 6.111 | 5.802 | 1.0 | NBA013 | 20.9 |
| 3 | 4 | 29 | 2 | 4 | 19 | 0.681 | 0.516 | 0.0 | NBA009 | 6.3 |
| 4 | 5 | 47 | 1 | 31 | 253 | 9.308 | 8.908 | 0.0 | NBA008 | 7.2 |
Pre-procesamiento
Como podrás ver, Address en este conjunto de datos es una variable categórica. El algoritmo k-medias no está directamente aplicado a variables categóricas porque la función de la distancia Euclediana no tiene sentido para variables discretas. Por lo que descartaremos esta característica y seguiremos adelante para correr el clustering.
[sourcecode language=»python» wraplines=»false» collapse=»false»]
df = cust_df.drop(‘Address’, axis=1)
df.head()
[/sourcecode]
| Customer Id | Age | Edu | Years Employed | Income | Card Debt | Other Debt | Defaulted | DebtIncomeRatio | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 41 | 2 | 6 | 19 | 0.124 | 1.073 | 0.0 | 6.3 |
| 1 | 2 | 47 | 1 | 26 | 100 | 4.582 | 8.218 | 0.0 | 12.8 |
| 2 | 3 | 33 | 2 | 10 | 57 | 6.111 | 5.802 | 1.0 | 20.9 |
| 3 | 4 | 29 | 2 | 4 | 19 | 0.681 | 0.516 | 0.0 | 6.3 |
| 4 | 5 | 47 | 1 | 31 | 253 | 9.308 | 8.908 | 0.0 | 7.2 |
Normalizando el desvío estándar
Ahora normalicemos el set de datos. Pero, ¿por que necesitamos normalizar? La normalización es un método estadístico que ayuda a los algoritmos basados en matemática interpretar características con distintas magnitudes y distribuciones de manera igual. Usamos tandardScaler() para normalizar nuestros set de datos.
[sourcecode language=»python» wraplines=»false» collapse=»false»]
from sklearn.preprocessing import StandardScaler
X = df.values[:,1:]
X = np.nan_to_num(X)
Clus_dataSet = StandardScaler().fit_transform(X)
Clus_dataSet
[/sourcecode]
array([[ 0.74291541, 0.31212243, -0.37878978, ..., -0.59048916,
-0.52379654, -0.57652509],
[ 1.48949049, -0.76634938, 2.5737211 , ..., 1.51296181,
-0.52379654, 0.39138677],
[-0.25251804, 0.31212243, 0.2117124 , ..., 0.80170393,
1.90913822, 1.59755385],
...,
[-1.24795149, 2.46906604, -1.26454304, ..., 0.03863257,
1.90913822, 3.45892281],
[-0.37694723, -0.76634938, 0.50696349, ..., -0.70147601,
-0.52379654, -1.08281745],
[ 2.1116364 , -0.76634938, 1.09746566, ..., 0.16463355,
-0.52379654, -0.2340332 ]])
Modeling
En nuestro ejemplo (en caso no hayamos tenido acceso al algoritmo de k-medias), sería lo mismo que suponer que cada grupo de cliente tendría cierta edad, educación, etc., con muchas pruebas y experimentos. Sin embargo, usando k-medias clustering, podemos hacer todo este proceso mucho más facilmente.
Apliquemos k-medias en nuestro set de datos y miremos las etiquetas del cluster.
[sourcecode language=»python» wraplines=»false» collapse=»false»]
clusterNum = 3
k_means = KMeans(init = "k-means++", n_clusters = clusterNum, n_init = 12)
k_means.fit(X)
labels = k_means.labels_
print(labels)
[/sourcecode]
[0 2 0 0 1 2 0 2 0 2 2 0 0 0 0 0 0 0 2 0 0 0 0 2 2 2 0 0 2 0 2 0 0 0 0 0 0 0 0 2 0 2 0 1 0 2 0 0 0 2 2 0 0 2 2 0 0 0 2 0 2 0 2 2 0 0 2 0 0 0 2 2 2 0 0 0 0 0 2 0 2 2 1 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 2 0 2 0 0 0 0 0 0 0 2 0 2 2 0 2 0 0 2 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 2 0 0 0 2 0 0 0 0 0 2 0 0 2 0 2 0 0 2 1 0 2 0 0 0 0 0 0 1 2 0 0 0 0 2 0 0 2 2 0 2 0 2 0 0 0 0 2 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 1 2 0 0 0 0 0 0 0 2 0 0 0 0 0 0 2 0 0 2 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 0 2 0 2 0 2 2 0 0 0 0 0 0 0 0 0 2 2 2 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 2 0 0 0 0 0 2 0 2 2 0 0 0 0 0 2 0 0 0 0 0 0 2 0 0 2 0 0 2 0 0 0 0 0 2 0 0 0 1 0 0 0 2 0 2 2 2 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 2 0 2 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 2 0 0 2 0 0 0 0 2 0 0 0 0 2 0 0 2 0 0 0 0 0 0 0 0 0 2 0 0 0 2 0 0 0 0 1 0 0 0 0 0 0 2 0 0 0 1 0 0 0 0 2 0 1 0 0 0 0 2 0 2 2 2 0 0 2 2 0 0 0 0 0 0 0 2 0 0 0 0 2 0 0 0 2 0 2 0 0 0 2 0 0 0 0 2 2 0 0 0 0 2 0 0 0 0 2 0 0 0 0 0 2 2 0 0 0 0 0 0 0 0 0 0 0 1 2 0 0 0 0 0 0 2 0 0 0 0 2 0 0 2 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 2 0 2 0 0 1 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 2 0 2 0 0 0 0 0 0 2 0 0 0 0 2 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 2 2 0 0 2 0 2 0 0 2 0 2 0 0 1 0 2 0 2 0 0 0 0 0 2 2 0 0 0 0 2 0 0 0 2 2 0 0 2 0 0 0 2 0 1 0 0 2 0 0 0 0 0 0 0 2 0 0 0 2 0 0 0 0 0 2 0 0 2 0 0 0 0 0 0 0 0 2 0 0 2 0 2 0 2 2 0 0 0 2 0 2 0 0 0 0 0 2 0 0 0 0 2 2 0 0 2 2 0 0 0 0 0 2 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 2 0 2 2 0 2 0 2 2 0 0 2 0 0 0 0 0 2 2 0 0 0 0 0 0 0 2 0 0 0 0 0 0 1 2 2 0 0 0 0 0 0 0 2 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 2]
Descubrimientos
Asignamos las etiquetas a cada fila dentro del marco de datos.
[sourcecode language=»python» wraplines=»false» collapse=»false»]
df["Clus_km"] = labels
df.head(5)
[/sourcecode]
| Customer Id | Age | Edu | Years Employed | Income | Card Debt | Other Debt | Defaulted | DebtIncomeRatio | Clus_km | |
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 41 | 2 | 6 | 19 | 0.124 | 1.073 | 0.0 | 6.3 | 0 |
| 1 | 2 | 47 | 1 | 26 | 100 | 4.582 | 8.218 | 0.0 | 12.8 | 2 |
| 2 | 3 | 33 | 2 | 10 | 57 | 6.111 | 5.802 | 1.0 | 20.9 | 0 |
| 3 | 4 | 29 | 2 | 4 | 19 | 0.681 | 0.516 | 0.0 | 6.3 | 0 |
| 4 | 5 | 47 | 1 | 31 | 253 | 9.308 | 8.908 | 0.0 | 7.2 | 1 |
Podemos revisar fácilmente los valores centroides sacando el promedio de las características de cada cluster.
[sourcecode language=»python» wraplines=»false» collapse=»false»]
df.groupby(‘Clus_km’).mean()
[/sourcecode]
| Customer Id | Age | Edu | Years Employed | Income | Card Debt | Other Debt | Defaulted | DebtIncomeRatio | |
|---|---|---|---|---|---|---|---|---|---|
| Clus_km | |||||||||
| 0 | 432.006154 | 32.967692 | 1.613846 | 6.389231 | 31.204615 | 1.032711 | 2.108345 | 0.284658 | 10.095385 |
| 1 | 410.166667 | 45.388889 | 2.666667 | 19.555556 | 227.166667 | 5.678444 | 10.907167 | 0.285714 | 7.322222 |
| 2 | 403.780220 | 41.368132 | 1.961538 | 15.252747 | 84.076923 | 3.114412 | 5.770352 | 0.172414 | 10.725824 |
Ahora, miremos la distribuición de los clientes basados en su edad e ingreso:
[sourcecode language=»python» wraplines=»false» collapse=»false»]
area = np.pi * ( X[:, 1])**2
plt.scatter(X[:, 0], X[:, 3], s=area, c=labels.astype(np.float), alpha=0.5)
plt.xlabel(‘Age’, fontsize=18)
plt.ylabel(‘Income’, fontsize=16)
plt.show()
[/sourcecode]
[sourcecode language=»python» wraplines=»false» collapse=»false»]
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure(1, figsize=(8, 6))
plt.clf()
ax = Axes3D(fig, rect=[0, 0, .95, 1], elev=48, azim=134)
plt.cla()
# plt.ylabel(‘Age’, fontsize=18)
# plt.xlabel(‘Income’, fontsize=16)
# plt.zlabel(‘Education’, fontsize=16)
ax.set_xlabel(‘Education’)
ax.set_ylabel(‘Age’)
ax.set_zlabel(‘Income’)
ax.scatter(X[:, 1], X[:, 0], X[:, 3], c= labels.astype(np.float))
[/sourcecode]
<mpl_toolkits.mplot3d.art3d.Path3DCollection at 0x7f0a271f7748>
k-medias particionará los clientes en grupos mutuamente excluyentes, por ejemplo, en 3 clusters. Los clientes de cada cluster son parecidos unos a otros en el aspecto demográfico. Ahora, podemos crear un perfil para cada grupo, teniendo en cuenta las características en común de cada cluster. Por ejemplo, los 3 clusters podrían ser:
- AFLUENTE, EDUCADO Y TERCERA EDAD
- EDAD MEDIA E INGRESO PROMEDIO
- JOVEN E INGRESO BAJO
