DEV Community: Edgar Cajusol

De Datos a Estrategias: Cómo la Estadística Puede Impulsar Decisiones Confiables en Marketing

Edgar Cajusol — Sun, 01 Dec 2024 07:28:33 +0000

La estadística es una herramienta poderosa que nos permite abordar problemas complejos y responder preguntas que surgen al observar datos o patrones por primera vez. Un ejemplo de esto podría ser analizar la personalidad de los clientes en un supermercado. Preguntas como ¿Realmente este grupo es diferente al otro? ¿En qué medida? ¿Debería centrarme más en este grupo para mejorar su experiencia y mis ventas? son clave para tomar decisiones acertadas.

Si bien las visualizaciones pueden ayudarnos a comprender los datos de manera rápida, no siempre son 100% confiables. Podríamos observar diferencias claras entre grupos, pero esas diferencias pueden no ser estadísticamente significativas.

Aquí es donde entra en juego la estadística: no solo nos ayuda a analizar los datos de manera más profunda, sino que nos da la seguridad necesaria para validar nuestras suposiciones. Como científicos de datos o profesionales que ayudan a tomar decisiones, debemos ser conscientes de que un análisis incorrecto puede llevar a decisiones equivocadas, lo que resultaría en pérdida de tiempo y dinero. Por eso, es crucial que nuestras conclusiones estén bien fundamentadas, respaldadas por evidencia estadística.

La verdadera satisfacción llega cuando vemos los resultados de nuestro análisis reflejados en cambios efectivos dentro de la empresa, mejoras en la experiencia del cliente, y, en última instancia, un impacto positivo en las ventas y operaciones. ¡Es una sensación increíble haber sido parte de ese proceso!

Para ayudarte a desarrollar esta habilidad desarrollaremos en este artículo en Análisis de la personalidad de clientes de un supermercado, utilizaremos el Dataset de Kaggle Customer Personality Analysis: https://www.kaggle.com/datasets/imakash3011/customer-personality-analysis

En este análisis, exploraremos el comportamiento de los clientes de un supermercado con el objetivo de extraer información valiosa de los datos. Buscaremos responder las siguientes preguntas:

¿Existe alguna diferencia significativa en el gasto total por Educación?
¿Existe alguna diferencia significativa en el gasto total por Cantidad de hijos?
¿Existe alguna diferencia significativa en el gasto total por Estado Marital?

Si bien este análisis podría extenderse mucho más, nos centraremos en responder estas tres preguntas, ya que ofrecen un gran poder explicativo. A lo largo del artículo, te mostraremos cómo podemos abordar estas cuestiones y cómo, mediante el mismo enfoque, podríamos responder muchas más preguntas.

En este artículo exploraremos análisis estadísticos como el test Kolmogorov-Smirnov, la prueba de Levene, y cómo saber cuándo aplicar ANOVA o Kruskal-Wallis. Puede que estos nombres te suenen desconocidos, pero no te preocupes, los explicaré de manera sencilla para que los entiendas sin complicaciones.

A continuación, te mostraré el código en Python y los pasos a seguir para realizar estos análisis estadísticos de forma efectiva.

1. Primeros pasos

Importamos las librerías de Python necesarias.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import os
from scipy import stats
from scipy.stats import kstest
from scipy.stats import levene
import scikit_posthocs as sp

Ahora podemos optar por dos formas para cargar el archivo.csv, obtenemos directamente el archivo o podemos obtener el enlace de kaggle, justo en el botón de descargar.

#pip install kagglehub
import kagglehub

# Download latest version
path = kagglehub.dataset_download("imakash3011/customer-personality-analysis")

print("Path to dataset files:", path)

#Obtenemos el nombre del archivo
nombre_archivo = os.listdir(path)[0]
nombre_archivo

'marketing_campaign.csv'

#Cargamos el archivo en un DataFrame
df = pd.read_csv(path + '\\' + nombre_archivo,sep='\t')
df.head(2)

	ID	Year_Birth	Education	Marital_Status	Income	Kidhome	Teenhome	Dt_Customer	Recency	MntWines	MntFruits	MntMeatProducts	MntFishProducts	MntSweetProducts	MntGoldProds	NumDealsPurchases	NumWebPurchases	NumCatalogPurchases	NumStorePurchases	NumWebVisitsMonth	Z_CostContact	Z_Revenue	Response
0	5524	1957	Graduation	Single	58138.0	0	0	04-09-2012	58	635	88	546	172	88	88	3	8	10	4	7	3	11	1
1	2174	1954	Graduation	Single	46344.0	1	1	08-03-2014	38	11	1	6	2	1	6	2	1	1	2	5	3	11	0
2	4141	1965	Graduation	Together	71613.0	0	0	21-08-2013	26	426	49	127	111	21	42	1	8	2	10	4	3	11	0

Para tener una mejor noción del conjunto de datos que analizaremos te indicare el significado de cada columna.

Columnas:

Personas:
- ID: identificador único del cliente
- Year_Birth: año de nacimiento del cliente.
- Education: nivel de educación del cliente.
- Marital_Status: estado civil del cliente
- Income: ingresos anuales del hogar del cliente
- Kidhome: Número de niños en el hogar del cliente
- Teenhome: Número de adolescentes en el hogar del cliente
- Dt_Customer: Fecha de alta del cliente en la empresa
- Recency: número de días desde la última compra del cliente.
- Complain: 1 si el cliente se quejó en los últimos 2 años, 0 en caso contrario
Productos:
- MntWines: Cantidad gastada en vino en los últimos 2 años.
- MntFruits: Monto gastado en frutas en los últimos 2 años.
- MntMeatProducts: Cantidad gastada en carne en los últimos 2 años.
- MntFishProducts: cantidad gastada en pescado en los últimos 2 años.
- MntSweetProducts: cantidad gastada en dulces en los últimos 2 años.
- MntGoldProds: cantidad gastada en oro en los últimos 2 años.
Promoción:
- NumDealsPurchases: Número de compras realizadas con descuento.
- AcceptedCmp1: 1 si el cliente aceptó la oferta en la primera campaña, 0 en caso contrario.
- AcceptedCmp2: 1 si el cliente aceptó la oferta en la segunda campaña, 0 en caso contrario.
- AcceptedCmp3: 1 si el cliente aceptó la oferta en la tercera campaña, 0 en caso contrario.
- AcceptedCmp4: 1 si el cliente aceptó la oferta en la cuarta campaña, 0 en caso contrario.
- AcceptedCmp5: 1 si el cliente aceptó la oferta en la quinta campaña, 0 en caso contrario.
- Response: 1 si el cliente aceptó la oferta en la última campaña, 0 en caso contrario
Lugar:
- NumWebPurchases: Número de compras realizadas a través del sitio web de la empresa.
- NumCatalogPurchases: Número de compras realizadas mediante un catálogo.
- NumStorePurchases: Número de compras realizadas directamente en tiendas.
- NumWebVisitsMonth: Número de visitas al sitio web de la empresa en el último mes.

Sí, son muchas columnas, sin embargo aquí solo utilizaremos unas cuantas, para no extendernos mucho, de todas formas puedes aplicar los mismo pasos para las demás columnas.

Ahora, verificaremos que no tengamos datos nulos

df.isna().sum()

ID                      0
Year_Birth              0
Education               0
Marital_Status          0
Income                 24
Kidhome                 0
Teenhome                0
Dt_Customer             0
Recency                 0
MntWines                0
MntFruits               0
MntMeatProducts         0
MntFishProducts         0
MntSweetProducts        0
MntGoldProds            0
NumDealsPurchases       0
NumWebPurchases         0
NumCatalogPurchases     0
NumStorePurchases       0
NumWebVisitsMonth       0
AcceptedCmp3            0
AcceptedCmp4            0
AcceptedCmp5            0
AcceptedCmp1            0
AcceptedCmp2            0
Complain                0
Z_CostContact           0
Z_Revenue               0
Response                0
dtype: int64

Podemos notar que tenemos 24 datos nulos en la columna Income, sin embargo esta columna no será utilizada en este análisis por ende no haremos nada con ella, en caso que tu la quieras usar, deberás de verificar realizar una de estas dos opciones:

Imputar los datos faltantes si no representa más de 5% del total de datos(recomendación).
Eliminar los datos nulos.

2. Configurar el Dataset para el análisis

Nos quedaremos con las columnas que sean de nuestro interés, como educación, hijos, estado marital, cantidad de gasto por categoria de producto, entre otros.

#Nos quedamos con las columnas de interes
df_2 = df[['Education','Kidhome','Teenhome','Marital_Status','NumDealsPurchases','MntWines',
          'MntFruits','MntMeatProducts','MntFishProducts','MntSweetProducts','MntGoldProds']].copy()

Calculamos el gasto total sumando los gastos de todas las categorías de producto.

df_2['Total_Spend'] = df_2['MntWines'] + df_2['MntFruits'] + df_2['MntMeatProducts'] + df_2['MntFishProducts'] + df_2['MntSweetProducts'] + df_2['MntGoldProds']

Calculamos la cantidad de hijos de cada cliente, sumando la cantidad de hijos pequeños y adolescentes.

df_2['Children_Count'] = df_2['Kidhome'] + df_2['Teenhome']

Una vez hecho los cálculos, volvemos a reducir el tamaño de las columnas para quedarnos con aquellas de interés.

df_2 = df_2[['Education','Marital_Status','NumDealsPurchases','Total_Spend','Children_Count']]

Como recomendación deberíamos categorizar los valores de nuestra columna Education y Marital_Status, ¿Porqué? Estos siguen un orden, tenemos datos como PhD (Doctorado) que es más elevado con un Master (Maestría), esto nos proporcionará orden y mayor legibilidad a nuestro conjunto de datos.

2.1. Columna Education

df_2['Education'].unique()

array(['Graduation', 'PhD', 'Master', 'Basic', '2n Cycle'], dtype=object)

education_order = ['Basic', '2n Cycle', 'Graduation', 'Master', 'PhD']
df_2['Education'] = df_2['Education'].astype('category')
df_2['Education'] = df_2['Education'].cat.reorder_categories(
    new_categories=education_order,
    ordered=True
)

df_2['Education'].unique()

['Graduation', 'PhD', 'Master', 'Basic', '2n Cycle']
Categories (5, object): ['Basic' < '2n Cycle' < 'Graduation' < 'Master' < 'PhD']

2.2. Columna Marital_Status

Aquí juntaré algunos valores, ya que es conveniente para evitar valores que tengan significados similares, como 'Alone' y 'Single'.

marital_mapping = {
    'Single': 'Single',
    'Alone': 'Single',
    'Together': 'Together',
    'Married': 'Married',
    'Divorced': 'Divorced',
    'Widow': 'Widow',
    'YOLO': 'Others',
    'Absurd': 'Others'
}
df_2['Marital_Status'] = df_2['Marital_Status'].map(marital_mapping)

marital_order = ['Single','Together','Married', 'Divorced', 'Widow','Others']

df_2['Marital_Status'] = df_2['Marital_Status'].astype('category')
df_2['Marital_Status'] = df_2['Marital_Status'].cat.reorder_categories(
    new_categories=marital_order,
    ordered=True
)

3. Análisis Exploratorio de Datos (EDA)

3.1. Education

#Gráfico de Barras
plt.figure(figsize=(10,6))
sns.barplot(data=df_2,x='Education',y='Total_Spend',errorbar=None,palette='Blues')
plt.xlabel("Educación",size=14)
plt.ylabel("Gasto Total (Últimos 2 años)",size=14)
plt.title("Gasto Total (Últimos 2 años) por Nivel de Educación",size=16,color='green')
plt.grid(axis='y')
plt.show()

Con el gráfico de barras podemos notar una clara diferencia en el gasto total que tienen los clientes por nivel de educación, siendo Graduation, Master y PhD el grupo gasto similar, sin embargo no sabemos aún si esta diferencia es significativa.

#Diagrama de Cajas
sns.boxplot(data=df_2,x='Education',y='Total_Spend')
plt.xlabel("Educación",size=14)
plt.ylabel("Gasto Total (Últimos 2 años)",size=14)
plt.title("Gasto Total (Últimos 2 años) por Nivel de Educación",size=16,color='green')
plt.show()

Con el diagrama de cajas (Boxplot) podemos apreciar aún más las diferencias entre clases, no solo viendo el gasto total, si no el gasto total medio de todos los niveles de educación, pudiendo notar incluso pequeñas diferencia entre los grupos con más gasto.

Por último veremos el comportamiento de nuestros gastos totales en cada nivel de educación.

# Número de subgráficos necesarios
n = len(education_order)

# Crear los subgráficos
fig, axes = plt.subplots(nrows=1, ncols=n, figsize=(15, 6))

# Si solo hay un subgráfico, axes no es un arreglo, entonces lo convertimos a lista
if n == 1:
    axes = [axes]

colors = ['skyblue','orange','green','purple','blue']
# Iterar sobre los niveles educativos y crear el histograma
for i, education_level in enumerate(education_order):
    sns.histplot(df_2[df_2['Education'] == education_level]['Total_Spend'], kde=True, ax=axes[i],color=colors[i])
    axes[i].set_title(f'{education_level}')
    axes[i].set_xlabel('Gasto Total')
    axes[i].set_ylabel('Frecuencia')

# Ajustar el layout
plt.tight_layout()
plt.show()

El histograma nos es de mucha ayuda, con el podemos darnos cuenta de que tenemos sesgo en nuestro datos, teniendo una mayor cantidad de datos en compras bajas, lo cual puede ser lógico dependiendo de la frecuencia de compra de cada cliente.

3.2. Marital Status

Con la columna de Marital_Status podemos observar un diferencia más leve entre clases, sin embargo el comportamiento de los datos sigue siendo el mismo, teniendo datos sesgados.

4. Estadística

¿Es realmente significativa esta diferencia?

Si bien observamos una diferencia en el gasto total por grupos de nivel de educación o por estado marital, ¿Es realmente significativa? Este es un punto crucial a considerar. Aunque podamos observar una diferencia visible, esto no garantiza que sea estadísticamente significativa. En el análisis de datos, es fundamental no solo identificar diferencias, sino asegurarse de que esas diferencias sean relevantes y no producto de la casualidad.

Debemos tener especial cuidado con este aspecto, ya que las decisiones que tome la empresa basadas en nuestro análisis pueden involucrar cambios que afecten recursos importantes como tiempo y dinero. Un análisis estadístico adecuado puede ayudar a asegurar que las decisiones sean tomadas con un respaldo sólido, minimizando riesgos y maximizando el impacto positivo.

4.1. Normalidad

Antes de realizar cualquier prueba de varianza, como ANOVA o Kruskal-Wallis, es fundamental verificar si los datos siguen una distribución normal. Dependiendo de los resultados de esta prueba de normalidad, podremos decidir cuál de las dos pruebas utilizar: si los datos son normales, se podrá optar por ANOVA; en caso contrario, utilizaremos Kruskal-Wallis.

La prueba de normalidad la realizaremos con Kolmogorov-Smirnov, ya que nuestro conjunto de datos tiene más de 50 muestras. Esta prueba es adecuada para tamaños de muestra grandes y nos permitirá determinar si los datos siguen una distribución normal, lo que es crucial para decidir qué prueba estadística aplicar posteriormente.

# Realizamos Kolmogorov-Smirnov para cada grupo de Educación
for edu in education_order:
    group_data = df_2[df_2['Education'] == edu]['Total_Spend']
    ks_stat, ks_p_value = kstest(group_data, 'norm')
    print(f"KS para {edu} (Total_Spend): estadístico = {ks_stat}, p-value = {ks_p_value}")

KS para Basic (Total_Spend): estadístico = 1.0, p-value = 0.0
KS para 2n Cycle (Total_Spend): estadístico = 1.0, p-value = 0.0
KS para Graduation (Total_Spend): estadístico = 0.9999997133484281, p-value = 0.0
KS para Master (Total_Spend): estadístico = 1.0, p-value = 0.0
KS para PhD (Total_Spend): estadístico = 0.9999999999999993, p-value = 0.0

Los resultados de la prueba de Kolmogorov-Smirnov (KS) indican que todas las categorías de Education tienen un p-value de 0.0, lo cual significa que rechazamos la hipótesis nula de normalidad. Es decir, los datos en todas las categorías no siguen una distribución normal.

4.2. Homocedasticidad

Luego de la prueba de normalidad, otro análisis importante es la prueba de Levene, que nos permite comprobar si nuestros datos tienen varianza homogénea o heterogénea. Este paso es crucial porque, dependiendo de los resultados, podremos decidir si aplicar pruebas como ANOVA (que asume homogeneidad de varianzas) o Kruskal-Wallis (que no requiere esta condición).

# Realizamos la prueba de Levene para homocedasticidad
edu_groups = [df_2[df_2['Education'] == edu]['Total_Spend'] for edu in education_order]
levene_stat, levene_p_value = levene(*edu_groups)

print(f"Prueba de Levene: estadístico = {levene_stat}, p-value = {levene_p_value}")

Prueba de Levene: estadístico = 18.40361074007475, p-value = 6.8598908557018694e-15

El p-value de la prueba de Levene es extremadamente bajo (6.86×10 −15 ), lo que nos lleva a rechazar la hipótesis nula de homocedasticidad. Esto indica que las varianzas no son homogéneas entre los grupos de Education.

4.3. ¿Que prueba Elegir?

Para explicarlo de manera sencilla la elección de una prueba u otra, presentaré a continuación unos cuadros de resumen.

4.4. Prueba Kruskal-Wallis

¿Por qué usar Kruskal-Wallis?

No requiere normalidad: A diferencia de ANOVA, Kruskal-Wallis es una prueba no paramétrica, lo que significa que no requiere que los datos sigan una distribución normal.

No requiere homocedasticidad: También es menos sensible a la suposición de homocedasticidad (igualdad de varianzas entre grupos), lo cual lo hace robusto en situaciones donde los grupos tienen varianzas diferentes.

Cómo interpretar la prueba Kruskal-Wallis:

Hipótesis nula (H₀): No hay diferencias significativas en las medianas de los grupos (en este caso, los diferentes niveles de educación).
Hipótesis alternativa (H₁): Hay al menos una diferencia significativa en las medianas de los grupos.

education_order

['Basic', '2n Cycle', 'Graduation', 'Master', 'PhD']

group1 = df_2[df_2['Education'] == education_order[0]]['Total_Spend']
group2 = df_2[df_2['Education'] == education_order[1]]['Total_Spend']
group3 = df_2[df_2['Education'] == education_order[2]]['Total_Spend']
group4 = df_2[df_2['Education'] == education_order[3]]['Total_Spend']
group5 = df_2[df_2['Education'] == education_order[4]]['Total_Spend']


stat, p_value = stats.kruskal(group1, group2, group3, group4, group5)
print(f'Estadístico de Kruskal-Wallis: {stat}')
print(f'Valor p: {p_value}')

if p_value < 0.05:
    print("Hay diferencias significativas entre los grupos.")
else:
    print("No hay diferencias significativas entre los grupos.")

Estadístico de Kruskal-Wallis: 71.01853119952575
Valor p: 1.3833274361973288e-14
Hay diferencias significativas entre los grupos.

Estadístico de Kruskal-Wallis: El valor 71.01853119952575 es el estadístico de la prueba, que refleja la magnitud de la diferencia entre los grupos. Un valor más alto generalmente indica que las diferencias entre los grupos son mayores.
Valor p: El valor 1.38e-14 es muy pequeño (mucho menor que el umbral de significancia común de 0.05), lo que significa que podemos rechazar la hipótesis nula de que todos los grupos tienen el mismo gasto total. En otras palabras, hay evidencia suficiente para afirmar que el gasto total difiere significativamente entre los niveles de educación.

4.5. Prueba Dunn

Bien, ahora que sabemos que realmente existe una diferencia significativa entre los grupos, ¿Cómo podemos identificar en qué grupos específicos se encuentran esas diferencias?

Para ello, utilizaremos la prueba posthoc Dunn, que es una técnica estadística que nos permite realizar comparaciones múltiples entre los grupos. Esta prueba nos ayuda a identificar qué pares de grupos tienen diferencias significativas, ajustando el valor p para controlar el error tipo I (falsos positivos), lo que la hace una herramienta confiable para análisis post-hoc.

# Crear una lista de grupos para la prueba de Dunn
groups = [group1, group2, group3, group4, group5]

# Aplicar la prueba de Dunn para comparar todos los pares de grupos
dunn_result = sp.posthoc_dunn(groups, p_adjust='bonferroni')

# Mostrar los resultados
dunn_result.round(6) #Se redondeo para evitar valores con muchos decimales

Se usa Bonferroni en Dunn para reducir la probabilidad de cometer un error tipo I al realizar comparaciones múltiples, lo que asegura que las diferencias significativas encontradas sean realmente confiables y no fruto del azar.

Los valores p son los resultados de las comparaciones entre cada par de grupos. Si el valor p es menor que 0.05, indica que hay una diferencia significativa entre esos dos grupos en cuanto al gasto total. Si es mayor que 0.05, no hay diferencia significativa.

Resumen de las diferencias significativas:

Entre los grupos 1 y 2: Hay una diferencia significativa.
Entre los grupos 1 y 3: Hay una diferencia significativa.
Entre los grupos 1 y 4: Hay una diferencia significativa.
Entre los grupos 1 y 5: Hay una diferencia significativa.
Entre los grupos 2 y 5: Hay una diferencia significativa.

No hay diferencias significativas entre:

Grupos 2 y 3
Grupos 2 y 4
Grupos 3 y 4
Grupos 3 y 5
Grupos 4 y 5

4.6. Analizar los resultados

¿Que podemos concluir de esto?

El grupo 1 (Basic) tiene diferencias significativas en cuanto al gasto total con casi todos los demás grupos.

Los grupos 3 (Graduation), 4 (Master) y 5 (PhD) no presentan diferencias significativas entre ellos, lo que sugiere que el nivel educativo superior no influye de manera significativa en el gasto total entre estos grupos.

En términos prácticos:

Grupo 1 (Basic):

Este grupo tiene un gasto total significativamente diferente del resto. Las personas con nivel educativo "Basic" (educación básica) presentan un comportamiento de gasto distinto al de los demás niveles educativos.
Esto podría ser clave para diseñar campañas específicas para este grupo, ya que su comportamiento de gasto es único.

Grupos 3, 4 y 5 (Graduation, Master, PhD):

Estos niveles educativos más altos muestran patrones de gasto similares entre sí, sin diferencias estadísticamente significativas.
Se podría considerar agruparlos para campañas de marketing dirigidas a clientes con nivel educativo superior, optimizando así esfuerzos y recursos al tratarlos como un segmento homogéneo.

Este análisis no solo valida la importancia de segmentar adecuadamente a los clientes, sino que también destaca cómo usar la estadística para respaldar decisiones que maximizan la efectividad de las estrategias de marketing.

Conclusión para Campañas de Marketing

A partir de los resultados del análisis estadístico, se identifican dos segmentos clave basados en el nivel educativo y su comportamiento de gasto:

Segmento 1: Educación Básica (Grupo 1 - Basic)

Perfil: Este grupo tiene un patrón de gasto significativamente diferente respecto a los demás niveles educativos. Esto puede deberse a factores como ingresos más bajos, necesidades específicas o comportamientos únicos en sus compras.
Recomendación:
- Diseñar campañas personalizadas, ajustadas a sus necesidades y posibilidades económicas.
- Enfocar promociones en productos accesibles o de alto interés para este segmento.
- Realizar estudios adicionales para identificar qué impulsa sus diferencias de gasto.

Segmento 2: Educación Superior (Grupos 3 - Graduation, 4 - Master, 5 - PhD)

Perfil: Las personas con educación superior (Graduation, Master, PhD) tienen comportamientos de gasto muy similares, sin diferencias significativas entre estos grupos.
Recomendación:
- Unificar esfuerzos con campañas dirigidas al segmento completo de educación superior.
- Aprovechar estrategias que resalten calidad, exclusividad o productos premium, ya que podrían alinearse con sus expectativas.
- Optimizar recursos agrupando a estos niveles educativos en un solo target publicitario.

Por si te preguntas, Ahora que sabemos que tenemos diferencias significativas estadísticamente, y que además sabemos que grupos son, ¿Cómo sabremos cual es la diferencia?

Muy fácil, basta con agrupar por educación y ver una estadística como el gasto medio por nivel de educación.

gasto_promedio  = df_2.groupby('Education')['Total_Spend'].mean().reset_index()
gasto_promedio

El gasto promedio es una métrica crucial, ya que elimina el efecto del tamaño del grupo, permitiéndonos analizar el comportamiento de gasto a nivel individual. Esto es especialmente útil para identificar tendencias claras y diseñar estrategias de marketing dirigidas de manera más precisa.

¿Notas ahora el poder de la estadística? Es realmente fascinante lo que podemos lograr con una comprensión básica de sus herramientas. Nos permite tomar decisiones informadas y confiables, respaldadas por datos sólidos, lo que a su vez puede llevar a resultados más efectivos y un mayor impacto en nuestras estrategias.

Con este enfoque basado en análisis estadísticos, podemos mejorar la segmentación, personalizar campañas y maximizar el retorno de inversión de manera medible. La estadística no solo se trata de números; es un motor para tomar decisiones estratégicas con confianza.

5. ¿Con ganas de más? Analicemos dos variables más (Marital_Status y Cantidad de hijos).

5.1. Marital_Status

#Prueba de normalidad para Marital Status
for status in marital_order:
    group_data = df_2[df_2['Marital_Status'] == status]['Total_Spend']
    ks_stat, ks_p_value = kstest(group_data, 'norm')
    print(f"KS para {status} (Total_Spend): estadístico = {ks_stat}, p-value = {ks_p_value}")

KS para Single (Total_Spend): estadístico = 0.9999997133484281, p-value = 0.0
KS para Together (Total_Spend): estadístico = 0.9999999999999993, p-value = 0.0
KS para Married (Total_Spend): estadístico = 0.9999999999999993, p-value = 0.0
KS para Divorced (Total_Spend): estadístico = 0.9999999990134123, p-value = 0.0
KS para Widow (Total_Spend): estadístico = 1.0, p-value = 0.0
KS para Others (Total_Spend): estadístico = 1.0, p-value = 0.0

RESULTADO: NO PRESENTA NORMALIDAD

# Realizamos la prueba de Levene para homocedasticidad
status_group = [df_2[df_2['Marital_Status'] == status]['Total_Spend'] for status in marital_order]
levene_stat, levene_p_value = levene(*status_group)

print(f"Prueba de Levene: estadístico = {levene_stat}, p-value = {levene_p_value}")

Prueba de Levene: estadístico = 0.3238202814700971, p-value = 0.8988688535412217

En este caso sí tenemos Homocedasticidad, debido a que el p-value es mucho más mayor que 0.05.

De todas formas al no tener normalidad debemos de usar Kruskall-Wallis.

#Kruskall-Wallis para cada categoria de Marital_Status
group1 = df_2[df_2['Marital_Status'] == marital_order[0]]['Total_Spend']
group2 = df_2[df_2['Marital_Status'] == marital_order[1]]['Total_Spend']
group3 = df_2[df_2['Marital_Status'] == marital_order[2]]['Total_Spend']
group4 = df_2[df_2['Marital_Status'] == marital_order[3]]['Total_Spend']
group5 = df_2[df_2['Marital_Status'] == marital_order[4]]['Total_Spend']
group6 = df_2[df_2['Marital_Status'] == marital_order[5]]['Total_Spend']


stat, p_value = stats.kruskal(group1, group2, group3, group4, group5, group6)
print(f'Estadístico de Kruskal-Wallis: {stat}')
print(f'Valor p: {p_value}')

if p_value < 0.05:
    print("Hay diferencias significativas entre los grupos.")
else:
    print("No hay diferencias significativas entre los grupos.")

Estadístico de Kruskal-Wallis: 7.370315136436014
Valor p: 0.1945237547896254
No hay diferencias significativas entre los grupos.

Al observar los resultados del análisis mediante Kruskal-Wallis por Estado Marital, concluimos que no existen diferencias significativas en el gasto total entre los distintos grupos. Esto significa que el estado civil (Marital_Status) no tiene un impacto estadísticamente relevante en el comportamiento de gasto de las personas, según los datos analizados.

En otras palabras, las diferencias de gasto entre las categorías de estado civil (incluso después de una posible recategorización) no son lo suficientemente marcadas como para considerarse significativas. Por lo tanto, desde una perspectiva estadística, el estado civil no es un factor determinante a la hora de segmentar o analizar el comportamiento de gasto de los clientes.

5.2. Cantidad de hijos

Normalidad

# Crear una nueva columna 'Children_Category' categorizando el número de hijos
df_2['Children_Category'] = df_2['Children_Count'].astype(str)
cantidad_hijos = df_2['Children_Category'].unique().tolist()

#Prueba de Kolmogorov (Normalidad)
for hijos in cantidad_hijos:
    group_data = df_2[df_2['Children_Category'] == hijos]['Total_Spend']
    ks_stat, ks_p_value = kstest(group_data, 'norm')
    print(f"KS para {edu} (Total_Spend): estadístico = {ks_stat}, p-value = {ks_p_value}")

KS para PhD (Total_Spend): estadístico = 0.9999999990134123, p-value = 0.0
KS para PhD (Total_Spend): estadístico = 1.0, p-value = 0.0
KS para PhD (Total_Spend): estadístico = 0.9999997133484281, p-value = 0.0
KS para PhD (Total_Spend): estadístico = 0.9999999999999993, p-value = 0.0

RESULTADOS: NO PRESENTA NORMALIDAD

Homocedasticidad

# Realizamos la prueba de Levene para homocedasticidad (Hijos)
status_group = [df_2[df_2['Children_Category'] == hijos]['Total_Spend'] for hijos in cantidad_hijos]
levene_stat, levene_p_value = levene(*status_group)

print(f"Prueba de Levene: estadístico = {levene_stat}, p-value = {levene_p_value}")

Prueba de Levene: estadístico = 82.76650024401404, p-value = 8.910410679935122e-51

PRESENTA HETEROCEDASTICIDAD

Kruskal-Wallis

# Crear los grupos por el número de hijos
group0 = df_2[df_2['Children_Category'] == cantidad_hijos[0]]['Total_Spend']
group1 = df_2[df_2['Children_Category'] == cantidad_hijos[1]]['Total_Spend']
group2 = df_2[df_2['Children_Category'] == cantidad_hijos[2]]['Total_Spend']
group3 = df_2[df_2['Children_Category'] == cantidad_hijos[3]]['Total_Spend']

# Realizar la prueba de Kruskal-Wallis
stat, p_value = stats.kruskal(group0, group1, group2, group3)

# Imprimir los resultados
print(f'Estadístico de Kruskal-Wallis: {stat}')
print(f'Valor p: {p_value}')

if p_value < 0.05:
    print("Hay diferencias significativas entre los grupos.")
else:
    print("No hay diferencias significativas entre los grupos.")

Estadístico de Kruskal-Wallis: 548.3466590214872
Valor p: 1.5859643569958945e-118
Hay diferencias significativas entre los grupos.

Estadístico de Kruskal-Wallis: 548.35 (es un valor alto, lo que indica una diferencia considerable entre los grupos).
Valor p: 1.59e-118, que es mucho menor que 0.05, lo que confirma que hay diferencias significativas entre los grupos con diferentes números de hijos.

Prueba Dunn

# Crear una lista de grupos para la prueba de Dunn
groups = [group0, group1, group2, group3]

# Aplicar la prueba de Dunn para comparar todos los pares de grupos
dunn_result = sp.posthoc_dunn(groups, p_adjust='bonferroni')
#dunn_result = sp.posthoc_dunn(df_2, val_col='Total_Spend', group_col='Children_Category', p_adjust='bonferroni')

# Mostrar los resultados
dunn_result.round(5) #Se redondeo para evitar valores con muchos decimales

Los grupos con 1 hijo y 3 hijos no tienen diferencias significativas en su gasto total (p = 1.0), lo que sugiere que podrían ser agrupados para ciertas campañas o promociones, ya que su comportamiento de gasto es similar.

En todos los demás casos, los grupos tienen diferencias significativas en su gasto total, lo que indica que el número de hijos tiene un impacto considerable en el comportamiento de gasto.

Podemos segmentar las personas en función del número de hijos, creando campañas específicas para aquellos con 1 y 3 hijos, y otras campañas para los grupos con 0, 2 y 3 hijos según su gasto y necesidades específicas.

Veamos el gasto promedio por cantidad de hijos.

# Calcular el gasto promedio por número de hijos
gasto_promedio_hijos = df_2.groupby('Children_Category')['Total_Spend'].mean().reset_index()

# Mostrar el gasto promedio por grupo
gasto_promedio_hijos

Conlusión para la segmentación

Segmentación con comportamiento de gasto similares:
- Los clientes con 1 o 3 hijos **presentan patrones de gasto muy similares. Esto sugiere que **una misma campaña podría ser efectiva para ambos grupos, optimizando recursos y estrategias de marketing.
Segmentos con comportamiento de gasto diferentes:
- Los clientes con 0, 2 y 3 hijos tienen patrones de gasto significativamente distintos entre sí. Por lo tanto, es recomendable mantener campañas separadas para estos segmentos, diseñando promociones específicas que respondan a las características únicas de cada grupo..

Nota clave:
Aunque los datos de gasto promedio entre los clientes con 2 y 3 hijos podrían parecer similares a simple vista, la estadística nos confirma que sus diferencias son significativas. Este hallazgo resalta la importancia de utilizar herramientas estadísticas para tomar decisiones informadas y diseñar estrategias basadas en evidencia sólida en lugar de suposiciones visuales o intuitivas.

La estadística no solo es una herramienta técnica, sino también un aliado estratégico para maximizar el impacto de las campañas de marketing y aumentar la rentabilidad.

6. Conclusiones Generales

Importancia de la estadística:

Este análisis resalta la importancia de instrumentos estadísticos, tales como Kolmogorov-Smirnov, Levene, Kruskal-Wallis y la prueba post-hoc de Dunn, para corroborar variaciones importantes en los datos. Nos brindan la posibilidad de superar las percepciones visuales y asegurar que nuestras decisiones se fundamenten en pruebas fiables.

Segmentación efectiva basada en patrones de gasto:
- El grado de educación tiene un impacto considerable en el gasto total. Los clientes con educación básica muestran una conducta de consumo diferente a la de los con educación superior, lo que facilita la creación de campañas orientadas a cada sector.
- El análisis por número de hijos mostró diferencias notables entre los grupos. Es factible reunir a los clientes con 1 o 3 hijos, mientras que los demás grupos deben ser tratados de manera individual.
- El estado de matrimonio no evidenció variaciones importantes en el gasto, lo que sugiere que este elemento no es crucial para la segmentación en esta situación.
Decisiones basadas en evidencia:

Con este enfoque estadístico, se pueden evitar errores al interpretar patrones en los datos, lo que garantiza que los recursos y estrategias se inviertan de manera más efectiva.

7. Recomendaciones finales

Campañas dirigidas según nivel educativo:
- Personalizar estrategias para el grupo con educación básica.
- Unificar campañas para clientes con educación superior (Graduation, Master, PhD).
Segmentar según cantidad de hijos:
- Agrupar a los clientes con 1 o 3 hijos en una campaña conjunta.
- Diseñar estrategias separadas para los grupos con 0 y 2 hijos.
Monitorear y ajustar:
- Analizar el rendimiento de las campañas para realizar mejoras continuas.
Explorar más variables:
- Ampliar el análisis con otros factores como ingresos o antigüedad del cliente para identificar nuevas oportunidades de segmentación.

8. Conclusiones Finales

La estadística no solo es una herramienta poderosa para tomar decisiones informadas, sino que también es un proceso continuo. En marketing, los datos y las tendencias evolucionan constantemente, lo que significa que siempre hay nuevas oportunidades para segmentar mejor a los clientes y adaptar las estrategias a las necesidades cambiantes.

Recuerda que la clave está en no solo realizar un análisis una vez, sino en realizarlo de manera iterativa, ajustando las estrategias a medida que los datos se actualizan y mejoran. Al hacerlo, puedes mantener tu enfoque de marketing y otros más, siempre alineado con lo que realmente importa para tus clientes, lo que te permitirá tomar decisiones aún más confiables y efectivas.

La estadística es tu aliada para mejorar los resultados: úsala de manera dinámica y continua para tomar decisiones cada vez más confiables y efectivas.

Si crees que se puedan incluir mejoras o alguna parte del código no te funciona, hazmelo saber, te ayudaré con gusto :).

Si los datos te confunden, recuerda: todos somos normales… hasta que aparece un outlier.

Edgar Cajusol - Data Scientist - Creando impacto un modelo a la vez.
https://www.linkedin.com/in/edgarcajusol/

El Poder de lo Simple: Regresión Lineal para Predecir Precios de Casas

Edgar Cajusol — Sun, 24 Nov 2024 22:20:20 +0000

El sector inmobiliario es uno de los más diversos y complejos del mundo. Entender cómo se determinan los precios de las propiedades puede ser un desafío, ya que depende de múltiples factores como el tamaño de la casa, el número de habitaciones, la ubicación, el tamaño del garaje (si tiene uno), entre otros. ¿Pero serán realmente todos estos factores determinantes?

En este artículo, exploraremos un modelo simple pero poderoso, la Regresión Lineal, para ayudarnos no solo a predecir los precios de las casas, sino también a identificar si algunas de las variables mencionadas realmente son importantes o influyentes en el modelo.

A lo largo del artículo, aprenderás:

Como preparar los datos inmobiliarios para el análisis.
Los fundamentos de la regresión lineal, incluyendo los supuestos que deben cumplirse (normalidad, homocedasticidad, entre otros) para obtener resultados confiables.
La implementación práctica del modelo en Python.
La interpretación de resultados, las métricas clave y los próximos pasos a considerar.

Para entrenar a nuestro modelo usaremos un dataset obtenido en kaggle, en el cual buscaremos predecir el precio de las casas en Bangladesh.

link del dataset: https://www.kaggle.com/datasets/durjoychandrapaul/house-price-bangladesh

En este dataset podemos encontrar columnas como:

Title: El titulo de la oferta de venta de la propiedad.
Bedrooms: Representa la cantidad de habitaciones de la propiedad.
Bathrooms: Cantidad de baños de la propiedad.
Floor_no: El número de piso en el que se encuentra la propiedad.
Occupancy_status: Indica si la propiedad está desocupada u ocupada.
Floor_area: La superficie total construida de la propiedad en pies cuadrados.
City: La ciudad donde se encuentra la propiedad.
Price_in_taka: Precio de la propiedad en Taka bangladesí.
Location: La ubicación o dirección específica dentro de la ciudad.

1. Importación de las librerías y carga de datos.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import statsmodels.api as sm

df = pd.read_csv('house_price_bd.csv')
df.head(2)

Title	Bedrooms	Bathrooms	Floor_no	Occupancy_status	Floor_area	City	Price_in_taka	Location
We Are Offering You A Very Spacious 1960 Sq Ft Flat For Sale In Gulshan 1	3.0	4.0	3	vacant	1960.0	dhaka	৳39,000,000	Gulshan 1, Gulshan
Valuable 1705 Square Feet Apartment Is Ready To Sale In Kalabagan	3.0	3.0	1	vacant	1705.0	dhaka	৳16,900,000	Lake Circus Road, Kalabagan

1.2. Limpieza de datos

Que tal si luego observamos el tipo de datos que tenemos para corroborar que todo esté en orden.

df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3865 entries, 0 to 3864
Data columns (total 9 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   Title             3865 non-null   object 
 1   Bedrooms          2864 non-null   float64
 2   Bathrooms         2864 non-null   float64
 3   Floor_no          3181 non-null   object 
 4   Occupancy_status  3766 non-null   object 
 5   Floor_area        3766 non-null   float64
 6   City              3865 non-null   object 
 7   Price_in_taka     3865 non-null   object 
 8   Location          3859 non-null   object 
dtypes: float64(3), object(6)
memory usage: 271.9+ KB

Lo que podemos notar:

Bedrooms y Bathrooms son tipo float (decimal). Aunque esto no debería afectar el rendimiento del modelo, es incorrecto, ya que no tiene sentido tener valores decimales en estas columnas, como "2.4 baños", ¿verdad? Lo correcto sería convertir ambas columnas a tipo int (entero).
Floor_no y Price_in_taka son de tipo object, lo cual es un error. El número de piso debería ser un valor entero, por lo que es necesario convertir esta columna a tipo int. En cuanto a la columna Price_in_taka, se ha considerado un object debido a la presencia de caracteres especiales, como el símbolo "৳". Para corregir esto, debemos eliminar dicho símbolo y luego cambiar el tipo de ambas columnas a su formato adecuado.

Ojo aquí:

df['Bedrooms'] = df['Bedrooms'].astype(int)
df['Bathrooms'] = df['Bathrooms'].astype(int)
df['Floor_no'] = df['Floor_no'].astype(int)

ValueError: invalid literal for int() with base 10: '8th'

Al intentar convertir las columnas Bedrooms, Bathrooms y Floor_no a tipo int, nos encontramos con un error. Este ValueError ocurre porque algunas filas contienen valores no numéricos, como '8th' en lugar de un valor numérico válido. Este error se presenta cuando intentamos convertir valores no numéricos o NaN a tipo entero (int), ya que el tipo int no puede manejar estos valores faltantes o textos. Por otro lado, float sí permite NaN como valor y es por eso que las columnas tenían este tipo de datos inicialmente.

De hecho, encontramos indicadores de valores faltantes antes de llegar a este punto, lo que nos ayudó a identificar el origen del error.

#Limpiar el simbolo en el Precio
df['Price_in_taka'] = df['Price_in_taka'].str.replace(r'৳','')
df['Price_in_taka'] = df['Price_in_taka'].str.replace(r',','')
df['Price_in_taka'] = df['Price_in_taka'].astype(float)

¿Porque convetí la columna Price_in_taka a float y no int?

Decidí convertir la columna de precio a float en lugar de int por varias razones. Inicialmente, la columna Price_in_taka estaba de tipo object, lo que indicaba que contenía valores no numéricos o con caracteres no válidos, como el símbolo "৳". Aunque el precio podría ser un valor entero, no podemos estar seguros de que todos los valores estén libres de decimales.

Si hubiésemos elegido convertir esta columna a int directamente, podríamos haber perdido la información de decimales en caso de que existieran, lo que podría sesgar nuestros datos. Además, el tipo float permite manejar valores decimales y, al mismo tiempo, preserva la posibilidad de representar números enteros. Así evitamos cualquier posible distorsión en el análisis.

El siguiente paso es opcional, lo que haré será convertir la moneda a dólares estadounidenses para una compresión mejor del columna precio.

#Transformar de Taka Bandaglesí a dolares
df['Price_in_taka'] = df['Price_in_taka']*0.0084
df.rename(columns={'Price_in_taka':'Price_in_dolars'},inplace=True)

Ahora sí, revisemos la cantidad de nulos que sabemos que existen.

df.isna().sum()

Title                  0
Bedrooms            1001
Bathrooms           1001
Floor_no             684
Occupancy_status      99
Floor_area            99
City                   0
Price_in_dolars        0
Location               6
dtype: int64

#Cantidad total de datos
len(df)
3865

La mayor cantidad de filas nulas que tenemos son alrededor de 1001 filas de un total de 3865 filas en el conjunto de datos. El porcentaje que representan se calcula de la siguiente manera:

Este porcentaje representa aproximadamente el 26% del total de los datos, lo que supera el umbral recomendado de un 5% para la imputación de datos. Con esto en mente, tenemos dos opciones:

Imputar los datos (aunque esto podría incluir valores erróneos).
Eliminar las filas con valores nulos, ya que contamos con una cantidad suficiente de datos.

Riesgos de imputar datos:

Imputar datos puede introducir sesgos si los valores imputados no representan adecuadamente la distribución original, distorsionando las relaciones entre las variables. Además, si los datos faltantes siguen un patrón específico, la imputación podría reforzar ese sesgo y afectar la precisión del modelo. Aunque mantener más datos puede ser útil, la imputación también puede aumentar la varianza del modelo si los valores imputados son muy diferentes de los reales.

#Observando los datos nulos
df[df['Bedrooms'].isna()].head(3)

	Title	Bedrooms	Bathrooms	Floor_no	Occupancy_status	Floor_area	City	Price_in_taka	Location
22	Large 5000 Sq Ft Commercial Space For Sale In Free School Street Road, Kathalbagan	NaN	NaN	9	vacant	5000.0	dhaka	110000000.0	Free School Street, Kathalbagan
40	A Commercial Building Is Up For Sale Which Is Located In Mirpur Nearby Mirpur Adhunik Hospital	NaN	NaN	6	vacant	16000.0	dhaka	120000000.0	Section 12, Mirpur
45	2.75 Katha Residential Plot For Sale In Mirpur-11	NaN	NaN	NaN	vacant	1980.0	dhaka	18000000.0	Section 11, Mirpur

Al observar algunos datos nulos, podemos notar que puede haber coincidencias entre las columnas, es decir, que tanto Bedrooms como Bathrooms estén vacíos al mismo tiempo. Esto podría indicar que la información de estas propiedades no fue registrada correctamente, o bien que se decidió no incluirla desde el principio, tal vez porque no era relevante para el análisis inicial. En cualquier caso, es importante identificar patrones en los datos faltantes para tomar decisiones informadas sobre cómo manejarlos.

Tomaré la opción de eliminar los datos nulos, debido a que imputar podría introducir error en mi conjunto de datos.

df_null = df.copy()
df.dropna(subset=['Bedrooms','Bathrooms','Floor_no'],inplace=True)
df.reset_index(drop=True,inplace=True)

print("La longitud del dataframe con datos nulos es: ",len(df_null))
print("La longitud eliminando datos nulos es: ",len(df))
print("Se han eliminado :", len(df_null) - len(df), "filas")

La longitud del dataframe con datos nulos es:  3865
La longitud eliminando datos nulos es:  2832
Se han eliminado : 1033 filas

Despues de eliminar nos hemos quedado con 2832 filas para entrenar a nuestro modelo.

Volvemos a ver los datos nulos.

df.isna().sum()

Title               0
Bedrooms            0
Bathrooms           0
Floor_no            0
Occupancy_status    0
Floor_area          0
City                0
Price_in_dolars     0
Location            1
dtype: int64

Vemos que aún tenemos un dato nulo en la columna Location, pero dado que no utilizaré esta variable en el análisis, no es necesario eliminar la fila.

Para mayor comodidad visual, decidí convertir la columna de precio a miles de unidades dividiéndola entre 1000. Esto facilita la interpretación de los valores y mejora la legibilidad de los datos.

df['Price_in_dolars'] = df['Price_in_dolars']/1000
df.rename(columns={'Price_in_dolars':'Price_$_k'},inplace=True)

No olvidemos convetir el tipo de variable de las columnas Bedrooms, Bathrooms y Floor_no.

Como Floor_no posee caracteres especiales deberíamos eliminarlos primero y extraer solamente el carácter numérico.

df['Floor_no'] = df['Floor_no'].astype(str).str.extract('(\d+)')
df['Floor_no'] = pd.to_numeric(df['Floor_no'], errors='coerce')

La expresión regular (\d+) extrae solo los dígitos (números) de cada valor. Si el valor contiene texto o símbolos no numéricos, solo se extraerán los números. Luego coerce convierte los valores extraídos a tipo numérico , si no logra hacerlo le colocará NaN.

df['Bedrooms'] = df['Bedrooms'].astype(int)
df['Bathrooms'] = df['Bathrooms'].astype(int)

Finalmente convertiremos a tipo int las otras dos columnas y tendríamos todo correctamente hecho.

2. Análisis Exploratorio de Datos (EDA)

En muchos problemas de predicción, un modelo lineal puede ser una herramienta poderosa. El objetivo de este artículo es aplicar la regresión lineal simple para predecir el precio de propiedades basándonos en el área del piso y el número de dormitorios. Utilizaremos un diagrama de dispersión (scatterplot) para visualizar si nuestros datos siguen una tendencia lineal, que es uno de los supuestos fundamentales para aplicar regresión lineal.

2.1. Normalidad

#GRAFICO POR DORMITORIOS
sns.scatterplot(x='Bedrooms',y='Price_$_k',data=df)
plt.title('Dormitorios vs Precios en ($)', fontsize=16)
plt.xlabel('Dormitorios')
plt.ylabel('Precio ($) en miles')
plt.show()

En el gráfico anterior, observamos que los datos no presentan un comportamiento lineal evidente entre el número de dormitorios y el precio. Esto sugiere que no se cumple el supuesto de linealidad, uno de los principios clave para la regresión lineal. Este patrón indica que otras variables podrían estar influyendo más significativamente en los precios.

2.2. Homocedasticidad

#Grafico por Área
sns.scatterplot(x='Floor_area',y='Price_$_k',data=df)
plt.title('Area del piso vs Precios en ($) en miles', fontsize=16)
plt.xlabel('Area del piso')
plt.ylabel('Precio ($) en miles')
plt.show()
#Regla de Homecedasticidad violada, conjunto Heterocedastico

En el gráfico anterior, notamos que los datos están más agrupados en valores bajos de Área del piso, pero se dispersan considerablemente conforme aumentan los valores del área. Esto indica que la homocedasticidad (varianza constante) no se cumple, y en su lugar, observamos un patrón de heterocedasticidad, lo que significa que la varianza de los precios no es constante a lo largo de los valores del área del piso.

Esto se puede corroborar con análisis estadísticos, como pruebas de linealidad y heterocedasticidad, pero en este artículo nos enfocaremos en un enfoque práctico apoyándonos en gráficos para identificar posibles violaciones a estos supuestos

Entonces ¿Cómo podemos seguir adelante?

Una manera efectiva de abordar estos problemas es transformar las variables mediante su logaritmo. Esta técnica es particularmente útil por las siguientes razones:

Linealización de relaciones no lineales: Muchas relaciones no lineales entre variables pueden convertirse en lineales al aplicar una transformación logarítmica, facilitando el ajuste del modelo.
Reducción de heterocedasticidad: Las transformaciones logarítmicas tienden a estabilizar la varianza, ayudando a evitar problemas de heterocedasticidad.
Escala más manejable: Si los valores tienen rangos amplios, el logaritmo los compacta, haciendo que sean más fáciles de interpretar y modelar.

En los próximos pasos, aplicaremos esta transformación a nuestras variables clave y evaluaremos cómo mejora la calidad de nuestros datos para la regresión lineal.

# Usar variables logaritmicas
df['log_area'] = np.log(df['Floor_area'])
df['log_precio']  = np.log(df['Price_$_k'])

sns.scatterplot(x='log_area',y='log_precio',data=df)
plt.title('Area del piso vs Precios en ($) en miles', fontsize=16)
plt.xlabel('Area del piso')
plt.ylabel('Precio ($) en miles')
plt.show()

Excelente! Ahora nuestras variables presentan no solo un comportamiento lineal si no que también hemos eliminado la heterocedasticidad.

Como siguiente paso realizaremos la configuración y aplicación de nuestro modelo de regresión lineal.

3. Aplicar el modelo de regresión

¿Por qué utilizaremos OLS de Statsmodels?

El modelo de Regresión Lineal mediante Ordinary Least Squares (OLS) es uno de los métodos más populares para estimar los coeficientes de un modelo lineal, ya que no solo ajusta el modelo, sino que también proporciona un análisis detallado de los resultados, lo que es muy importante para interpretar y evaluar nuestro modelo.

En este contexto, el uso de OLS no solo nos permitirá ajustar un modelo, sino también profundizar en la comprensión de los factores que afectan los precios de las propiedades.

¿Por qué no usamos solo scikit-learn? Aunque scikit-learn también permite implementar la regresión lineal, su enfoque está más orientado a tareas de predicción que a la interpretación detallada del modelo. Por eso, Statsmodels es mi elección cuando el análisis interpretativo y estadístico es una prioridad.

#Ejecutar el model
y = df['log_precio'] #variable dependiente
x1 = df['log_area'] #variable independiente
x = sm.add_constant(x1) #Añadimos la constante
results = sm.OLS(y,x).fit() #entrenamos al modelo
results.summary() #Observamos el cuadro informativo

Después de ajustar nuestro modelo de regresión lineal, obtuvimos el siguiente cuadro resumen:

R-squared (Coeficiente de determinación): El valor de R2 es 0.706 lo que indica que el 70.6% de la variabilidad en los precios de las casas (en escala logarítmica) puede ser explicada por el área del piso (también en escala logarítmica). Es un resultado bueno aunque podría mejorarse al incluir otras variables relevantes.
Coeficiente de la variable independiente (log(Area)): El coeficiente es 1.4417 lo que indica que en promedio, un aumento del 1% en el área del piso está asociado con un incremento del 1.4417% en el precio de la casa. Esta es una relación fuerte y positiva.
Significancia estadística (Valores p): Tanto la constante como
log(Area) tienen valores p significativamente menores a 0.05, lo que confirma que son estadísticamente significativos en el modelo.

Veamos como se gráfico la línea de regresión en nuestro conjunto de datos.

sns.scatterplot(x=x1,y=y)
yhat = -6.1998 + 1.4417*x1
plt.plot(x1,yhat,c='red',label='regression line')
plt.xlabel('Area del piso')
plt.ylabel('Precio miles ($)')
plt.title('Area del piso vs Precios en ($) en miles', fontsize=16, color='green')
plt.legend()
plt.show()

Espera! no nos quedaremos allí, ¿Qué ocurriría si añadimos otra variable más? Como por ejemplo: Bedrooms, eso es lo que veremos en el siguiente punto.

4. Regresión Lineal Múltiple

Aquí añadiremos la columnas Bedrooms para ver si nuestro modelo mejora o no, ya estaríamos hablando de un problema de regresión lineal múltiple.

x1 = df[['Bedrooms','log_area']]
y = df['log_precio']
x = sm.add_constant(x1)
results = sm.OLS(y,x).fit()
results.summary()

Análisis de los resultados del modelo y comparación de cambios:

R-squared Ajustado (Coeficiente de determinación ajustado): En un problema de regresión lineal múltiple es más adecuado utilizar el R2-ajustado en lugar del R2 estándr, ya que este penaliza la inclusión de variables adicionales que no aporten significativamente al modelo.

Al comparar el R2-ajustado de 72.4% frente a 70.6% de la regresión simple (solo con log(Area)), podemos observar que la inclusión de Bedrooms ha mejorado la capacidad del modelo para explicar la variabilidad en los precios.

Significancia estadística (Valores p): El valor p asociado a la nueva variable Bedrooms es menor a 0.05, lo que indica que es estadísticamente significativa para el modelo. Esto confirma que Bedrooms aporta información relevante para explicar la variabilidad en los precios, contribuyendo a una mejor predicción.
Coeficiente de la variable independiente Bedrooms: El coeficiente negativo de Bedrooms indica que, al aumentar en 1 el número de dormitorios, el log(Precio) disminuye en promedio, manteniendo constante el área. Esto puede parecer contraintuitivo, pero podría reflejar que, en propiedades con áreas similares, agregar dormitorios reduce el espacio disponible para otras características de alto valor (como una sala más grande o acabados de lujo).

Este resultado enfatiza que Bedrooms por sí solo no es siempre un predictor lineal positivo de precio, especialmente cuando otras variables como el área ya están incluidas en el modelo.

Conclusión:
La adición de Bedrooms no solo ha mejorado el ajuste del modelo (mayor R2-ajustado), sino que también ha demostrado ser una variable relevante desde el punto de vista estadístico. Esto refuerza la importancia de explorar y seleccionar cuidadosamente las variables predictoras en los modelos de regresión, por último es importante interpretar estos resultados no de forma aislada, sino considerando las interacciones y la posible multicolinealidad entre las variables.

5. Añadir más variables

Para mejorar el modelo de regresión y ver cómo se comporta con la regresión lineal múltiple, añadiremos una nueva variable: Ciudad. Intuitivamente, podemos suponer que la ubicación de la propiedad, representada por la ciudad, puede tener un impacto significativo en su precio. Por lo tanto, vamos a incluirla como una variable adicional en nuestro análisis.

df['City'] = df['City'].map({'dhaka':0,'chattogram':1,'cumilla':2,'narayanganj-city':3,'gazipur':4})

En el código anterior, lo que hice fue mapear la columna "City", que contiene los nombres de las ciudades, asignando a cada una de ellas un valor numérico único. Por ejemplo, Dhaka se convierte en 0, Chattogram en 1, y así sucesivamente. Este mapeo nos permite incluir la variable "Ciudad" como una variable numérica en nuestro modelo de regresión lineal.

Es importante destacar que este es un enfoque sencillo para convertir variables categóricas en numéricas. Sin embargo, si las ciudades tienen más de dos categorías, una alternativa más robusta es usar técnicas como el OneHotEncoder de la librería scikit-learn, que crea una columna binaria por cada categoría, permitiendo modelar de manera más eficiente y evitando problemas de interpretación cuando hay más de dos categorías.

x1 = df[['City','log_area','Bedrooms']]
y = df['log_precio']
x = sm.add_constant(x1)
results = sm.OLS(y,x).fit()
results.summary()

¡Muchísimo mejor, ¿Verdad?! Al incluir la variable 'City', logramos mejorar significativamente el rendimiento de nuestro modelo, alcanzando un R² de 78.7%. Esto sugiere que la ciudad en la que se encuentra la propiedad tiene una influencia considerable en su precio. Los p-valores menores a 0.05 refuerzan la idea de que las variables utilizadas son estadísticamente significativas, lo que significa que podemos confiar en los resultados del modelo. Este análisis nos permite hacer predicciones más precisas y establecer una base sólida para futuras investigaciones en el sector inmobiliario.

6. Predecir y evaluar correctamente los resultados.

Para finalizar y dar un análisis más completo, no solo nos quedaremos con el ajuste del modelo, sino que también realizaremos predicciones utilizando nuevos valores y evaluaremos los resultados.

# Ejemplo de nuevos datos
new_data = pd.DataFrame({
    'City': [0, 1],
    'log_area': [7.5, 6.8],
    'Bedrooms': [3, 4]
})

# Agregar la constante para los nuevos datos
new_data_with_const = sm.add_constant(new_data)

# Hacer predicciones
predicted_values = results.predict(new_data_with_const)

# Mostrar las predicciones
print(predicted_values)

Una vez realizadas las predicciones, obtuvimos los precios predichos (en logaritmo de precios) para los dos datos nuevos introducidos, los cuales nunca antes habían sido vistos por el modelo:

0    4.759433
1    3.427864
dtype: float64

Ahora, vamos a evaluar la precisión de nuestro modelo y entender cómo se comportan estas predicciones en comparación con los datos reales.

¿Como evaluamos los errores?

Para evaluar la precisión de nuestras predicciones, utilizaremos el Mean Squared Error (MSE) o Error Cuadrático Medio, que mide el promedio de los cuadrados de las diferencias entre los valores predichos y los valores observados. Este valor nos permite cuantificar qué tan bien está funcionando nuestro modelo. Para calcularlo, utilizaremos la librería de scikit-learn y su módulo mean_squared_error.

from sklearn.metrics import mean_squared_error
y_pred = results.predict(x)

# Calcular MSE
mse = mean_squared_error(y, y_pred)

print(f"El MSE del modelo es: {mse}")

Una vez aplicada la librería obtenemos el siguiente valor de MSE.

El MSE del modelo es: 0.0738931778107037

Es importante tener en cuenta que el MSE está en unidades elevadas al cuadrado, lo que puede hacer que su interpretación sea más difícil. Para facilitar la lectura y comprensión del error, utilizaremos el RMSE (Root Mean Squared Error), que es simplemente la raíz cuadrada del MSE. El RMSE tiene las mismas unidades que la variable de interés, lo que lo hace más fácil de interpretar.

rmse = np.sqrt(mse)
print(f"El RMSE del modelo es: {rmse}")

El RMSE del modelo es: 0.2718329961772553

Para interpretar el RMSE en las unidades originales de los precios (no logarítmicas), es necesario exponenciar el RMSE, ya que el modelo trabaja sobre valores logarítmicos. Esto nos dará una medida en la misma escala de los precios originales.

rmse_original_scale = np.exp(0.2718) - 1
print(f"El RMSE Original es: {rmse_original_scale}")

El RMSE Original es: 0.31232451016083607

El RMSE de 0.3123 miles de dólares muestra que nuestro modelo tiene una capacidad bastante decente para predecir los precios de las propiedades, con un error promedio de alrededor de 312 dólares. Dependiendo del destino de uso del modelo como para predicciones comerciales, este error puede ser aceptable, pero siempre es bueno compararlo con el rango de precios para tener una evaluación más precisa.

7. Conclusiones y pasos finales

En este artículo, hemos utilizado la regresión lineal, específicamente el modelo OLS (Ordinary Least Squares), para predecir los precios de propiedades basado en variables como el área del piso, la cantidad de dormitorios y la ciudad. A través de este análisis, hemos logrado lo siguiente:

Validación de supuestos: Aunque la linealidad no fue perfecta y encontramos evidencias de heterocedasticidad en nuestros datos (Omnibus y Jarque-Bera), aplicamos una transformación logarítmica que ayudó a mejorar la linealidad y la varianza constante, acercando el modelo a las condiciones ideales de la regresión lineal.
Mejora con variables adicionales: Hemos ido viendo como la incorporación de variables ha ido mejorando al modelo, la variable City, que representa las diferentes ciudades, logramos mejorar significativamente el modelo, alcanzando un R2 ajustado del 78.7%, lo que indica que el modelo puede explicar un alto porcentaje de la variabilidad en los precios, cabe recalcar que esto no siempre es así, por eso es bueno revisar siempre el R2-ajustado y el p-valor de cada variable.
Evaluación del rendimiento: Con el cálculo del RMSE (Root Mean Squared Error) en escala original, encontramos que el modelo tiene un error promedio de 312.3 dólares por predicción. Este valor, aunque dependiente del rango de precios, muestra un error razonablemente bajo, lo que sugiere que el modelo es adecuado para las predicciones de precios de propiedades en este conjunto de datos.

En resumen, hemos construido un modelo de regresión lineal efectivo para predecir precios de propiedades, aunque siempre existen áreas para mejorar, como la posible inclusión de variables adicionales o el ajuste más fino del modelo.

Pasos Finales a Seguir

Ampliar los datos: Incluir más datos y variables podría mejorar la precisión del modelo.
Probar otros modelos: Modelos como Random Forest o XGBoost pueden captar mejor las interacciones y mejorar las predicciones.
Evaluar con nuevos datos: Validar el modelo con un conjunto de prueba o usar validación cruzada para asegurar que no haya sobreajuste.
Incluir más variables: Añadir factores como el tipo de propiedad o la antigüedad podría mejorar la precisión.
Predicción en tiempo real: Si el modelo se va a implementar en producción se debe de considerar actualizarlo periódicamente con nuevos datos, recomiendo ir leyendo sobre MLOps.

Si crees que se puedan incluir mejoras o alguna parte del código no te funciona, hazmelo saber, te ayudaré con gusto :).

¿Quién dijo que las matemáticas no resuelven problemas de la vida real? La regresión lineal lo hace con más estilo que un chef con su receta secreta.

Edgar Cajusol - Data Scientist - Creando impacto un modelo a la vez.
https://www.linkedin.com/in/edgarcajusol/

¿Fraude? Que no nos engañen. Detección de fraude en tarjetas de crédito con Random Forest Classifier.

Edgar Cajusol — Thu, 21 Nov 2024 08:14:22 +0000

Los usuarios del sector bancario son especialmente vulnerables a los fraudes debido a factores como la delincuencia local, robo de datos por ciberataques, filtraciones de información o incluso la clonación de tarjetas. Cuando un delincuente obtiene nuestros datos, puede realizar compras o retiros de dinero que impactan directamente nuestras finanzas.

Afortunadamente, muchas de estas actividades fraudulentas son detectadas y bloqueadas a tiempo por los sistemas bancarios gracias a la identificación de patrones sospechosos o anomalías en el comportamiento del usuario. ¿Cómo logran hacer esto? La respuesta radica en el uso de algoritmos de machine learning. Desde técnicas clásicas como la regresión logística o los clasificadores basados en árboles de decisión, hasta avanzados modelos de deep learning, estos algoritmos son la clave para prevenir fraudes de manera eficiente.

Sin embargo, la implementación de un modelo de detección de fraudes no se reduce simplemente a aplicar un algoritmo sobre los datos. Hay una serie de pasos fundamentales que debemos considerar:

Identificación de factores relevantes: Es crucial analizar qué características podrían indicar actividades fraudulentas. Estas pueden incluir patrones en las transacciones, dispositivos utilizados para iniciar sesión, cambios frecuentes de contraseña o accesos desde ubicaciones inusuales, entre otros.
Construcción de un historial significativo: Si no contamos con datos históricos de fraudes, será necesario recopilar información suficiente para que el modelo pueda aprender patrones generales y no simplemente memorizar datos. Esto ayuda a evitar problemas como underfitting o overfitting. Además, entrenar un modelo basado en datos de otra empresa probablemente no funcionará debido a diferencias en los contextos y patrones de comportamiento.
Limpieza y procesamiento de datos: Entrenar un modelo sin un adecuado procesamiento de los datos es un error común. Dividir el dataset en conjuntos de entrenamiento y prueba no es suficiente si los datos contienen errores, valores atípicos o información incompleta. Recuerda que tu modelo será implementado en un entorno real; un modelo poco confiable no solo puede causar pérdidas económicas a la empresa, sino también afectar directamente a los usuarios.
Selección del algoritmo adecuado: La complejidad no siempre es sinónimo de calidad. Evalúa las diferentes opciones y considera que, en algunos casos, un algoritmo más simple puede ser más eficiente y efectivo para tu problema.
Evaluación con métricas variadas: No te quedes únicamente con la precisión del modelo. Dependiendo del caso, métricas como el recall, la F1-score o la matriz de confusión pueden ofrecer una mejor comprensión del rendimiento y ayudarte a evitar errores críticos. A veces, un modelo con alta precisión no es necesariamente el más adecuado.

Veamos el caso que trataremos aquí: un dataset obtenido de Kaggle. Este conjunto de datos incluye transacciones realizadas durante dos días y tiene las siguientes características clave:

Tamaño y balance de clases:

Total de transacciones: 284,807.
Transacciones clasificadas como fraude: 492.
La clase de fraude representa solo el 0.17% del total, lo que evidencia un conjunto de datos muy desequilibrado. Esto es común en problemas de detección de fraude, ya que los casos fraudulentos son poco frecuentes.

Columnas principales:

V1 a V28: Estas columnas son el resultado de un análisis de componentes principales (PCA) para reducir la dimensionalidad. Además, el PCA se utilizó para ocultar información sensible, permitiendo que los científicos de datos las utilicen de manera segura para experimentar y mejorar sus habilidades.
Time: Representa los segundos transcurridos entre cada transacción y la primera registrada en el dataset.
Amount: Representa la cantidad de dinero que registró la transacción.
Class: Es nuestra variable objetivo. Toma el valor 1 para transacciones fraudulentas y 0 en caso contrario. Como podemos ver, el desequilibrio en las clases será un desafío importante al entrenar modelos de machine learning, ya que puede llevar a que los algoritmos ignoren los casos minoritarios si no se manejan adecuadamente.

Link del dataset: https://www.kaggle.com/datasets/mlg-ulb/creditcardfraud

1. Carga de datos y primer vistazo.

Importamos las liberías necesarias, cargamos nuestro dataset y visualizamos las 10 primeras filas.

#Importar liberías
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import make_pipeline
from sklearn.metrics import (classification_report, confusion_matrix, 
                             precision_score, recall_score, 
                             f1_score, precision_recall_curve)
from sklearn.model_selection import KFold, train_test_split, GridSearchCV, RandomizedSearchCV
from imblearn.over_sampling import SMOTE
from collections import Counter

#Cargar el dataset y mostrarlo
df = pd.read_csv('archivo.csv')
df.head(10)

	Time	V1	V2	V3	V4	V5	V6	V7	V8	V9	V10	V11	V12	V13	V14	V15	V16	V17	V18	V19	V20	V21	V22	V23	V24	V25	V26	V27	V28	Amount
0	0.0	-1.359807	-0.072781	2.536347	1.378155	-0.338321	0.462388	0.239599	0.098698	0.363787	0.090794	-0.551600	-0.617801	-0.991390	-0.311169	1.468177	-0.470401	0.207971	0.025791	0.403993	0.251412	-0.018307	0.277838	-0.110474	0.066928	0.128539	-0.189115	0.133558	-0.021053	149.62
1	0.0	1.191857	0.266151	0.166480	0.448154	0.060018	-0.082361	-0.078803	0.085102	-0.255425	-0.166974	1.612727	1.065235	0.489095	-0.143772	0.635558	0.463917	-0.114805	-0.183361	-0.145783	-0.069083	-0.225775	-0.638672	0.101288	-0.339846	0.167170	0.125895	-0.008983	0.014724	2.69
2	1.0	-1.358354	-1.340163	1.773209	0.379780	-0.503198	1.800499	0.791461	0.247676	-1.514654	0.207643	0.624501	0.066084	0.717293	-0.165946	2.345865	-2.890083	1.109969	-0.121359	-2.261857	0.524980	0.247998	0.771679	0.909412	-0.689281	-0.327642	-0.139097	-0.055353	-0.059752	378.66
3	1.0	-0.966272	-0.185226	1.792993	-0.863291	-0.010309	1.247203	0.237609	0.377436	-1.387024	-0.054952	-0.226487	0.178228	0.507757	-0.287924	-0.631418	-1.059647	-0.684093	1.965775	-1.232622	-0.208038	-0.108300	0.005274	-0.190321	-1.175575	0.647376	-0.221929	0.062723	0.061458	123.50
4	2.0	-1.158233	0.877737	1.548718	0.403034	-0.407193	0.095921	0.592941	-0.270533	0.817739	0.753074	-0.822843	0.538196	1.345852	-1.119670	0.175121	-0.451449	-0.237033	-0.038195	0.803487	0.408542	-0.009431	0.798278	-0.137458	0.141267	-0.206010	0.502292	0.219422	0.215153	69.99
5	2.0	-0.425966	0.960523	1.141109	-0.168252	0.420987	-0.029728	0.476201	0.260314	-0.568671	-0.371407	1.341262	0.359894	-0.358091	-0.137134	0.517617	0.401726	-0.058133	0.068653	-0.033194	0.084968	-0.208254	-0.559825	-0.026398	-0.371427	-0.232794	0.105915	0.253844	0.081080	3.67
6	4.0	1.229658	0.141004	0.045371	1.202613	0.191881	0.272708	-0.005159	0.081213	0.464960	-0.099254	-1.416907	-0.153826	-0.751063	0.167372	0.050144	-0.443587	0.002821	-0.611987	-0.045575	-0.219633	-0.167716	-0.270710	-0.154104	-0.780055	0.750137	-0.257237	0.034507	0.005168	4.99
7	7.0	-0.644269	1.417964	1.074380	-0.492199	0.948934	0.428118	1.120631	-3.807864	0.615375	1.249376	-0.619468	0.291474	1.757964	-1.323865	0.686133	-0.076127	-1.222127	-0.358222	0.324505	-0.156742	1.943465	-1.015455	0.057504	-0.649709	-0.415267	-0.051634	-1.206921	-1.085339	40.80
8	7.0	-0.894286	0.286157	-0.113192	-0.271526	2.669599	3.721818	0.370145	0.851084	-0.392048	-0.410430	-0.705117	-0.110452	-0.286254	0.074355	-0.328783	-0.210077	-0.499768	0.118765	0.570328	0.052736	-0.073425	-0.268092	-0.204233	1.011592	0.373205	-0.384157	0.011747	0.142404	93.20
9	9.0	-0.338262	1.119593	1.044367	-0.222187	0.499361	-0.246761	0.651583	0.069539	-0.736727	-0.366846	1.017614	0.836390	1.006844	-0.443523	0.150219	0.739453	-0.540980	0.476677	0.451773	0.203711	-0.246914	-0.633753	-0.120794	-0.385050	-0.069733	0.094199	0.246219	0.083076	3.68

Corroboramos que no tenga algún dato nulo.
df.isna().sum()

	Time	V1	V2	V3	V4	V5	V6	V7	V8	V9	V10	V11	V12	V13	V14	V15	V16	V17	V18	V19	V20	V21	V22	V23	V24	V25	V26	V27	V28	Amount	Class
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0

Al no tener datos nulos, continuaremos con visualizar el tipo de elementos que tiene cada columna.


RangeIndex: 284807 entries, 0 to 284806
Data columns (total 31 columns):
 #   Column  Non-Null Count   Dtype  
---  ------  --------------   -----  
 0   Time    284807 non-null  float64
 1   V1      284807 non-null  float64
 2   V2      284807 non-null  float64
 3   V3      284807 non-null  float64
 4   V4      284807 non-null  float64
 5   V5      284807 non-null  float64
 6   V6      284807 non-null  float64
 7   V7      284807 non-null  float64
 8   V8      284807 non-null  float64
 9   V9      284807 non-null  float64
 10  V10     284807 non-null  float64
 11  V11     284807 non-null  float64
 12  V12     284807 non-null  float64
 13  V13     284807 non-null  float64
 14  V14     284807 non-null  float64
 15  V15     284807 non-null  float64
 16  V16     284807 non-null  float64
 17  V17     284807 non-null  float64
 18  V18     284807 non-null  float64
 19  V19     284807 non-null  float64
 20  V20     284807 non-null  float64
 21  V21     284807 non-null  float64
 22  V22     284807 non-null  float64
 23  V23     284807 non-null  float64
 24  V24     284807 non-null  float64
 25  V25     284807 non-null  float64
 26  V26     284807 non-null  float64
 27  V27     284807 non-null  float64
 28  V28     284807 non-null  float64
 29  Amount  284807 non-null  float64
 30  Class   284807 non-null  int64  
dtypes: float64(30), int64(1)
memory usage: 67.4 MB

Observando el resultado anterior podemos notar que todos tipos de datos son los que les corresponden, así que no habría que corregir nada aquí.

2. Análisis Exploratorio de Datos (EDA)

Aquí principalmente implementaremos visualizaciones para poder analizar y entender el comportamiento y distribución de nuestros datos.

plt.figure(figsize=(8,6))
ax = sns.countplot(x='Class',data=df,palette={0:'gray',1:'r'})
plt.xticks(ticks=[0,1],labels=['No Fraude','Fraude'])

# Añadir porcentajes
total = len(df)

for p in ax.patches:
    altura = p.get_height()
    porcentaje = altura / total * 100
    ax.annotate(f"{porcentaje:.2f}%", (p.get_x() + p.get_width()/2, altura),
                ha='center', va='center', xytext=(0,10), textcoords='offset points')

plt.title("Cantidad de Fraude y No Fraude en el Dataset",color='blue',size=16)
plt.show()

Podemos notar que tenemos una dataset desbalancedo la clase objetivo Fraude representa apenas un 0.17% de todo el conjunto de datos, esto será un reto importante para nuestro modelo.

# Graficar puntos para cada clase con diferente.
sns.scatterplot(x='Amount', y='Time', data=df[df['Class'] == 0], color='gray', alpha=0.5, label='No Fraude')
sns.scatterplot(x='Amount', y='Time', data=df[df['Class'] == 1], color='red', alpha=1, label='Fraude')
plt.title("Tiempo vs Cantidad de Dinero",color='blue',size=16)
plt.show()

Con este gráfico de dispersión, podemos observar con más claridad la diferencia entre las dos clases. Además, notamos que la clase 'Fraude' tiende a tener montos relativamente bajos, generalmente entre 0$ y 3000$. Esto se debe a que transacciones con montos excesivamente altos activarían un aviso inmediato de fraude.

A partir de aquí podemos incluir los gráficos que creamos convenientes para mejorar nuestro entendimiento de los datos, como un boxplot de Amount para ver como oscila, entre otros.

3. Aplicando algoritmos de clasificación

Utilizaré principalmente dos algoritmos con el objetivo de obtener una visión más amplia de los resultados y realizar una comparativa entre ambos modelos. Además, aplicaremos SMOTE (Synthetic Minority Over-Sampling Technique), una técnica de sobremuestreo que genera nuevas instancias sintéticas para la clase minoritaria, en lugar de simplemente duplicarlas, lo cual podría introducir sesgos o errores.

¿Cómo funciona SMOTE?

Encuentra los vecinos cercanos de una instancia de la clase minoritaria.
Genera nuevas instancias sintéticas ubicadas en el punto medio de la línea que conecta la instancia original con uno de sus vecinos más cercanos.
Crea un nuevo punto tomando una proporción aleatoria de las características de la instancia original y su vecino más cercano.
Repite el proceso hasta lograr un balance entre las clases.

3.1. SMOTE y Logistic Regression

Dividiremos el conjunto de datos en entrenamiento y testing para evitar el overfitting y tener un conjunto de datos con que validar nuestro modelo.

X = np.array(df.drop(columns=['Class']))
y = np.array(df['Class'])

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=123,stratify=y)

Si te has fijado en el código, he incluido la línea de código stratify=y. Esto hace que la proporción de la clase 0 (No Fraude) y la clase 1 (Fraude) en el conjunto de datos original se preserve tanto en el conjunto de entrenamiento como en el de prueba. Es decir, al dividir el conjunto de datos en estos dos subconjuntos, nos aseguramos de que ambos mantengan las proporciones de cada clase, evitando que alguno de los conjuntos carezca de ejemplos de alguna clase, conservando la proporción de cómo se distribuyen los datos, es decir si nuestro conjunto de datos contiene una distribución de 99% para clase 0 y 1% para la clase 1 esta misma proporción se mantendrá en train y test.

#from imblearn import SMOTE
smote = SMOTE(random_state=123)

X_train_resampled, y_train_resampled = smote.fit_resample(X_train, y_train)

#from collections import Counter
# Mostrar el balance de clases antes y después de aplicar SMOTE
print('Distribución original de clases:', Counter(y_train))
print('Distribución después de SMOTE:', Counter(y_train_resampled))

Ahora que tenemos nuestra clase balanceada veamos como se comporta un modelo de Regresión Logística.

model = LogisticRegression(max_iter=1000)
model.fit(X_train_resampled,y_train_resampled)
y_pred = model.predict(X_test)

Ya que entrenamos el modelo con el dataset resampleado, gráfiquemos una matriz de confunsion para poder visualizar mejor los resultados.

def matriz_de_confusion(y_true, y_pred, title, detection):
    from sklearn.metrics import accuracy_score
    from sklearn.metrics import ConfusionMatrixDisplay
    """ Visualiza la matriz de confusión """

    matriz = confusion_matrix(y_true, y_pred)
    accuracy = accuracy_score(y_true, y_pred)

    #Código de matplotlib para graficar    
    plt.figure(figsize=(4, 4))
    cm_display = ConfusionMatrixDisplay(matriz).plot()


    matriz = pd.DataFrame(matriz, 
                          columns=[f"No (0): {detection}", f"Si (1): {detection}"])
    #plt.matshow(matriz, cmap="Blues", vmin=0, vmax=20, fignum=1)

    plt.xticks(range(len(matriz.columns)), matriz.columns, rotation=45)
    plt.yticks(range(len(matriz.columns)), matriz.columns)

    etiquetas = (("Verdaderos\nnegativos", "Falsos\nnegativos"),
                 ("Falsos\npositivos", "Verdaderos\npositivos"))

    plt.text(2.45, -0.2, title, fontsize=25, c="red")
    plt.text(2.25, 0.10, "Accuracy: %0.2f" % accuracy, fontsize=20)

    for i in range(len(matriz.columns)):
        for j in range(len(matriz.columns)):
            #plt.text(i, j + 0.14, str(matriz.iloc[j, i]),
                     #fontsize=20, ha="center", va="center")
            plt.text(i, j - 0.25, etiquetas[i][j],
                     fontsize=11.5, ha="center", va="center")           
    plt.show()

Al parecer nuestro modelo ha conseguido un Accuracy (Exactitud) muy buena de 99% pero ¿El modelo estará correcto?

Podemos entrar más a profundidad revisando las métricas de precision, recall y f1-score.

Antes de pasar al detalle de la tabla de reporte, me gustaría dar unos tips de como entender las metricas de accuracy, presicion, recall y el F1-Score.

(TN - True negative) (TP - True Positive)

Accuracy: Accuracy o Exactitud es la capacidad de nuestro modelo para identificar los valores positivos o negativos, es decir mide la proporción total de predicciones correctas.

Precision: La Presicion responde a la siguiente pregunta: De todos los positivos predichos por el modelo ¿Cuántos realmente eran positivos?.

Recall: De todos los positivos (predichos y no predichos) ¿Cuántos logramos identificar?

F1-Score: Es la media armónica entre la precisión y el recall. Se utiliza cuando se necesita un equilibrio entre estas dos métricas y es especialmente útil cuando las clases están desbalanceadas.

Una vez aclarado esto, veamos el resultado del reporte de clasificación de nuestro de modelo de regresión logistica con SMOTE.

report = classification_report(y_test,y_pred,target_names={0:'Normal',1:'Fraude'},output_dict=True)
report_df = pd.DataFrame(report).transpose()
report_df

	precision	recall	f1-score	support
0	0.999727	0.985990	0.992811	85295.000000
1	0.094697	0.844595	0.170300	148.000000
accuracy	0.985745	0.985745	0.985745	0.985745
macro avg	0.547212	0.915292	0.581555	85443.000000
weighted avg	0.998159	0.985745	0.991386	85443.000000

Precisión de la clase 1 (Fraude) baja: La precisión mide la proporción de predicciones positivas correctas (fraudes detectados) sobre el total de predicciones positivas. Tengo 1,195 falsos positivos y solo 125 verdaderos positivos, lo que hace que la precisión sea baja: 9%.
Recall de la clase 1 (Fraude) alto: El recall mide la proporción de fraudes correctamente detectados sobre el total de fraudes reales: Esto significa que nuestro modelo está logrando capturar la mayoría de los fraudes, pero a costa de predecir muchos falsos positivos.

Aunque el modelo tenga un accuracy alto y un recall elevado (lo que indica una buena capacidad para identificar los fraudes reales), también está generando una gran cantidad de falsos positivos, es decir, está catalogando transacciones que no son fraudulentas como si lo fueran.

¿Cómo podría perjudicar este resultado?

Este tipo de errores puede tener un impacto directo tanto en el usuario como en la entidad bancaria. Cuando el modelo clasifica incorrectamente una transacción legítima como fraude, el banco podría bloquear la tarjeta del usuario. Esto interrumpe su capacidad para realizar compras hasta que se comunique con el banco, aclare la situación y, en muchos casos, responda a preguntas de seguridad. Este proceso es costoso en términos de tiempo, recursos humanos y logísticos. Además, genera incomodidad en los usuarios, lo que puede llevar a pérdidas de fidelización y de ingresos para el banco. Por estos motivos, sería recomendable descartar el modelo de regresión logística.

Antes de pasar a lo siguiente veamos un gráfico más.

#from sklearn.metrics import roc_auc_score, roc_curve

y_proba = model.predict_proba(X_test)[:,1]
fpr, tpr, _ = roc_curve(y_test,y_proba)
auc = roc_auc_score(y_test,y_proba)

plt.plot([0,1],[0,1],'k--')
plt.plot(fpr,tpr,label=f"ROC Curve (AUC = {auc:.2f})")
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Curva ROC',color='blue',size=16)
plt.legend(loc='best')

AUC-SCORE: La puntuación AUC oscila entre 0 y 1, donde una puntuación cercana a 1 indica un rendimiento excelente del modelo, 0,5 sugiere una adivinación aleatoria, y una puntuación cercana a 0 significa un rendimiento deficiente.

El modelo tiene un AUC muy bueno (0.96), lo que significa que es excelente a la hora de separar las dos clases (fraude y no fraude) basándose en las probabilidades. Sin embargo, el F1-Score para la clase 1 (fraude) es muy bajo (0.17), mientras que para la clase 0 (no fraude) es casi perfecto (0.99). Esto sugiere que, aunque el modelo puede identificar bien la clase mayoritaria (no fraude), no está funcionando bien para detectar fraudes.

3.2. Logistic Regression Balanced

El algoritmo de regresión logística también ofrece un parámetro llamado class_weight, que nos permite asignar pesos a las clases de manera que la clase minoritaria no pierda protagonismo durante el proceso de entrenamiento. Esto es especialmente útil cuando estamos trabajando con conjuntos de datos desbalanceados, como en el caso de la detección de fraude, donde la clase fraude (minoritaria) podría ser ignorada por el modelo si no se ajusta adecuadamente. Al dar un peso mayor a la clase minoritaria, ayudamos a que el modelo preste más atención a esos casos, lo que mejora la capacidad de identificar fraudes sin que el modelo esté sesgado hacia la clase mayoritaria.

A continuación aplicaremos dicho parámetro además de estandarizar nuestras variables, esto no es estrictamente necesario sin embargo es altamente recomendable cuando tenemos variables muy diferentes de escala entre sí, mejorando la estabilidad del modelo.

#from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

#Aqui ya no usamos el dataset balanceado con SMOTE
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model = LogisticRegression(max_iter=1000, class_weight='balanced')
model.fit(X_train_scaled, y_train)
y_pred = model.predict(X_test_scaled)

matriz_de_confusion(y_test,y_pred,"Balanced",'Fraude')

report = classification_report(y_test,y_pred,target_names={0:'Normal',1:'Fraude'},output_dict=True)
report_df = pd.DataFrame(report).transpose()
report_df

	precision	recall	f1-score	support
0	0.999749	0.979741	0.989644	85295.00000
1	0.068464	0.858108	0.126810	148.00000
accuracy	0.979530	0.979530	0.979530	0.97953
macro avg	0.534106	0.918925	0.558227	85443.00000
weighted avg	0.998136	0.979530	0.988149	85443.00000

Como podemos notar en el reporte y en la matriz de confusión nuestro modelo no ha mejorado mucho, de hecho a pesar de aumentar nuestro verdaderos positivos, las datos clasificados como verdaderos negativos han aumentado y el F1-Score de la clase Fraude ha disminuido.

3.3. Random Forest Classifier

El Random Forest Classifier es un algoritmo de aprendizaje supervisado que utiliza múltiples árboles de decisión para hacer predicciones. Cada árbol es entrenado con un subconjunto aleatorio de los datos y las características, y luego sus predicciones se combinan mediante una votación mayoritaria para determinar la clase final.

¿Cómo funciona?

Entrenamiento: Se crean varios árboles de decisión con subconjuntos aleatorios de datos y características.
Predicción: Cada árbol emite una predicción, y la clase final se elige por mayoría de votos.
Votación: El resultado es más robusto y preciso que el de un solo árbol de decisión.

Ventajas:

Menos propenso a sobreajuste (overfitting).
Robusto frente a datos ruidosos.
Manejo eficiente de datos desbalanceados.

No solo me limitaré a entrenar el modelo, sino que lo haremos con RandomizedSearchCV, que es una técnica de optimización de hiperparámetros que realiza una búsqueda aleatoria dentro de un espacio de posibles valores para encontrar la mejor combinación de parámetros. A diferencia de GridSearchCV, que prueba todas las combinaciones posibles, RandomizedSearchCV selecciona aleatoriamente un número de combinaciones, lo que puede ser más eficiente cuando el espacio de búsqueda es muy grande.

Este método recibe parámetros como:

estimator: El modelo que se desea optimizar (en este caso, el clasificador RandomForest).
param_distributions: Un diccionario que define los rangos de los hiperparámetros que se desean explorar.
n_iter: El número de combinaciones aleatorias que se probarán.
scoring: La métrica que se usará para evaluar el rendimiento del modelo.
cv: Número de particiones para la validación cruzada.

El uso de RandomizedSearchCV nos permite encontrar rápidamente una combinación óptima de parámetros, mejorando el rendimiento del modelo sin la necesidad de hacer una búsqueda exhaustiva.

Por si no recuerdas como funciona Cross Validation (CV):

Cross-Validation (CV) es una técnica de validación en aprendizaje automático que evalúa el rendimiento de un modelo dividiendo el conjunto de datos en varios subconjuntos o folds. En k-fold cross-validation, los datos se dividen en k grupos, y el modelo se entrena con k-1 de estos grupos, evaluándolo en el grupo restante. Este proceso se repite k veces, utilizando cada grupo como conjunto de prueba una vez. Al final, se promedian los resultados de todas las iteraciones para obtener una evaluación más precisa y generalizada del modelo.

Veamos el código de nuestro modelo.

import time

pipeline = make_pipeline(RandomForestClassifier())

param_grid = {
    'randomforestclassifier__n_estimators': [100, 200, 300],
    'randomforestclassifier__max_depth': [None, 10, 20, 30],
    'randomforestclassifier__min_samples_split': [2, 5, 10],
    'randomforestclassifier__min_samples_leaf': [1, 2, 4],
    'randomforestclassifier__class_weight': ['balanced'],
    'randomforestclassifier__criterion': ['gini', 'entropy']
}

start_time = time.time()

random_search = RandomizedSearchCV(estimator=pipeline, param_distributions=param_grid, n_iter=10, cv=5, n_jobs=-1, verbose=3, random_state=123)
random_search.fit(X_train,y_train)

# Calcular el tiempo total
total_time = time.time() - start_time

Explicación de los parámetros:

n_estimators: Número de árboles en el bosque.
max_depth: Profundidad máxima de los árboles. None indica sin límite.
min_samples_split: Número mínimo de muestras necesarias para dividir un nodo.
min_samples_leaf: Número mínimo de muestras que debe tener una hoja.
class_weight: Ajusta el peso de las clases. 'balanced' ayuda a manejar datos desbalanceados.
criterion: Función para medir la calidad de la división (Gini o Entropía).

He incluido una línea de código start_time, para poder calcular el tiempo que tarda RandomSearchCV en aplicar todas las combinaciones de hiperparámetros dados.

print(f"Tiempo total: {total_time:.2f} segundos")

Tiempo total: 1710.29 segundos = 28.5 minutos

# Obtener el mejor modelo y los mejores parámetros
best_model = random_search.best_estimator_
best_params = random_search.best_params_
print("Mejores parámetros:", best_params)

print(f'Mejor score: {random_search.best_score_}')

Mejor score: 0.9995736448174799

Ahora que tenemos un modelo más robusto aplicando RandomSearchCV y los hiperparámetros porque no entrenamos un modelo con los mejores parámetros encontrados.

4. Entrenando con los mejores parámetros

Aquí serviría de mucho dejar en claro la diferencia entre usar gini o entropía como criterion.

Índice de Gini: Mide la impureza de un nodo en un árbol de decisión. Penaliza las mezclas de clases, ya que un valor de Gini más alto indica que las instancias en el nodo están más mezcladas entre diferentes clases. Un Gini de 0 significa que el nodo es puro (todas las instancias son de la misma clase).
- Ventajas: Es computacionalmente más simple que la entropía. Tiende a funcionar bien en la práctica para muchos problemas de clasificación
Entropía: Mide la incertidumbre o impureza de un nodo. Penaliza la mezcla de clases en función de la cantidad de información necesaria para describir la clase. Un valor de entropía más alto indica mayor mezcla de clases, y un valor de 0 significa que el nodo es puro.
- Ventajas: Tiene una interpretación más directa en términos de teoría de la información. Puede ofrecer mejores resultados en algunos problemas, especialmente cuando se busca una separación más fina entre clases.

y_pred = best_model.predict(X_test)
matriz_de_confusion(y_test,y_pred,'Best Params','Fraude')

Con la visualización de nuestra matriz de confusion podemos notar una clara mejora en clasificación de nuestra clase Fraude y No Fraude.

Veamos el reporte para más detalle.

report = classification_report(y_test,y_pred,target_names=['No Fraude','Fraude'],output_dict=True)
report_df = pd.DataFrame(report).transpose()
report_df

	precision	recall	f1-score	support
No Fraude	0.999508	0.999953	0.999730	85295.000000
Fraude	0.963636	0.716216	0.821705	148.000000
accuracy	0.999462	0.999462	0.999462	0.999462
macro avg	0.981572	0.858085	0.910718	85443.000000
weighted avg	0.999446	0.999462	0.999422	85443.000000

CLASE NO FRAUDE

Precision: 0.9995 → Muy alta, lo que significa que casi todas las predicciones como "No Fraude" fueron correctas.
Recall: 0.9996 → También muy alto, indicando que el modelo captura casi todos los casos verdaderos de "No Fraude".

CLASE FRAUDE

Precision: 0.9636 → Muy buena para una clase minoritaria, lo que significa que la mayoría de las predicciones etiquetadas como "Fraude" son correctas, pasamos de valores como 0.09 a 0.9636.
Recall: 0.7162 → No es tan alto como la precisión, lo que indica que el modelo pierde algunos casos de fraude (falsos negativos).
F1-score: 0.8217 → Es un buen equilibrio entre precisión y recall, pero esto sugiere que aún hay margen de mejora en la captura de fraudes (recall).

Veamos como se comporta nuestra curva ROC.

y_pred_proba = best_model.predict_proba(X_test)[:,1]
fpr, tpr, _ = roc_curve(y_test,y_pred_proba)
auc = roc_auc_score(y_test,y_pred_proba)
plt.plot([0,1],[0,1],'k--')
plt.plot(fpr,tpr,label=f"ROC CURVE (AUC): {auc:.2f}")
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Curva ROC')
plt.legend(loc='best')
plt.show()

Tenemos un alto AUC Score 0.93 lo cual indica una muy buena capacidad para separar clases.

4.1. Ajustar el Umbral de clasificación (Clase 1:Fraude)

Para finaliza realizare un ajuste en cuanto a los umbrales para clasificar los datos como fraude, como "estandar" siempre colocamos un 50% o 0.5, pero podemos ir variandolo para ver como cambian las metricas de evaluación del modelo.

#from sklearn.metrics import precision_score, recall_score, f1_score

thresholds = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]  # Diferentes umbrales para probar
for threshold in thresholds:
    y_pred_adjusted = (y_pred_proba >= threshold).astype(int)  # Ajustar el umbral
    precision = precision_score(y_test, y_pred_adjusted)
    recall = recall_score(y_test, y_pred_adjusted)
    f1 = f1_score(y_test, y_pred_adjusted)
    print(f"Threshold: {threshold}, Precision: {precision:.4f}, Recall: {recall:.4f}, F1: {f1:.4f}")

Si observamos los datos a medida que cambia el threshold, precision, recall y f1-score tambien lo hacen. Veamoslo con un gráfico para tenerlo más claro.

#from sklearn.metrics import precision_recall_curve

precision, recall, thresholds = precision_recall_curve(y_test, y_pred_proba)

plt.plot(thresholds, precision[:-1], 'b--', label='Precision')
plt.plot(thresholds, recall[:-1], 'g-', label='Recall')
plt.xlabel('Threshold')
plt.legend(loc='best')
plt.title('Precision-Recall vs Threshold')
plt.show()

Como vemos tenemos dos líneas que van tomando diferentes valores según el threshold dado, estás líneas son de las métricas de nuestro mayor interés recall y precision, para elegir un threshold podriamos simplemente elegir el punto de intersección, sin embargo hay algunas cosas que debemos de considerar las cual veremos a detalle en las conclusiones.

Sin embargo me gustaría decir que la elección de un modelo que equilibre precisión y recall es crucial en un entorno bancario, ya que un modelo que clasifica correctamente las transacciones fraudulentas (alto recall) reduce las pérdidas económicas por fraude y protege al cliente. Al mismo tiempo, minimizar los falsos positivos es esencial para evitar la incomodidad de bloquear transacciones legítimas, lo que puede llevar a la insatisfacción del cliente y pérdidas de fidelización. Random Forest, al ofrecer una buena combinación de estas métricas, se presenta como una herramienta eficaz para este tipo de problemas, alineándose con los objetivos del negocio: proteger a los clientes y optimizar los recursos operativos.

5. Conclusiones finales

El objetivo principal es maximizar la detección de fraudes (priorizando el recall), un umbral alrededor de 0.1 podría ser una buena elección. Aunque la precisión es relativamente baja (80%), el recall es el más alto (81.08%), capturando la mayoría de los fraudes a costa de aumentar los falsos positivos, teniendo el cuenta que es "mejor" clasificar una transacción como fraudulenta cuando no lo es, que clasificar una transacción como no fraudulenta cuando realmente lo es.

Para un balance entre precisión y recall, el umbral de 0.2 o 0.3 parece proporcionar un buen equilibrio. Con un F1-score de aproximadamente 0.83 y una precisión por encima del 89%, estos umbrales podrían ser más apropiados si se desea mantener una buena precisión sin sacrificar demasiado el recall.

Deberíamos de evaluar el impacto operativo de los falsos positivos en nuestra aplicación. Si los costos asociados con los falsos positivos son manejables, se podría optar por un umbral más bajo para asegurar una detección más exhaustiva de fraudes.

Como paso final se puede probar estos umbrales en una fase piloto para observar el impacto práctico de los ajustes en el entorno de producción. También sería útil visualizar la curva Precision-Recall para estos umbrales y observar gráficamente el trade-off.

Si crees que se puedan incluir mejoras o alguna parte del código no te funciona, hazmelo saber, te ayudaré con gusto :).

"Debugging es como ser un detective en una novela en la que tú mismo escribiste el guion... pero olvidaste el final. Sigue adelante, ¡cada error es un paso hacia el éxito!"

Edgar Cajusol - Data Scientist - Creando impacto un modelo a la vez.
https://www.linkedin.com/in/edgarcajusol/