Aprendizaje No Supervisado: clustering, asociacion y reduccion de dimensionalidad

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs, make_moons
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score, davies_bouldin_score
import seaborn as sns

# Dataset con 4 clusters reales
X, y_real = make_blobs(n_samples=400, centers=4, cluster_std=1.0, random_state=42)
X_scaled = StandardScaler().fit_transform(X)

# Evaluar K=2..9 con TRES criterios
K_range = range(2, 10)
inercias, silhouettes, dbi = [], [], []

for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X_scaled)
    inercias.append(km.inertia_)
    silhouettes.append(silhouette_score(X_scaled, labels))
    dbi.append(davies_bouldin_score(X_scaled, labels))

# Visualizacion
fig, axes = plt.subplots(1, 3, figsize=(15, 4))
axes[0].plot(K_range, inercias, 'o-', color='#06B6D4', linewidth=2)
axes[0].set_title('Inercia (metodo del codo)')
axes[0].set_xlabel('K')

axes[1].plot(K_range, silhouettes, 'o-', color='#10B981', linewidth=2)
axes[1].axvline(4, color='red', linestyle='--', alpha=0.5)
axes[1].set_title('Silhouette (mayor = mejor)')
axes[1].set_xlabel('K')

axes[2].plot(K_range, dbi, 'o-', color='#8B5CF6', linewidth=2)
axes[2].axvline(4, color='red', linestyle='--', alpha=0.5)
axes[2].set_title('Davies-Bouldin (menor = mejor)')
axes[2].set_xlabel('K')

for ax in axes:
    sns.despine(ax=ax)
    ax.grid(alpha=0.3, linestyle='--')
plt.tight_layout()
plt.show()

# K=4 es la eleccion optima segun los 3 criterios
# Y coincide con la verdad del dataset sintetico

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import DBSCAN
from sklearn.neighbors import NearestNeighbors
import seaborn as sns

X, _ = make_moons(n_samples=300, noise=0.08, random_state=42)
X_scaled = StandardScaler().fit_transform(X)

# METODO DEL k-DISTANCE PLOT para elegir eps
# Para cada punto, calculamos la distancia a su k-esimo vecino (k = min_samples)
k = 5
nn = NearestNeighbors(n_neighbors=k)
nn.fit(X_scaled)
distances, _ = nn.kneighbors(X_scaled)
kth_distances = distances[:, k-1]
kth_distances_sorted = np.sort(kth_distances)[::-1]

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(range(len(kth_distances_sorted)), kth_distances_sorted, color='#06B6D4', linewidth=1.5)
ax.set_xlabel('Puntos ordenados')
ax.set_ylabel(f'Distancia al {k}-esimo vecino')
ax.set_title(f'k-Distance Plot: buscar el "codo" para elegir eps (k = min_samples = {k})')
ax.grid(alpha=0.3, linestyle='--')
sns.despine(ax=ax)
plt.tight_layout()
plt.show()

# Si el codo esta en ~0.3, ese es tu eps.
# Luego DBSCAN(eps=0.3, min_samples=5)
dbscan = DBSCAN(eps=0.3, min_samples=5)
labels = dbscan.fit_predict(X_scaled)
n_outliers = (labels == -1).sum()
print(f"Clusters encontrados: {len(set(labels)) - (1 if -1 in labels else 0)}")
print(f"Outliers: {n_outliers} ({n_outliers/len(labels):.1%})")

# pip install mlxtend
import pandas as pd
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori, association_rules

# Dataset de transacciones de un kiosko
transacciones = [
    ['pan', 'manteca', 'cafe'],
    ['pan', 'manteca'],
    ['leche', 'manteca', 'galletas'],
    ['cafe', 'galletas'],
    ['pan', 'cafe'],
    ['leche', 'galletas'],
    ['pan', 'manteca', 'cafe', 'galletas'],
    ['leche', 'manteca'],
]

# 1) Codificar a formato one-hot
te = TransactionEncoder()
te_ary = te.fit(transacciones).transform(transacciones)
df = pd.DataFrame(te_ary, columns=te.columns_)

# 2) Itemsets frecuentes con Apriori
itemsets = apriori(df, min_support=0.4, use_colnames=True).sort_values('support', ascending=False)

# 3) Reglas de asociacion
reglas = association_rules(itemsets, metric='confidence', min_threshold=0.6)
reglas = reglas.sort_values('lift', ascending=False)

# Las 3 metricas SIEMPRE juntas
print(reglas[['antecedents', 'consequents', 'support', 'confidence', 'lift']].to_string(index=False))

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.datasets import load_wine
import seaborn as sns

# Dataset: 13 features quimicas de vinos
data = load_wine()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target
class_names = data.target_names

# 1) Escalar (OBLIGATORIO antes de PCA)
X_scaled = StandardScaler().fit_transform(X)

# 2) PCA completa
pca_full = PCA()
X_pca = pca_full.fit_transform(X_scaled)

# 3) Scree plot
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

axes[0].bar(range(1, 14), pca_full.explained_variance_ratio_ * 100, color='#06B6D4')
axes[0].plot(range(1, 14), np.cumsum(pca_full.explained_variance_ratio_) * 100, 'o-', color='red', label='Acumulado')
axes[0].axhline(80, color='gray', linestyle='--', alpha=0.5, label='80% varianza')
axes[0].set_xlabel('Componente')
axes[0].set_ylabel('% Varianza explicada')
axes[0].set_title('Scree Plot')
axes[0].legend()

# 4) Visualizar en 2D con las clases
pca_2d = PCA(n_components=2)
X_pca_2d = pca_2d.fit_transform(X_scaled)

for clase in range(3):
    mask = y == clase
    axes[1].scatter(X_pca_2d[mask, 0], X_pca_2d[mask, 1], label=class_names[clase], s=50, alpha=0.7)

axes[1].set_xlabel(f'PC1 ({pca_2d.explained_variance_ratio_[0]:.1%})')
axes[1].set_ylabel(f'PC2 ({pca_2d.explained_variance_ratio_[1]:.1%})')
axes[1].set_title(f'Vinos en 2D (PC1+PC2 = {pca_2d.explained_variance_ratio_.sum():.1%})')
axes[1].legend()

for ax in axes:
    sns.despine(ax=ax)
    ax.grid(alpha=0.3, linestyle='--')

plt.tight_layout()
plt.show()