Estudio de caso: análisis de la cesta de compra mediante algoritmos de agrupamiento (k-means) y reglas de asociación (apriori) en aprendizaje no supervisado¶

url = "https://raw.githubusercontent.com/prasertcbs/basic-dataset/master/BreadBasket_DMS.csv"
df = pd.read_csv(url)
print(f"✓ Dataset cargado exitosamente. Dimensiones iniciales: {df.shape[0]} filas y {df.shape[1]} columnas.")

# Previsualización de los primeros 10 registros
print("--- Primeros 10 registros del dataset ---")
display(df.head(10))

# Estructura general de las variables
print("\n--- Información general de los datos ---")
df.info()

# Conteo de valores nulos o vacíos
print("\n--- Conteo de valores faltantes por columna ---")
print(df.isnull().sum())

# Valores únicos en la variable de transacción e ítems
print(f"\nNúmero de facturas/transacciones únicas: {df['Transaction'].nunique()}")
print(f"Número de productos únicos en catálogo: {df['Item'].nunique()}")

# 1. Eliminar transacciones vacías marcadas como 'NONE'
none_count = df[df['Item'].str.upper() == 'NONE'].shape[0]
print(f"Registros detectados con Item='NONE': {none_count}")

df_clean = df[df['Item'].str.upper() != 'NONE'].copy()

# 2. Estandarizar nombres a minúsculas y remover espacios laterales
df_clean['Item'] = df_clean['Item'].str.strip().str.lower()

# 3. Eliminar registros duplicados dentro de la misma factura
duplicates = df_clean.duplicated(subset=['Transaction', 'Item']).sum()
print(f"Registros duplicados (mismo ítem en la misma transacción): {duplicates}")
df_clean = df_clean.drop_duplicates(subset=['Transaction', 'Item'])

# Dimensiones finales de los datos depurados
print(f"\n✓ Dimensiones finales tras depuración: {df_clean.shape[0]} filas.")
print(f"Facturas únicas finales: {df_clean['Transaction'].nunique()}")
print(f"Productos en catálogo final: {df_clean['Item'].nunique()}")

# Top 15 de productos más vendidos
top_15 = df_clean['Item'].value_counts().head(15)

plt.figure(figsize=(14, 7))
sns.barplot(x=top_15.values, y=top_15.index, palette="viridis")
plt.title("Top 15 Productos Más Vendidos - Historial Transaccional de la Panadería", fontsize=14, pad=15, fontweight='bold')
plt.xlabel("Frecuencia Absoluta (Número de Facturas)", fontsize=12, labelpad=10)
plt.ylabel("Producto", fontsize=12, labelpad=10)

# Añadir etiquetas de valores en cada barra
for index, value in enumerate(top_15.values):
    plt.text(value + 20, index, f"{value} ({value/df_clean['Transaction'].nunique()*100:.1f}%)",
             va='center', fontsize=10, fontweight='bold', color='#2c3e50')

plt.tight_layout()
plt.show()

# Construir perfil numérico por transacción
# 1. Cantidad de ítems distintos por transacción
tx_items = df_clean.groupby('Transaction')['Item'].count().reset_index()
tx_items.columns = ['Transaction', 'num_items']

# 2. Hora del día (extraer de la columna Time)
tx_time = df_clean.drop_duplicates(subset='Transaction')[['Transaction', 'Time']].copy()
tx_time['hour'] = tx_time['Time'].apply(lambda x: int(str(x).split(':')[0]) if ':' in str(x) else 12)
tx_time = tx_time[['Transaction', 'hour']]

# 3. Presencia de café en la transacción (1 = sí, 0 = no)
tx_coffee = df_clean[df_clean['Item'] == 'coffee'][['Transaction']].drop_duplicates()
tx_coffee['has_coffee'] = 1

# Unir las características
tx_profile = tx_items.merge(tx_time, on='Transaction', how='left')
tx_profile = tx_profile.merge(tx_coffee, on='Transaction', how='left')
tx_profile['has_coffee'] = tx_profile['has_coffee'].fillna(0).astype(int)

print(f"✓ Perfil de transacciones creado: {tx_profile.shape[0]} transacciones con {tx_profile.shape[1]-1} variables numéricas.")
display(tx_profile.head(10))
print("\n--- Estadísticas descriptivas del perfil ---")
display(tx_profile[['num_items', 'hour', 'has_coffee']].describe())

# Preparar datos para clustering: estandarizar las variables
features = tx_profile[['num_items', 'hour', 'has_coffee']]
scaler = StandardScaler()
features_scaled = scaler.fit_transform(features)

# Método del codo: probar K de 2 a 10
inertias = []
K_range = range(2, 11)

for k in K_range:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans.fit(features_scaled)
    inertias.append(kmeans.inertia_)

# Visualizar la curva del codo
plt.figure(figsize=(10, 6))
plt.plot(K_range, inertias, 'bo-', linewidth=2, markersize=8)
plt.title('Método del Codo - Determinación del Número Óptimo de Clústeres (K)', fontsize=14, pad=15, fontweight='bold')
plt.xlabel('Número de Clústeres (K)', fontsize=12, labelpad=10)
plt.ylabel('Inercia (Suma de distancias al cuadrado)', fontsize=12, labelpad=10)
plt.xticks(K_range)
plt.grid(True, alpha=0.3)

# Marcar el codo sugerido en K=3
plt.annotate('Codo sugerido (K=3)', xy=(3, inertias[1]), xytext=(5, inertias[1]*1.1),
             arrowprops=dict(arrowstyle='->', color='red', lw=2),
             fontsize=12, fontweight='bold', color='red',
             bbox=dict(boxstyle='round,pad=0.3', fc='yellow', alpha=0.5))

plt.tight_layout()
plt.show()

print("\nInercia por valor de K:")
for k, inertia in zip(K_range, inertias):
    print(f"  K={k}: Inercia = {inertia:,.2f}")

# Entrenar K-Means con K=3
kmeans_final = KMeans(n_clusters=3, random_state=42, n_init=10)
tx_profile['cluster'] = kmeans_final.fit_predict(features_scaled)

# Distribución de transacciones por clúster
print("✓ Distribución de transacciones por clúster:")
cluster_dist = tx_profile['cluster'].value_counts().sort_index()
for cluster_id, count in cluster_dist.items():
    pct = count / len(tx_profile) * 100
    print(f"  Clúster {cluster_id}: {count} transacciones ({pct:.1f}%)")

# Perfil promedio de cada clúster
print("\n--- Perfil promedio por clúster ---")
cluster_profile = tx_profile.groupby('cluster')[['num_items', 'hour', 'has_coffee']].mean()
cluster_profile.columns = ['Promedio Ítems', 'Hora Promedio', '% Incluye Café']
cluster_profile['% Incluye Café'] = (cluster_profile['% Incluye Café'] * 100).round(1)
display(cluster_profile.round(2))

# Scatter plot de clústeres: Hora vs Cantidad de Ítems
fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# Gráfica 1: Scatter por Hora y Número de Ítems
colors = ['#e74c3c', '#3498db', '#2ecc71']
labels = ['Clúster 0', 'Clúster 1', 'Clúster 2']

for cluster_id in range(3):
    mask = tx_profile['cluster'] == cluster_id
    axes[0].scatter(tx_profile.loc[mask, 'hour'], tx_profile.loc[mask, 'num_items'],
                    c=colors[cluster_id], label=labels[cluster_id], alpha=0.5, s=30, edgecolors='black', linewidth=0.3)

axes[0].set_title('Segmentación de Transacciones por K-Means (K=3)', fontsize=13, fontweight='bold', pad=10)
axes[0].set_xlabel('Hora del Día', fontsize=11, labelpad=8)
axes[0].set_ylabel('Cantidad de Ítems por Transacción', fontsize=11, labelpad=8)
axes[0].legend(fontsize=10)
axes[0].grid(True, alpha=0.3)

# Gráfica 2: Distribución por clúster (barras)
cluster_counts = tx_profile['cluster'].value_counts().sort_index()
bars = axes[1].bar(cluster_counts.index, cluster_counts.values, color=colors, edgecolor='black', linewidth=0.8)
axes[1].set_title('Distribución de Transacciones por Clúster', fontsize=13, fontweight='bold', pad=10)
axes[1].set_xlabel('Clúster', fontsize=11, labelpad=8)
axes[1].set_ylabel('Número de Transacciones', fontsize=11, labelpad=8)
axes[1].set_xticks([0, 1, 2])

# Etiquetas en barras
for bar, count in zip(bars, cluster_counts.values):
    axes[1].text(bar.get_x() + bar.get_width()/2., bar.get_height() + 30,
                 f'{count}\n({count/len(tx_profile)*100:.1f}%)',
                 ha='center', va='bottom', fontweight='bold', fontsize=10)

plt.tight_layout()
plt.show()

# 1. Agrupar ítems por número de transacción
transacciones = df_clean.groupby('Transaction')['Item'].apply(list).tolist()
print(f"Ejemplo de las primeras 3 transacciones agrupadas:\n{transacciones[:3]}")

# 2. Inicializar y aplicar el TransactionEncoder
te = TransactionEncoder()
te_ary = te.fit(transacciones).transform(transacciones)

# 3. Convertir la matriz booleana resultante en un DataFrame estructurado
df_encoded = pd.DataFrame(te_ary, columns=te.columns_)

print(f"\n✓ Matriz binaria transaccional creada: {df_encoded.shape[0]} filas (transacciones) y {df_encoded.shape[1]} columnas (ítems).")
display(df_encoded.head(5))

# Ejecución del algoritmo Apriori
frequent_itemsets = apriori(df_encoded, min_support=0.01, use_colnames=True)

# Ordenar los itemsets por soporte de mayor a menor
frequent_itemsets = frequent_itemsets.sort_values(by='support', ascending=False).reset_index(drop=True)

print(f"✓ Se han extraído {frequent_itemsets.shape[0]} itemsets frecuentes con soporte mínimo de 1%.")
display(frequent_itemsets.head(15))

# Generación de reglas usando confianza como métrica base
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.2)

# Filtrar por Lift > 1 para asegurar correlación positiva y ordenar por Lift descendente
rules_filtered = rules[rules['lift'] > 1.0].sort_values(by='lift', ascending=False).reset_index(drop=True)

print(f"✓ Se generaron {rules_filtered.shape[0]} reglas de asociación con Confianza >= 20% y Lift > 1.0.")

# Formatear visualización de columnas de reglas para facilitar lectura
rules_display = rules_filtered[['antecedents', 'consequents', 'antecedent support',
                                'consequent support', 'support', 'confidence', 'lift']].copy()

# Convertir sets a strings legibles
rules_display['antecedents'] = rules_display['antecedents'].apply(lambda x: ', '.join(list(x)))
rules_display['consequents'] = rules_display['consequents'].apply(lambda x: ', '.join(list(x)))

display(rules_display.head(15))

plt.figure(figsize=(12, 7))
scatter = plt.scatter(rules_filtered['support'], rules_filtered['confidence'],
                      c=rules_filtered['lift'], cmap='coolwarm', s=100, alpha=0.85, edgecolors='black')

plt.title("Distribución de Reglas de Asociación - Soporte vs Confianza", fontsize=14, pad=15, fontweight='bold')
plt.xlabel("Soporte (Frecuencia Conjunta)", fontsize=12, labelpad=10)
plt.ylabel("Confianza (Probabilidad Condicional)", fontsize=12, labelpad=10)

# Barra de color para representar el Lift
cbar = plt.colorbar(scatter)
cbar.set_label('Lift (Fuerza de la Regla)', rotation=270, labelpad=20, fontsize=12)

# Resaltar con anotaciones las 3 reglas con mayor Lift
for idx, row in rules_filtered.head(3).iterrows():
    ant_str = ", ".join(list(row['antecedents']))
    cons_str = ", ".join(list(row['consequents']))
    plt.annotate(f"{ant_str} -> {cons_str}",
                 (row['support'], row['confidence']),
                 textcoords="offset points",
                 xytext=(0,10),
                 ha='center',
                 fontsize=9,
                 fontweight='bold',
                 bbox=dict(boxstyle="round,pad=0.3", fc="yellow", alpha=0.5))

plt.tight_layout()
plt.show()