Aprendizaje no supervisado y sistemas de recomendación

📐 Fundamento

Algoritmo K-means:

1. Elegir K centroides aleatorios
2. Repetir hasta convergencia:
   a. Asignar cada punto al centroide más cercano
   b. Recalcular el centroide de cada cluster (promedio de sus puntos)

Implementación:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Datos de clientes: [gasto_promedio, frecuencia_mensual]
clientes = np.array([
    [5, 2], [8, 3], [4, 1], [50, 8], [60, 10], [55, 9],
    [25, 4], [30, 5], [28, 6], [100, 15], [90, 12], [110, 14]
])

# Escalar (K-means es sensible a la escala)
scaler = StandardScaler()
clientes_scaled = scaler.fit_transform(clientes)

# Determinar K óptimo con el método del codo
inercias = []
for k in range(1, 9):
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(clientes_scaled)
    inercias.append(km.inertia_)  # suma de distancias^2 a centroide

# Graficar: buscar el "codo" en la curva
plt.plot(range(1, 9), inercias, 'bx-')
plt.xlabel('K')
plt.ylabel('Inercia (WCSS)')
plt.title('Método del codo')

# Entrenar con K=3 (asumiendo que el codo está en 3)
km = KMeans(n_clusters=3, random_state=42, n_init=10)
etiquetas = km.fit_predict(clientes_scaled)
centroides = scaler.inverse_transform(km.cluster_centers_)

print("Centroides (escala original):")
for i, c in enumerate(centroides):
    print(f"  Cluster {i}: gasto=${c[0]:.0f}, frecuencia={c[1]:.0f}/mes")

# Posible interpretación:
# Cluster 0: "Clientes ocasionales" (gasto bajo, visitan poco)
# Cluster 1: "Clientes frecuentes" (gasto medio, visitan seguido)
# Cluster 2: "Clientes VIP" (gasto alto, muy frecuentes)

Métricas de calidad del clustering:

from sklearn.metrics import silhouette_score, davies_bouldin_score

# Silhouette score: [-1, 1], más alto es mejor
# Mide qué tan bien separados están los clusters
sil = silhouette_score(clientes_scaled, etiquetas)
print(f"Silhouette score: {sil:.3f}")  # > 0.5 es bueno

# Davies-Bouldin: [0, ∞), más bajo es mejor
db = davies_bouldin_score(clientes_scaled, etiquetas)
print(f"Davies-Bouldin: {db:.3f}")

Limitaciones de K-means:

• Requiere especificar K de antemano.
• Asume clusters esféricos — falla con formas irregulares.
• Sensible a outliers.
• Sensible a la inicialización (K-means++ mejora esto).
• No funciona bien con alta dimensionalidad.

Alternativas:

• DBSCAN: detecta clusters de forma arbitraria, identifica outliers.
• Hierarchical clustering: construye un árbol de clusters (no requiere K a priori).
• Gaussian Mixture Models: versión "blanda" de K-means con probabilidades.

📐 Fundamento

PCA — Principal Component Analysis:

from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

# Supongamos que cada cliente tiene un vector de 50 features
# (cuántas veces pidió cada platillo)
X = np.random.rand(200, 50)  # 200 clientes, 50 platillos

# Reducir a 2 dimensiones para visualización
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X)

print(f"Varianza explicada por PC1: {pca.explained_variance_ratio_[0]:.1%}")
print(f"Varianza explicada por PC2: {pca.explained_variance_ratio_[1]:.1%}")
print(f"Total: {sum(pca.explained_variance_ratio_):.1%}")

# Visualizar
plt.scatter(X_2d[:, 0], X_2d[:, 1], alpha=0.6)
plt.xlabel('Componente Principal 1')
plt.ylabel('Componente Principal 2')
plt.title('Clientes en espacio reducido')

# Elegir n_components que expliquen el 95% de la varianza
pca_95 = PCA(n_components=0.95)  # sklearn elige n automáticamente
X_reducido = pca_95.fit_transform(X)
print(f"Dimensiones para 95% varianza: {X_reducido.shape[1]}")

PCA antes de K-means:

# Pipeline: PCA + K-means (práctica recomendada)
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA(n_components=10)),  # reducir a 10 dims
    ('kmeans', KMeans(n_clusters=4, random_state=42))
])
pipeline.fit(X)
etiquetas = pipeline.predict(X)

📐 Fundamento

Tipos de sistemas de recomendación:

Collaborative filtering basado en memoria:

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# Matriz usuario-platillo: filas=clientes, columnas=platillos
# Valores: cuántas veces lo pidió (0 = nunca)
ratings = np.array([
    # P1  P2  P3  P4  P5  P6
    [5,   3,  0,  0,  1,  2],  # Ana
    [4,   0,  4,  1,  0,  0],  # Beto
    [0,   3,  0,  5,  3,  0],  # Carlos
    [0,   0,  5,  4,  0,  3],  # Diana
    [1,   0,  0,  0,  5,  4],  # Elena
])
usuarios = ['Ana', 'Beto', 'Carlos', 'Diana', 'Elena']
platillos = ['Pupusa queso', 'Pupusa loroco', 'Tamales', 'Yuca', 'Refresco', 'Postre']

# Similitud coseno entre usuarios
sim_usuarios = cosine_similarity(ratings)
print("Similitudes:")
for i, u in enumerate(usuarios):
    similares = [(usuarios[j], sim_usuarios[i,j]) for j in range(len(usuarios)) if i != j]
    similares.sort(key=lambda x: -x[1])
    print(f"  {u}: más similar a {similares[0][0]} ({similares[0][1]:.2f})")

def recomendar(usuario_idx, n_recomendaciones=3):
    usuario = ratings[usuario_idx]
    similitudes = sim_usuarios[usuario_idx]
    
    # Calcular score predicho para cada platillo no pedido
    scores = np.zeros(ratings.shape[1])
    for j in range(len(usuarios)):
        if j != usuario_idx:
            scores += similitudes[j] * ratings[j]
    
    # Excluir platillos ya pedidos
    scores[usuario > 0] = -1
    
    # Top N recomendaciones
    top_n = np.argsort(scores)[::-1][:n_recomendaciones]
    return [(platillos[i], scores[i]) for i in top_n if scores[i] > 0]

print("\nRecomendaciones para Ana:")
for plato, score in recomendar(0):
    print(f"  {plato}: {score:.2f}")

Matrix Factorization (SVD) — el algoritmo de Netflix:

from sklearn.decomposition import TruncatedSVD

# Factorizar la matriz ratings en factores latentes
n_factors = 3
svd = TruncatedSVD(n_components=n_factors)
user_factors = svd.fit_transform(ratings)
item_factors = svd.components_.T

# Reconstruir ratings predichos
ratings_pred = user_factors @ item_factors.T

print("Ratings predichos para Ana:")
for i, (plato, pred) in enumerate(zip(platillos, ratings_pred[0])):
    actual = ratings[0, i]
    print(f"  {plato}: real={actual}, pred={pred:.1f}")

Métricas de evaluación:

from sklearn.metrics import mean_squared_error
import numpy as np

# Dividir en train/test (ocultar algunos ratings reales)
# Evaluar con RMSE (Root Mean Squared Error)
rmse = np.sqrt(mean_squared_error(ratings_conocidos, ratings_predichos))
print(f"RMSE: {rmse:.3f}")  # menor es mejor

# Precision@K: de las K recomendaciones, ¿cuántas fueron relevantes?
# Recall@K: de todos los ítems relevantes, ¿cuántos recomendé?