Segmentación en Python

Analizamos la codificación en caliente, estandarización, PCA. Preparación de datos para la segmentación en Python.

Artículo escrito por Indraneel Dutta Baruah.

¡Obteniendo los datos correctos para la segmentación en Python perfecta!

La segmentación de clientes basada en datos o la agrupación de productos son fundamentales para que las empresas sigan siendo relevantes frente a la intensa competencia que enfrentan. Los consumidores tienen ahora mucho donde elegir y prefieren ofertas de productos personalizados.

Con la llegada de la cuarta revolución industrial en forma de inmenso crecimiento de la inteligencia artificial y las tecnologías de big data, no hay mejor momento para aprovechar los modelos de segmentación para realizar dicho análisis.

Pero antes de profundizar en estos modelos, debemos saber qué tipo de datos se necesitan para ellos. Este es el enfoque de mi blog, ya que pasaremos por todos los pasos necesarios para transformar nuestro conjunto de datos sin procesar al formato que necesitamos para entrenar y probar nuestros algoritmos de segmentación en Python.

Los datos

Para este ejercicio, trabajaremos con datos de flujo de clics de una tienda en línea que ofrece ropa para mujeres embarazadas. Tiene datos de abril de 2008 a agosto de 2008 e incluye variables como categoría de producto, ubicación de la foto en la página web, país de origen de la dirección IP y precio del producto en dólares estadounidenses. La razón por la que elegí este conjunto de datos es que los datos del flujo de clics se están convirtiendo en una fuente muy importante de proporcionar información detallada sobre el comportamiento del cliente. También nos proporciona un conjunto de datos con desafíos típicos como alta dimensionalidad, necesidad de ingeniería de características, presencia de variables categóricas y diferentes escalas de campos.

Intentaremos preparar los datos para la segmentación de productos realizando los siguientes pasos:

1. Análisis de datos exploratorios (EDA)
2. Ingeniería de funciones
3. Una codificación en caliente
4. Estandarización
5. PCA

Primero intentaremos leer el conjunto de datos (usando la read_csvfunción) y mirar las 5 filas superiores (usando la headfunción):

# Read dataset and look at top records
import pandas as pd
df = pd.read_csv('e-shop clothing 2008.csv', delimiter=";")
df.head(5)

Comprobación número de filas, columnas y sus tipos

Tenemos los datos a nivel diario para varios modelos de ropa (nombre del campo: "página 2 (modelo de ropa)"). A continuación, vamos a comprobar el número de filas y columnas y sus tipos (utilizando la función info)

#Check the number of rows and columns and their types
df.info()

Tenemos 165474 registros y 14 campos. Hay que tener en cuenta que muchos campos son numéricos, pero lo ideal sería que fueran cadenas. Convirtamos los campos en cadenas utilizando la función as.type(str):

# Convert categorical variables to string
cat_vars = ['year', 'month', 'day', 'country', 'session ID',
               'page 1 (main category)', 'page 2 (clothing model)',   'colour',
               'location', 'model photography', 'price 2', 'page']
df[cat_vars] = df[cat_vars].astype(str)
df.info()

Comprobemos a continuación las propiedades de los campos numéricos:

# Check properties of numeric fields
df.describe()

Como se ve en la figura 4, el precio del producto (nombre del campo: "precio") está en una escala mucho mayor que la secuencia de clics durante una sesión (nombre del campo: "pedido"). Esto significa que tendremos que normalizar estos campos para llevarlos a la misma escala, ya que los modelos basados en la distancia, como K-means, se ven afectados por la escala de los campos.

Ingeniería de funciones

Como se mencionó anteriormente, nuestro conjunto de datos es a nivel diario y necesitamos agregar los datos a nivel de producto porque queremos realizar la segmentación de productos. Creamos las siguientes características mientras agregamos a nivel de producto:

1. Color del producto más frecuente, día de navegación, país, tipo de foto (perfil, cara), tipo de precio (superior o inferior al promedio de la categoría), número de página dentro del sitio web y ubicación de la foto del producto en la página (usando la modefunción)
2. Número total de ID de sesión únicos (usando la nununiquefunción)
3. Mediana, mínima y máxima de la secuencia de clics durante una sesión y precio del producto (usando la función median, miny max)

# Feature Engineering
from scipy.stats import mode 
df2 = df.groupby(['country','page 1 (main category)','page 2 (clothing model)']).agg(
                                                                             median_no_of_clicks_per_session=('order', 'median'),
                                                                             min_no_of_clicks_per_session=('order', 'max'),
                                                                             max_no_of_clicks_per_session=('order', 'min'),
                                                                             median_price=('price', 'median'),
                                                                             min_price=('price', 'max'),
                                                                             max_price=('price', 'min'),
                                                                             total_number_of_sessions =('session ID', pd.Series.nunique),
                                                                             most_frequent_day=('day', lambda x: mode(x)[0][0]),
                                                                             most_frequent_colour=('colour', lambda x: mode(x)[0][0]),
                                                                             most_frequent_location=('location', lambda x: mode(x)[0][0]),
                                                                             most_frequent_photo_type=('model photography', lambda x: mode(x)[0][0]),
                                                                             most_frequent_price_type =('price 2', lambda x: mode(x)[0][0]),
                                                                             most_frequent_page_number =('page', lambda x: mode(x)[0][0])
                                                                            )
df2

Una codificación en caliente (one hot)

La codificación en caliente crea variables ficticias que son variables duplicadas que representan un nivel de una variable categórica. La presencia de un nivel se representa con un 1 y la ausencia con un 0. Si la variable categórica es ordinal (es decir, las categorías de la variable tienen un orden), podemos traducir la variable a una variable numérica utilizando la función OrdinalEncoder. En nuestro caso, las variables categóricas no tienen ninguna ordinalidad y, por tanto, utilizamos la función get_dummies para crear las variables ficticias.

# One hot encoding - to convert categorical data to continuous
cat_vars = ['most_frequent_day',
           'most_frequent_colour', 'most_frequent_location',
           'most_frequent_photo_type', 'most_frequent_price_type',
           'most_frequent_page_number']
df2[cat_vars] = df2[cat_vars].astype(str)
df3 = pd.get_dummies(df2)
df3.head(5)

También podemos utilizar la función OneHotEncoder en lugar de la función get_dummies si nuestras características nominales son enteras.

Estandarización

Como se muestra en la figura 4, nuestras características numéricas tienen diferentes escalas. El escalado ayuda a comparar entidades independientes con diferentes rangos o unidades después de convertirlas en valores comparables. Hay dos métodos de escala principales:

La normalización es la opción ideal cuando sabemos que la distribución de datos no sigue una distribución gaussiana o para algoritmos que no asumen ninguna distribución de datos como K-Vecinos más cercanos y Redes neuronales. Por otro lado, la estandarización se puede utilizar cuando los datos siguen una distribución gaussiana. Pero estas no son reglas estrictas e idealmente podemos probar ambas y seleccionar la opción que dé los mejores resultados de validación de clúster. Estaremos estandarizando nuestros campos numéricos en este ejemplo usando la StandardScalerfunción.

# Standardizing
from sklearn.preprocessing import StandardScaler
con_vars = ['median_no_of_clicks_per_session', 'min_no_of_clicks_per_session',
           'max_no_of_clicks_per_session', 'median_price', 'min_price',
           'max_price', 'total_number_of_sessions']
scaler = StandardScaler()
df3[con_vars]=scaler.fit_transform(df3[con_vars])
df3.head(5)

Análisis de componentes principales

El análisis de componentes principales combina nuestras características actuales de una manera específica. Para crear nuevas características y luego podemos descartar las "menos importantes". Sin dejar de retener las partes más valiosas de todas las variables originales. Este es un método útil cuando tenemos muchas funciones que manejar. Calcula la matriz de covarianza de todas las características y luego genera los autovectores y autovalores de la matriz. Luego, la matriz de covarianza se multiplica por los vectores propios para crear componentes principales. Estos componentes principales son las nuevas características basadas en nuestras características originales y su importancia en términos de explicar la variabilidad en el conjunto de datos viene dada por valores propios. Podemos mantener los componentes principales mejor clasificados que explican un nivel mínimo de variación en nuestro conjunto de datos original.

Podemos implementar el análisis de PCA usando la pcafunción del sklearn.decompositionmódulo. He configurado una función de bucle para identificar el número de componentes principales que explican al menos el 85% de la varianza en el conjunto de datos.

# PCA
from sklearn.decomposition import PCA
# Loop Function to identify number of principal components that explain at least 85% of the variance
for comp in range(3, df3.shape[1]):
    pca = PCA(n_components= comp, random_state=42)
    pca.fit(df3)
    comp_check = pca.explained_variance_ratio_
    final_comp = comp
    if comp_check.sum() > 0.85:
        break
        
Final_PCA = PCA(n_components= final_comp,random_state=42)
Final_PCA.fit(df3)
cluster_df=Final_PCA.transform(df3)
num_comps = comp_check.shape[0]
print("Using {} components, we can explain {}% of the variability in the original data.".format(final_comp,comp_check.sum()))

Como se ve en la figura 8, 15 componentes son capaces de explicar el 85% de la varianza de nuestro conjunto de datos. Ahora podemos utilizar estas características en nuestros modelos no supervisados como K means, DBSCAN, clustering jerárquico, etc. para segmentar nuestros productos.

Conclusión

En esta publicación, aprendimos sobre los pasos necesarios para preparar los datos para el análisis de segmentación en Python.

Específicamente, aprendimos:

• Cómo deberíamos realizar un análisis de datos exploratorio observando los datos, los tipos de campo y las propiedades de los campos numéricos.
• Ejemplos de qué tipo de características podemos crear a partir de los campos categóricos y continuos sin procesar.
• Cómo implementar una codificación en caliente en Python y una codificación ordinal.
• Varios tipos de técnicas de escalado y cómo elegir entre ellas.
• Qué es PCA y cómo usarlo en Python para la reducción de características.

¿Tienes alguna pregunta o sugerencia sobre este blog? No dudes en enviar una nota.

Por último, te animo a que consultes el siguiente artículo para obtener una explicación en profundidad de los diferentes métodos para seleccionar el número óptimo de clusters para la segmentación:

Cheat sheet para implementar 7 métodos para seleccionar el número óptimo de clusters en Python.

Si deseas leer la versión original en Inglés, haz clic aquí.

Si te gusta la información que traemos para ti, dale “Me Gusta” a nuestra página de Facebook. Síguenos a través de nuestro canal de Youtube, donde puedes ver el distinto material que preparamos para ti. Y si lo deseas, puedes suscribirte a nuestra página para recibir un regalo digital que preparamos para ti.

Accede a nuestros cursos de Python para aprender mucho más.