SundayTheQuant

Análisis de Datos para A/B Testing con Python: Diseña, Ejecuta y Evalúa Experimentos

## Dominando el A/B Testing con Python: Una Guía Práctica para la Toma de Decisiones Basada en Datos

¡Hola a todos los entusiastas de los datos! Soy [Tu Nombre/Sunday the Quant] y hoy vamos a sumergirnos en el fascinante mundo del A/B testing. Si alguna vez te has preguntado cómo las grandes empresas deciden qué versión de su producto o página web es la mejor, la respuesta muy probablemente sea a través de los tests A/B. En este artículo, no solo exploraremos la teoría detrás de esta poderosa herramienta, sino que también la pondremos en práctica utilizando Python con un dataset real, paso a paso, para que puedas replicar y aplicar este conocimiento en tus propios proyectos.

## Introducción: La Importancia del A/B Testing

En la era actual, la toma de decisiones basada en datos es fundamental. El A/B testing, también conocido como pruebas de división, es una metodología experimental que nos permite comparar dos versiones (A y B) de un mismo elemento para determinar cuál de ellas funciona mejor. Ya sea que estemos hablando de un nuevo diseño de botón en una página web, el texto de un anuncio, o una característica de producto, el A/B testing nos da la confianza estadística para saber si un cambio realmente genera un impacto positivo. Sin estas pruebas, estaríamos navegando a ciegas, basando nuestras decisiones en suposiciones en lugar de en evidencia empírica. Mi objetivo hoy es mostrarte cómo puedes dominar esta técnica esencial para cualquier científico o analista de datos.

## Metodología: Diseñando Nuestro Experimento A/B

Antes de sumergirnos en el código, es crucial entender la metodología detrás de un buen A/B test. Un experimento bien diseñado es la base para obtener resultados válidos y accionables.

### 1. Formulación de Hipótesis

Todo A/B test comienza con una hipótesis. Generalmente, formulamos dos hipótesis:
* **Hipótesis Nula (H₀):** No hay diferencia significativa entre el grupo de control (A) y el grupo de tratamiento (B). Cualquier diferencia observada es debida al azar.
* **Hipótesis Alternativa (H₁):** Existe una diferencia significativa entre el grupo de control (A) y el grupo de tratamiento (B). El cambio implementado en el grupo B tiene un efecto.

Para nuestro ejemplo, utilizaremos un dataset que simula una prueba A/B en una página de destino. Queremos saber si una “nueva página” (grupo de tratamiento) tiene una tasa de conversión diferente a la “página antigua” (grupo de control).

* H₀: La tasa de conversión de la nueva página es igual a la de la página antigua.
* H₁: La tasa de conversión de la nueva página es diferente a la de la página antigua.

### 2. Definición de Métricas Clave

La métrica clave a evaluar es la *tasa de conversión*, que se define como el número de usuarios que realizaron una acción deseada (ej. una compra, un registro) dividido por el número total de usuarios expuestos a esa versión. Es una métrica binaria (convertido/no convertido).

### 3. Cálculo del Tamaño de Muestra

El tamaño de muestra es crítico para asegurar que nuestro experimento tenga suficiente poder estadístico para detectar una diferencia real si es que existe, y para evitar sacar conclusiones erróneas. Necesitamos definir:
* **Nivel de significancia (α):** La probabilidad de rechazar la hipótesis nula cuando es verdadera (error Tipo I). Comúnmente 0.05.
* **Poder estadístico (1 – β):** La probabilidad de rechazar correctamente la hipótesis nula cuando es falsa (1 menos error Tipo II). Comúnmente 0.80.
* **Efecto mínimo detectable (MDE):** La diferencia mínima en la métrica que consideramos significativa para detectar.

Para tasas de conversión, podemos usar la fórmula para dos proporciones. Simularemos un cálculo de tamaño de muestra con valores razonables.

### 4. Ejecución y Recopilación de Datos (Simulación)

En un escenario real, asignaríamos aleatoriamente usuarios a los grupos A y B y recopilaríamos datos. Nuestro dataset ya tiene esta estructura, con columnas `group` (control o treatment) y `converted` (0 o 1). Esto simula perfectamente el resultado de un experimento A/B.

**Instrucciones para Obtener el Dataset:**
El dataset que utilizaremos se llama “A/B Testing Dataset” y está disponible en Kaggle. Puedes descargarlo directamente desde el siguiente enlace: [https://www.kaggle.com/datasets/amirmotefaker/ab-testing-dataset](https://www.kaggle.com/datasets/amirmotefaker/ab-testing-dataset). Una vez descargado, asegúrate de colocar el archivo `ab_test_data.csv` en el mismo directorio donde ejecutes tu código Python o proporciona la ruta completa al archivo.

## Códigos: Análisis de Datos con Python

Ahora es el momento de ensuciarnos las manos con Python. Asegúrate de tener instaladas las librerías necesarias: `pandas`, `numpy`, `scipy`, `matplotlib`, y `seaborn`. Si no las tienes, puedes instalarlas usando `pip`:
`pip install pandas numpy scipy matplotlib seaborn statsmodels`

### 1. Preparación del Ambiente y Carga de Datos

Comenzaremos importando las librerías y cargando nuestro dataset.


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

# Cargar el dataset
try:
    df = pd.read_csv('ab_test_data.csv')
    print("Dataset cargado exitosamente.")
except FileNotFoundError:
    print("Error: El archivo 'ab_test_data.csv' no fue encontrado. Asegúrate de que está en el directorio correcto.")
    exit()

# Mostrar las primeras filas y la información general
print("Primeras 5 filas del dataset:")
print(df.head())
print("\nInformación del dataset:")
print(df.info())
print("\nValores únicos en la columna 'group':")
print(df['group'].unique())
print("\nValores únicos en la columna 'landing_page':")
print(df['landing_page'].unique())

Como podemos ver, el dataset ya tiene las columnas `group` y `landing_page` que nos permiten identificar los grupos de control y tratamiento, y la columna `converted` que es nuestra métrica de interés. La columna `group` tiene ‘control’ y ‘treatment’, y `landing_page` tiene ‘old_page’ y ‘new_page’. Necesitamos asegurarnos de que ‘control’ se asocia con ‘old_page’ y ‘treatment’ con ‘new_page’. Si no es el caso, deberíamos limpiar o reasignar. Afortunadamente, en este dataset, parecen estar correctamente alineados.

### 2. Limpieza y Preprocesamiento de Datos

Verificaremos si hay inconsistencias donde un usuario del grupo de control vea la `new_page` o viceversa.


# Asegurarnos de que 'control' group solo vea 'old_page' y 'treatment' solo vea 'new_page'
# Contar las inconsistencias
inconsistencies_control = df[(df['group'] == 'control') & (df['landing_page'] == 'new_page')].shape[0]
inconsistencies_treatment = df[(df['group'] == 'treatment') & (df['landing_page'] == 'old_page')].shape[0]

if inconsistencies_control > 0 or inconsistencies_treatment > 0:
    print(f"\nInconsistencias detectadas: {inconsistencies_control} usuarios de control en new_page, {inconsistencies_treatment} usuarios de tratamiento en old_page.")
    # Si hay inconsistencias, podríamos optar por eliminarlas o reasignarlas.
    # Para este ejercicio, asumiremos que no hay inconsistencias significativas o las limpiaremos.
    df_clean = df[((df['group'] == 'control') & (df['landing_page'] == 'old_page')) |
                  ((df['group'] == 'treatment') & (df['landing_page'] == 'new_page'))]
    print("Dataset limpiado de inconsistencias.")
else:
    df_clean = df.copy()
    print("\nNo se encontraron inconsistencias en la asignación de grupos/páginas.")

# Verificar duplicados
print(f"\nNúmero total de filas antes de eliminar duplicados: {df_clean.shape[0]}")
df_clean.drop_duplicates(subset=['user_id'], inplace=True)
print(f"Número total de filas después de eliminar duplicados: {df_clean.shape[0]}")

# Separar los grupos
control_group = df_clean[df_clean['group'] == 'control']
treatment_group = df_clean[df_clean['group'] == 'treatment']

print(f"\nTamaño del grupo de control: {len(control_group)}")
print(f"Tamaño del grupo de tratamiento: {len(treatment_group)}")

### 3. Cálculo del Tamaño de Muestra

Aunque ya tenemos un dataset, es útil saber cómo calcularíamos el tamaño de muestra necesario antes de ejecutar un experimento. Esto nos asegura que el experimento es lo suficientemente grande como para detectar una diferencia real. Utilizaremos el módulo `statsmodels.stats.proportion.prop_confint`.


from statsmodels.stats.power import GofChisquarePower
from statsmodels.stats.proportion import proportions_ztest, proportion_confint

# Parámetros para el cálculo del tamaño de muestra
alpha = 0.05  # Nivel de significancia
power = 0.80  # Poder estadístico deseado
# Tasas de conversión base y esperada (estimaciones previas o MDE)
# Supongamos que la tasa de conversión actual (control) es del 12%
p1 = 0.12
# Y esperamos una mejora a, por ejemplo, el 14% (tratamiento)
p2 = 0.14
effect_size = sm.stats.proportion.proportion_effectsize(p1, p2)

# Calcular el tamaño de muestra
# Para una prueba de proporciones con dos muestras independientes
sample_size_calculator = GofChisquarePower()
required_n = sample_size_calculator.solve_power(
    effect_size=effect_size,
    alpha=alpha,
    power=power,
    alternative='two-sided'
)

print(f"\nPara detectar un efecto del {effect_size:.4f} (de {p1:.2f} a {p2:.2f})")
print(f"con alfa={alpha} y poder={power}, se necesitan aproximadamente {int(np.ceil(required_n))} observaciones por grupo.")
print(f"Total de observaciones requeridas: {int(np.ceil(required_n * 2))}")

Este cálculo nos da una idea del tamaño de experimento que deberíamos haber planificado. Para nuestro dataset actual, verificaremos si el tamaño de nuestra muestra es suficiente.

### 4. Estadísticas Descriptivas y Visualización

Antes de las pruebas estadísticas, analicemos las estadísticas descriptivas de cada grupo.


# Estadísticas descriptivas
conversion_rates = df_clean.groupby('group')['converted'].agg(['mean', 'count', 'sum'])
conversion_rates.columns = ['conversion_rate', 'total_users', 'converted_users']
print("\nTasas de Conversión por Grupo:")
print(conversion_rates)

# Visualización de las tasas de conversión
plt.figure(figsize=(8, 6))
sns.barplot(x=conversion_rates.index, y=conversion_rates['conversion_rate'], palette='viridis')
plt.title('Tasa de Conversión por Grupo')
plt.xlabel('Grupo')
plt.ylabel('Tasa de Conversión')
plt.ylim(0, 0.2) # Ajustar el límite y si es necesario
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()

# Histograma de conversiones (aunque para binaria no es muy informativo)
# Boxplot no aplica directamente a una variable binaria como 'converted' de esta forma.
# Mejor visualización para binarias es la proporción.

La gráfica de barras nos permite una comparación visual rápida entre las tasas de conversión de ambos grupos.

### 5. Pruebas de Hipótesis Estadísticas

Dado que nuestra métrica es una tasa de conversión (proporción binaria), la prueba estadística adecuada es una prueba Z para dos proporciones. También podemos utilizar la prueba chi-cuadrada para la independencia, que es equivalente en este contexto.


# Preparar datos para la prueba Z de proporciones
count_control = conversion_rates.loc['control', 'converted_users']
nobs_control = conversion_rates.loc['control', 'total_users']
count_treatment = conversion_rates.loc['treatment', 'converted_users']
nobs_treatment = conversion_rates.loc['treatment', 'total_users']

# Realizar la prueba Z para dos proporciones
z_stat, p_value = proportions_ztest([count_control, count_treatment],
                                    [nobs_control, nobs_treatment],
                                    alternative='two-sided')

print(f"\nResultados de la Prueba Z para Dos Proporciones:")
print(f"Estadístico Z: {z_stat:.4f}")
print(f"P-valor: {p_value:.4f}")

# Calcular intervalos de confianza para las tasas de conversión
ci_control_low, ci_control_upp = proportion_confint(count_control, nobs_control, alpha=alpha, method='normal')
ci_treatment_low, ci_treatment_upp = proportion_confint(count_treatment, nobs_treatment, alpha=alpha, method='normal')

print(f"\nIntervalo de Confianza del {100*(1-alpha)}% para la Tasa de Conversión (Control): [{ci_control_low:.4f}, {ci_control_upp:.4f}]")
print(f"Intervalo de Confianza del {100*(1-alpha)}% para la Tasa de Conversión (Tratamiento): [{ci_treatment_low:.4f}, {ci_treatment_upp:.4f}]")

# Visualización de las tasas de conversión con intervalos de confianza
conversion_rates_df = pd.DataFrame({
    'group': conversion_rates.index,
    'conversion_rate': conversion_rates['conversion_rate'],
    'ci_lower': [ci_control_low, ci_treatment_low],
    'ci_upper': [ci_control_upp, ci_treatment_upp]
})

plt.figure(figsize=(10, 7))
plt.errorbar(conversion_rates_df['group'], conversion_rates_df['conversion_rate'],
             yerr=[conversion_rates_df['conversion_rate'] - conversion_rates_df['ci_lower'],
                   conversion_rates_df['ci_upper'] - conversion_rates_df['conversion_rate']],
             fmt='o', capsize=5, markersize=8, color='blue', ecolor='red')
plt.title('Tasas de Conversión con Intervalos de Confianza del 95%')
plt.xlabel('Grupo')
plt.ylabel('Tasa de Conversión')
plt.ylim(0, 0.2)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()

### 6. Interpretación de Resultados

El **P-valor** es nuestra clave aquí.
* Si el P-valor es menor que nuestro nivel de significancia (α = 0.05), rechazamos la hipótesis nula. Esto significa que la diferencia observada entre los grupos es estadísticamente significativa y no es probable que se deba al azar.
* Si el P-valor es mayor que α, no podemos rechazar la hipótesis nula. Esto sugiere que no hay evidencia suficiente para decir que existe una diferencia significativa entre los grupos.

Los **intervalos de confianza** nos dan un rango de valores plausibles para la verdadera tasa de conversión de cada grupo. Si los intervalos de confianza para los dos grupos no se solapan, esto refuerza la idea de una diferencia significativa.

### 7. Validación de Supuestos Estadísticos

Para la prueba Z de proporciones, los supuestos clave son:
* **Independencia:** Las observaciones dentro de cada grupo y entre grupos son independientes (asegurado por la asignación aleatoria).
* **Suficiente tamaño de muestra:** El número de éxitos y fracasos en cada grupo debe ser suficientemente grande (generalmente al menos 5 o 10). Esto es crucial para que la aproximación normal sea válida.


# Verificar el supuesto de tamaño de muestra suficiente
print("\nVerificación de supuestos para la prueba de proporciones:")
print(f"Éxitos (convertidos) en Control: {count_control}")
print(f"Fracasos (no convertidos) en Control: {nobs_control - count_control}")
print(f"Éxitos (convertidos) en Tratamiento: {count_treatment}")
print(f"Fracasos (no convertidos) en Tratamiento: {nobs_treatment - count_treatment}")

if (count_control >= 5 and (nobs_control - count_control) >= 5 and
    count_treatment >= 5 and (nobs_treatment - count_treatment) >= 5):
    print("El supuesto de tamaño de muestra suficiente se cumple.")
else:
    print("Advertencia: El supuesto de tamaño de muestra suficiente podría no cumplirse. Considerar usar pruebas exactas si los conteos son bajos.")


📊 Salida:

Verificación de supuestos para la prueba de proporciones:


Si los conteos de éxitos o fracasos fueran muy bajos en alguno de los grupos, deberíamos considerar una prueba exacta de Fisher en lugar de la prueba Z.

### 8. Análisis de Sensibilidad y Robustez

Un análisis de sensibilidad implica ver cómo nuestros resultados cambian si modificamos el nivel de significancia (alfa) o si hubiéramos definido la métrica de manera ligeramente diferente. Por ejemplo, si aumentamos alfa a 0.10, ¿cambiaría nuestra conclusión?


# Análisis de sensibilidad: ¿Qué pasa si cambiamos alfa a 0.10?
alpha_sensitive = 0.10
z_stat_sens, p_value_sens = proportions_ztest([count_control, count_treatment],
                                             [nobs_control, nobs_treatment],
                                             alternative='two-sided')
print(f"\nAnálisis de Sensibilidad (alfa = {alpha_sensitive}):")
print(f"P-valor: {p_value_sens:.4f}")
if p_value_sens < alpha_sensitive:
    print(f"Con alfa={alpha_sensitive}, rechazaríamos H₀. Hay una diferencia significativa.")
else:
    print(f"Con alfa={alpha_sensitive}, no rechazaríamos H₀. No hay una diferencia significativa.")

# Si los supuestos no se cumplieran o para mayor robustez, podríamos mencionar pruebas no paramétricas.
# Aunque para proporciones, la prueba Z es la estándar si el tamaño de muestra es adecuado.
# Para datos continuos con no normalidad o heterocedasticidad, se considerarían pruebas como Mann-Whitney U.

## Conclusiones: Toma de Decisiones Basada en Datos

Basados en el P-valor de nuestra prueba Z:
* Si P-valor < 0.05: Podemos concluir con un 95% de confianza que la nueva página (tratamiento) tiene una tasa de conversión estadísticamente diferente a la página antigua (control). Si la tasa de la nueva página es mayor, deberíamos implementarla.
* Si P-valor ≥ 0.05: No tenemos suficiente evidencia estadística para afirmar que la nueva página es significativamente diferente en términos de tasa de conversión. En este caso, mantener la página antigua es la decisión más prudente, o se podría considerar un nuevo experimento con un diseño diferente o un mayor tamaño de muestra si la diferencia observada (aunque no significativa) es de interés práctico.

Recuerda que un resultado no significativo no significa que no haya *ninguna* diferencia, sino que no la detectamos con la confianza deseada. El poder estadístico y el tamaño de muestra son clave aquí.

El A/B testing es una herramienta indispensable para cualquier profesional de datos que busque optimizar productos y experiencias. Nos permite pasar de la intuición a la evidencia, garantizando que cada cambio que implementamos esté respaldado por datos sólidos.

## Promoción

¡Espero que este artículo te haya dado una visión clara y práctica de cómo realizar un A/B testing con Python! Si te apasiona el mundo de los datos y quieres profundizar mucho más, te invito a echar un vistazo a mi curso completo de Ciencia de Datos con Python y R en Udemy. Allí cubrimos desde los fundamentos hasta técnicas avanzadas, incluyendo más a fondo el A/B testing, machine learning y mucho más.

Puedes encontrar el curso aquí: [https://www.udemy.com/course/ciencia-de-datos-con-python-r/?referralCode=B9A5A600EEECE5E538C1](https://www.udemy.com/course/ciencia-de-datos-con-python-r/?referralCode=B9A5A600EEECE5E538C1)

¡Gracias por leer y **recuerda que siempre siempre vas a aprender un bit a la vez!**

🤖 Automatiza tu trading en 5 días con Python

Únete a mi Mini-Curso gratuito por email. Aprende a extraer datos reales, crear indicadores cuantitativos y hacer backtesting profesional.