ML aplicado: pipelines, segmentacion y sistemas de recomendacion

import pandas as pd
import numpy as np
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
from sklearn.metrics import classification_report, roc_auc_score
import joblib

np.random.seed(42)
N = 2000

# Generar dataset realista: predicción de churn en una empresa de telecomunicaciones
df = pd.DataFrame({
    'tenure':          np.random.randint(1, 73, N),                # meses como cliente
    'monthly_charges': np.random.normal(65, 25, N).clip(20, 200),  # cargo mensual
    'total_charges':   np.nan,                                    # calculado
    'contract':        np.random.choice(['Mes a mes', '1 anio', '2 anios'], N, p=[0.55, 0.25, 0.2]),
    'internet':        np.random.choice(['Fibra', 'DSL', 'No'], N),
    'tech_support':    np.random.choice(['Si', 'No', np.nan], N, p=[0.4, 0.55, 0.05]),
    'churn':           np.nan,
})

# Logica de negocio: mas churn en mes-a-mes, alta factura, poca antigüedad
df['total_charges'] = df['tenure'] * df['monthly_charges'] * np.random.uniform(0.95, 1.05, N)
prob_churn = (
    (df['contract'] == 'Mes a mes') * 0.35 +
    (df['monthly_charges'] > 80) * 0.20 +
    (df['tenure'] < 12) * 0.15 +
    np.random.uniform(0, 0.1, N)
).clip(0, 1)
df['churn'] = (np.random.uniform(0, 1, N) < prob_churn).astype(int)

# Split
X = df.drop('churn', axis=1)
y = df['churn']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)

# Definir columnas por tipo
num_cols = ['tenure', 'monthly_charges', 'total_charges']
cat_cols = ['contract', 'internet', 'tech_support']

# Sub-pipeline para numericas: imputar + escalar
num_pipe = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler',  StandardScaler())
])

# Sub-pipeline para categoricas: imputar + one-hot
cat_pipe = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('ohe',     OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])

# ColumnTransformer: une ambos, aplicando a las columnas correctas
preprocessor = ColumnTransformer([
    ('num', num_pipe, num_cols),
    ('cat', cat_pipe, cat_cols)
])

# Pipeline completo: preprocesamiento + modelo
pipeline = Pipeline([
    ('prep',  preprocessor),
    ('model', RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42, n_jobs=-1))
])

# Cross-validation honesta (todo el preprocessing DENTRO del CV)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(pipeline, X_train, y_train, cv=cv, scoring='roc_auc')
print(f"AUC en CV: {scores.mean():.3f} ± {scores.std():.3f}")

# Entrenar y evaluar en test
pipeline.fit(X_train, y_train)
y_proba = pipeline.predict_proba(X_test)[:, 1]
y_pred  = pipeline.predict(X_test)
print(f"\nAUC en test: {roc_auc_score(y_test, y_proba):.3f}")
print(classification_report(y_test, y_pred, target_names=['Activo', 'Churn']))

# Persistir TODO el pipeline
joblib.dump(pipeline, 'churn_pipeline.joblib')
loaded = joblib.load('churn_pipeline.joblib')
assert loaded.score(X_test, y_test) == pipeline.score(X_test, y_test), "Error de reproducibilidad"
print("\nPipeline persistido y recargado OK")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
from sklearn.decomposition import PCA
import seaborn as sns

# Generar transacciones de 12 meses
np.random.seed(42)
N_CLIENTES = 500
N_TRANSACC = 8000

clientes = pd.DataFrame({
    'cliente_id': range(1, N_CLIENTES + 1),
    'segmento_real': np.random.choice(['VIP', 'Habitual', 'Nuevo', 'En_riesgo'], N_CLIENTES, p=[0.1, 0.5, 0.25, 0.15])
})

# Simular transacciones según segmento
fechas = pd.date_range('2023-01-01', '2023-12-31', freq='H')
trans = pd.DataFrame({
    'fecha':       np.random.choice(fechas, N_TRANSACC),
    'cliente_id':  np.random.choice(clientes['cliente_id'], N_TRANSACC),
    'monto':       np.random.lognormal(4, 1.2, N_TRANSACC).round(2)
})
trans = trans.merge(clientes, on='cliente_id')

# Calcular RFM
fecha_corte = trans['fecha'].max()
rfm = trans.groupby('cliente_id').agg(
    recency  = ('fecha', lambda x: (fecha_corte - x.max()).days),  # dias desde ultima compra
    frequency= ('fecha', 'count'),                                   # cantidad de compras
    monetary  = ('monto', 'sum')                                      # gasto total
).reset_index()
rfm = rfm.merge(clientes[['cliente_id', 'segmento_real']], on='cliente_id')

# 1) ESCALAR (obligatorio antes de K-Means)
scaler = StandardScaler()
rfm_scaled = scaler.fit_transform(rfm[['recency', 'frequency', 'monetary']])

# 2) Elegir K: metodo del codo + silhouette
inercias, silhouettes, K_range = [], [], range(2, 9)
for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(rfm_scaled)
    inercias.append(km.inertia_)
    silhouettes.append(silhouette_score(rfm_scaled, labels))

fig, axes = plt.subplots(1, 2, figsize=(12, 4))
axes[0].plot(K_range, inercias, 'o-', color='#06B6D4', linewidth=2)
axes[0].set_title('Metodo del Codo (Inercia)')
axes[0].set_xlabel('K')
axes[1].plot(K_range, silhouettes, 'o-', color='#8B5CF6', linewidth=2)
axes[1].set_title('Silhouette (mayor = mejor)')
axes[1].set_xlabel('K')
for ax in axes:
    sns.despine(ax=ax)
    ax.grid(alpha=0.3, linestyle='--')
plt.tight_layout()
plt.show()

# 3) Elegir K_optimo (acá: 4, el valor "real")
K_OPTIMO = 4
km = KMeans(n_clusters=K_OPTIMO, random_state=42, n_init=10)
rfm['cluster'] = km.fit_predict(rfm_scaled)

# 4) Visualizar con PCA 2D
pca = PCA(n_components=2, random_state=42)
coords = pca.fit_transform(rfm_scaled)
rfm['pca1'], rfm['pca2'] = coords[:, 0], coords[:, 1]

fig, ax = plt.subplots(figsize=(10, 7))
palette = sns.color_palette('viridis', K_OPTIMO)
for i, color in enumerate(palette):
    mask = rfm['cluster'] == i
    ax.scatter(rfm.loc[mask, 'pca1'], rfm.loc[mask, 'pca2'], c=[color], label=f'Cluster {i}', alpha=0.6, s=30)
ax.set_title(f'Segmentacion RFM (K={K_OPTIMO}, PCA {pca.explained_variance_ratio_.sum():.0%} varianza)')
ax.legend()
sns.despine(ax=ax)
plt.tight_layout()
plt.show()

# 5) Perfil de cada cluster (para presentar a negocio)
perfil = rfm.groupby('cluster').agg(
    n=('cliente_id', 'count'),
    recency_promedio=('recency', 'mean'),
    frequency_promedio=('frequency', 'mean'),
    monetary_promedio=('monetary', 'mean'),
).round(1)
print(perfil)

# pip install scikit-surprise
from surprise import Dataset, Reader, KNNWithMeans
from surprise.model_selection import train_test_split
from surprise import accuracy

# Ejemplo con dataset MovieLens-100k
data = Dataset.load_builtin('ml-100k', prompt=False)
trainset, testset = train_test_split(data, test_size=0.2, random_state=42)

# item-based con similitud coseno ajustada por la media
sim_options = {
    'name': 'pearson_baseline',  # usa pearson con shrinkage
    'user_based': False           # item-based
}
modelo = KNNWithMeans(sim_options=sim_options, k=40)
modelo.fit(trainset)

preds = modelo.test(testset)
print(f"RMSE: {accuracy.rmse(preds):.3f}")
print(f"MAE:  {accuracy.mae(preds):.3f}")

# Top-5 recomendaciones para un usuario
def top_n_recomendaciones(modelo, user_id, n=5):
    """Devuelve los N items con mayor prediccion para el usuario."""
    items_no_calificados = [iid for iid in modelo.trainset.all_items()
                            if not modelo.trainset.knows_user(user_id) or
                            iid not in [j for (j, _) in modelo.trainset.ur[user_id]]]
    preds = [(iid, modelo.predict(user_id, iid).est) for iid in items_no_calificados]
    return sorted(preds, key=lambda x: x[1], reverse=True)[:n]

# Uso: top_n_recomendaciones(modelo, user_id=196, n=5)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import TimeSeriesSplit
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error

# Serie temporal sintetica con tendencia
np.random.seed(42)
n = 365
t = np.arange(n)
y = 100 + 0.5 * t + 10 * np.sin(2 * np.pi * t / 30) + np.random.normal(0, 5, n)

# TimeSeriesSplit: 5 splits, cada uno entrena en el pasado y valida en el futuro
tscv = TimeSeriesSplit(n_splits=5)
fig, ax = plt.subplots(figsize=(12, 5))

for i, (train_idx, val_idx) in enumerate(tscv.split(y)):
    ax.axvspan(train_idx[0], train_idx[-1], alpha=0.15, color='blue', label='Train' if i == 0 else '')
    ax.axvspan(val_idx[0], val_idx[-1], alpha=0.25, color='orange', label='Validacion' if i == 0 else '')

ax.plot(y, color='black', linewidth=1, alpha=0.7)
ax.set_title('TimeSeriesSplit: cada fold es estrictamente en el futuro')
ax.set_xlabel('Tiempo')
ax.set_ylabel('Valor')
ax.legend()
plt.tight_layout()
plt.show()

# Comparar con KFold (incorrecto para series temporales)
from sklearn.model_selection import KFold

def comparar_splits(X, y):
    resultados = {}
    for nombre, splitter in [('K-Fold', KFold(n_splits=5, shuffle=True, random_state=42)),
                              ('TimeSeries', TimeSeriesSplit(n_splits=5))]:
        maes = []
        for train_idx, val_idx in splitter.split(X):
            modelo = LinearRegression().fit(X[train_idx], y[train_idx])
            preds = modelo.predict(X[val_idx])
            maes.append(mean_absolute_error(y[val_idx], preds))
        resultados[nombre] = (np.mean(maes), np.std(maes))
    return resultados

X = t.reshape(-1, 1)
print(comparar_splits(X, y))
# K-Fold va a dar un MAE artificialmente bajo porque "ve" el futuro
# TimeSeriesSplit da una estimacion honesta