Agrupación para datos discretos mixtos numéricos y nominales

Mis datos incluyen respuestas a encuestas que son binarias (numéricas) y nominales / categóricas. Todas las respuestas son discretas y a nivel individual.

Los datos tienen forma (n = 7219, p = 105).

Un par de cosas:

• Estoy tratando de identificar una técnica de agrupamiento con una medida de similitud que funcione para datos binarios categóricos y numéricos. Existen técnicas en R kmodes clustering y kprototype que están diseñadas para este tipo de problema, pero estoy usando Python y necesito una técnica de sklearn clustering que funcione bien con este tipo de problemas.

• Quiero construir perfiles de segmentos de individuos. lo que significa que este grupo de personas se preocupa más por este conjunto de características.

Tomando una puñalada:

Estoy tratando de identificar una técnica de agrupamiento con una medida de similitud que funcione para datos binarios categóricos y numéricos.

La distancia de Gower es una medida de distancia útil cuando los datos contienen variables continuas y categóricas.

Existen técnicas en R kmodes clustering y kprototype que están diseñadas para este tipo de problema, pero estoy usando Python y necesito una técnica de sklearn clustering que funcione bien con este tipo de problemas.

No pude encontrar una implementación de Gower Distance en Python cuando la busqué hace unos 4-5 meses. Entonces se me ocurrió mi propia implementación.

import pandas as pd
import numpy as np
from sklearn.neighbors import DistanceMetric


def gower_distance(X):
    """
    This function expects a pandas dataframe as input
    The data frame is to contain the features along the columns. Based on these features a
    distance matrix will be returned which will contain the pairwise gower distance between the rows
    All variables of object type will be treated as nominal variables and the others will be treated as 
    numeric variables.
    Distance metrics used for:
    Nominal variables: Dice distance (https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient)
    Numeric variables: Manhattan distance normalized by the range of the variable (https://en.wikipedia.org/wiki/Taxicab_geometry)
    """
    individual_variable_distances = []

    for i in range(X.shape[1]):
        feature = X.iloc[:,[i]]
        if feature.dtypes[0] == np.object:
            feature_dist = DistanceMetric.get_metric('dice').pairwise(pd.get_dummies(feature))
        else:
            feature_dist = DistanceMetric.get_metric('manhattan').pairwise(feature) / np.ptp(feature.values)

        individual_variable_distances.append(feature_dist)

    return np.array(individual_variable_distances).mean(0)

El enlace al mismo fragmento de código: https://github.com/matchado/Misc/blob/master/gower_dist.py

Con respecto a la técnica de agrupamiento, no he usado las que mencionaste. Pero he usado la agrupación jerárquica en R junto con la distancia de Gower con éxito en el pasado.

Analizando las técnicas de agrupación disponibles en scikit learn, la Agrupación Aglomerativa parece encajar perfectamente. http://scikit-learn.org/stable/modules/clustering.html#hierarchical-clustering

Quiero construir perfiles de segmentos de individuos. lo que significa que este grupo de personas se preocupa más por este conjunto de características.

Una vez que haya asignado etiquetas de clúster a cada fila de sus datos, para cada clúster examine la distribución de las características (estadísticas de resumen para variables continuas y distribuciones de frecuencia para variables categóricas). Esto es más fácil de analizar visualmente si su número de características es manejable (¿<20 quizás?).

Pero como tiene más de 100 funciones, le sugiero un enfoque más organizado. Cree una matriz con etiquetas de clúster en las columnas y el resumen estadístico de las características en las filas (sugiero usar la mediana para la variable continua y el porcentaje de ocurrencia del valor más frecuente en el clúster para la variable categórica)

Puede parecer algo como esto.

╔═══════════════════════╦═══════════╦═══════════╦════╦═══════════╗
║        Feature        ║ Cluster 1 ║ Cluster 2 ║ …  ║ Cluster N ║
╠═══════════════════════╬═══════════╬═══════════╬════╬═══════════╣
║ Numeric feature 1     ║ 15        ║ 37        ║ .. ║ 1         ║
║ Numeric feature 2     ║ 34        ║ 56        ║ …  ║ 56        ║
║ Categorical feature 1 ║ 47%       ║ 87%       ║ …  ║ 25%       ║
║ …                     ║ …         ║ …         ║ …  ║ …         ║
║ Categorical feature N ║ 25%       ║ 91%       ║ …  ║ 11%       ║
║ Numeric feature N     ║ 0.2       ║ 0.7       ║ …  ║ 0.5       ║
╚═══════════════════════╩═══════════╩═══════════╩════╩═══════════╝

Agregué mi respuesta a esta pregunta a continuación: ustedes esencialmente preguntaron lo mismo.

Esta pregunta parece realmente sobre la representación, y no tanto sobre la agrupación.

Los datos categóricos son un problema para la mayoría de los algoritmos en el aprendizaje automático. Supongamos, por ejemplo, que tiene una variable categórica llamada "color" que podría adoptar los valores rojo, azul o amarillo. Si simplemente los codificamos numéricamente como 1,2 y 3 respectivamente, nuestro algoritmo pensará que el rojo (1) está realmente más cerca del azul (2) que del amarillo (3). Necesitamos usar una representación que le permita a la computadora entender que estas cosas son en realidad igualmente diferentes.

Una manera simple es usar lo que se llama una representación única, y es exactamente lo que pensabas que deberías hacer. En lugar de tener una variable como "color" que puede tomar tres valores, la separamos en tres variables. Estos serían "color rojo", "color azul" y "color amarillo", que solo pueden tomar el valor 1 o 0.

Esto aumenta la dimensionalidad del espacio, pero ahora podría usar cualquier algoritmo de agrupación que desee. A veces tiene sentido zscore o blanquear los datos después de hacer este proceso, pero su idea es definitivamente razonable.

La métrica de distancia implementada por @gregorymatchado tiene un error. Para los atributos numéricos, el rango dará NaN para los mismos valores en todo momento. Para eso necesitamos un cambio de uso en max(np.ptp(feature.values),1)lugar de np.ptp(feature.values). Código completo a continuación:

import pandas as pd
import numpy as np
from sklearn.neighbors import DistanceMetric


def gower_distance(X):
"""
This function expects a pandas dataframe as input
The data frame is to contain the features along the columns. Based on these features a
distance matrix will be returned which will contain the pairwise gower distance between the rows
All variables of object type will be treated as nominal variables and the others will be treated as 
numeric variables.
Distance metrics used for:
Nominal variables: Dice distance (https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient)
Numeric variables: Manhattan distance normalized by the range of the variable (https://en.wikipedia.org/wiki/Taxicab_geometry)
"""
individual_variable_distances = []

for i in range(X.shape[1]):
    feature = X.iloc[:,[i]]
    if feature.dtypes[0] == np.object:
        feature_dist = DistanceMetric.get_metric('dice').pairwise(pd.get_dummies(feature))
    else:
        feature_dist = DistanceMetric.get_metric('manhattan').pairwise(feature) / max(np.ptp(feature.values),1)

    individual_variable_distances.append(feature_dist)

return np.array(individual_variable_distances).mean(0)

Creo que también tienes error. Si el vector de características tiene una escala muy pequeña. entonces tu distancia es inútil. Entonces, convertiría como sigue:

epsilon = 10**(-8)
... / max(np.ptp(feature.values), epsilon)