Clustering

# %matplotlib notebook
# Esta línea permite gráficos interactivos en Jupyter Notebook. Comentada actualmente.

import numpy as np                  # Librería para cálculos numéricos y manejo de arreglos.
import pandas as pd                # Librería para manipulación de datos tipo tabla (DataFrame).
import seaborn as sns               # Librería para visualizaciones estadísticas (no usada aquí).
import matplotlib.pyplot as plt    # Librería para generar gráficos y visualizaciones.

from sklearn.datasets import make_blobs  # Función para generar datos de prueba con clústeres.
from sklearn.cluster import KMeans        # Algoritmo de clustering K-Means.
from shared_utilities import plot_labelled_scatter
# Función personalizada que genera una gráfica de dispersión con etiquetas por clúster.

# Genera un conjunto de datos aleatorio con distribución tipo clúster.
# X: coordenadas de los puntos, y: etiquetas verdaderas (no se usan aquí).
X, y = make_blobs(random_state=10)

# Crea un modelo KMeans que buscará 3 clústeres.
# n_init=20: se prueban varias inicializaciones para reducir la dependencia del punto de partida.
kmeans = KMeans(n_clusters=3, n_init=20, random_state=42)

# Ajusta el modelo KMeans a los datos generados.
kmeans.fit(X)

# Grafica los puntos en un scatter plot, usando las etiquetas que asignó KMeans.
# Cada grupo se rotula como 'Cluster 1', 'Cluster 2' o 'Cluster 3'.
plot_labelled_scatter(X, kmeans.labels_, ['Cluster 1', 'Cluster 2', 'Cluster 3'])

from sklearn.datasets import make_blobs  # (No se usa en este bloque, se podría eliminar si se desea limpiar el código)
from sklearn.cluster import KMeans       # Importa el algoritmo KMeans para clustering no supervisado.
from shared_utilities import plot_labelled_scatter  # Función externa que grafica los datos según sus etiquetas.
from sklearn.preprocessing import MinMaxScaler       # Escalador para normalizar características numéricas.
import pandas as pd                                  # Librería para manipulación de datos tabulares.

# URL del archivo de datos: contiene información de frutas con características físicas y color.
uu = 'https://raw.githubusercontent.com/vmoprojs/DataLectures/refs/heads/master/fruit_data_with_colors.txt'

# Carga los datos en un DataFrame. El archivo es de texto con separador de tabulaciones (\t).
fruits = pd.read_table(uu)

# Selecciona las variables numéricas relevantes para el modelo de clustering y las convierte en matriz NumPy.
X_fruits = fruits[['mass','width','height', 'color_score']].to_numpy()

# Obtiene las etiquetas verdaderas (por tipo de fruta) y las ajusta para comenzar desde 0. No se usan en el clustering.
y_fruits = fruits[['fruit_label']] - 1

# Normaliza los datos a un rango [0, 1] para que todas las variables tengan igual peso en el clustering.
scaler_fruits = MinMaxScaler()
X_fruits_normalized = scaler_fruits.fit_transform(X_fruits)

# Crea el modelo KMeans para 4 clústeres y utiliza varias inicializaciones.
kmeans = KMeans(n_clusters=4, n_init=20, random_state=42)

# Ajusta el modelo a los datos normalizados. El algoritmo agrupa las observaciones en 4 clústeres.
kmeans.fit(X_fruits_normalized)

# Grafica los resultados, coloreando cada punto según el clúster asignado y con etiquetas personalizadas.
plot_labelled_scatter(X_fruits_normalized, kmeans.labels_,
                      ['Cluster 1', 'Cluster 2', 'Cluster 3', 'Cluster 4'])

# Ejemplo computacional del cálculo de un medoide
puntos = np.array([1, 2, 3, 8, 10], dtype=float)

# Matriz de distancias absolutas entre todos los pares de observaciones
matriz_distancias = np.abs(puntos[:, None] - puntos[None, :])

# Suma de distancias desde cada observación hacia las demás
suma_distancias = matriz_distancias.sum(axis=1)

# La observación con la menor suma de distancias es el medoide
indice_medoide = np.argmin(suma_distancias)
medoide = puntos[indice_medoide]

etiquetas = [f"x = {int(x)}" for x in puntos]
tabla_distancias = pd.DataFrame(
    matriz_distancias,
    index=etiquetas,
    columns=etiquetas
)
tabla_distancias["Suma de distancias"] = suma_distancias

display(tabla_distancias)
print(f"Medoide: {medoide:g}")
print(f"Suma mínima de distancias: {suma_distancias[indice_medoide]:g}")

# https://scikit-learn-extra.readthedocs.io/en/latest/index.html
# Documentación oficial del paquete scikit-learn-extra, que amplía scikit-learn con algoritmos adicionales.

from sklearn_extra.cluster import KMedoids
# Importa el algoritmo K-Medoids, una alternativa a KMeans que elige observaciones reales como representantes de cada clúster (medoides).

# Crea el modelo de clustering con K-Medoids para 4 grupos y semilla fija para reproducibilidad.
kmedoides = KMedoids(n_clusters=4, metric="euclidean", method="pam", random_state=42)

# Ajusta el modelo a los datos previamente normalizados. Cada punto es asignado al medoide más cercano.
kmedoides.fit(X_fruits_normalized)

# Grafica los resultados del clustering, coloreando los puntos según su grupo asignado por K-Medoids.
# Usa etiquetas personalizadas para los 4 clústeres.
plot_labelled_scatter(X_fruits_normalized, kmedoides.labels_,
                      ['Cluster 1', 'Cluster 2', 'Cluster 3', 'Cluster 4'])

# Comparar las asignaciones obtenidas por K-means y K-medoides
tabla_cruzada = pd.crosstab(kmeans.labels_, kmedoides.labels_,
                             rownames=["KMeans"], colnames=["KMedoids"])

print(tabla_cruzada)

from sklearn.datasets import make_blobs  # Genera datos sintéticos con distribución en forma de clústeres.
from sklearn.cluster import AgglomerativeClustering  # Importa el algoritmo de clustering jerárquico aglomerativo.
from shared_utilities import plot_labelled_scatter  # Función para graficar los datos coloreados por clúster.

# Genera un conjunto de datos de ejemplo con clústeres definidos.
# X contiene las coordenadas de los puntos, y son las etiquetas reales (no se usan en el clustering).
X, y = make_blobs(random_state=10)

# Crea un modelo de agrupamiento jerárquico aglomerativo con 3 clústeres deseados.
cls = AgglomerativeClustering(n_clusters=3)

# Ajusta el modelo a los datos y devuelve las asignaciones de clúster para cada punto.
cls_assignment = cls.fit_predict(X)

# Grafica los datos, coloreando cada punto según el clúster asignado por el modelo.
# Se añaden etiquetas personalizadas para facilitar la interpretación visual.
plot_labelled_scatter(X, cls_assignment, 
                      ['Cluster 1', 'Cluster 2', 'Cluster 3'])

X, y = make_blobs(random_state = 10, n_samples = 10)
plot_labelled_scatter(X, y, 
        ['Cluster 1', 'Cluster 2', 'Cluster 3'])
print(X)

from scipy.cluster.hierarchy import dendrogram,linkage
plt.figure()
dendrogram(linkage(X, 'complete'))
plt.show()

plt.figure()
plt.title('Linkage: Complete')
dendrogram(linkage(X, 'complete'))
plt.show()

plt.figure()
plt.title('Linkage: Single')
dendrogram(linkage(X, 'single'))
plt.show()

plt.figure()
plt.title('Linkage: Average')
dendrogram(linkage(X, 'average'))
plt.show()

plt.figure()
plt.title('Linkage: Centroid')
dendrogram(linkage(X, 'centroid'))
plt.show()

from sklearn.cluster import DBSCAN  # Importa el algoritmo DBSCAN para clustering basado en densidad.
from sklearn.datasets import make_blobs  # Función para generar datos sintéticos agrupados.

# Genera un conjunto de 25 puntos con estructura de clúster para pruebas.
# X: coordenadas de los puntos, y: etiquetas reales (no se usan aquí).
X, y = make_blobs(random_state=9, n_samples=25)

# Crea el modelo DBSCAN con parámetros:
# eps = 2: radio de vecindad considerado para formar un clúster.
# min_samples = 2: número mínimo de puntos para formar un clúster denso.
dbscan = DBSCAN(eps=2, min_samples=2)

# Ajusta el modelo y obtiene las etiquetas de clúster (o -1 si el punto es ruido).
cls = dbscan.fit_predict(X)

# Imprime los valores de pertenencia a clúster de cada punto.
# -1 representa ruido (puntos que no pertenecen a ningún clúster).
print("Cluster membership values:\n{}".format(cls))

# Grafica los resultados del clustering.
# Se le suma 1 a las etiquetas para que el ruido (-1) pase a 0 y así pueda graficarse como "Noise".
# Etiquetas: 'Noise' para los puntos aislados, y 'Cluster 0', 'Cluster 1', etc., para los demás.
plot_labelled_scatter(X, cls + 1, 
                      ['Noise', 'Cluster 0', 'Cluster 1', 'Cluster 2'])

uu = "https://raw.githubusercontent.com/vmoprojs/DataLectures/master/Mall_Customers.csv"
datos = pd.read_csv(uu)


dbDat = datos.iloc[:,3:5]
dbDat.describe()

plt.figure()
plt.scatter(dbDat.AnnualIncome,dbDat.SpendingScore)
plt.show()

from scipy.spatial import distance_matrix
dd = pd.DataFrame(distance_matrix(dbDat.values, dbDat.values), index=dbDat.index, columns=dbDat.index)
n = len(np.sort(dd.values))
dd = np.sort(dd.values[np.triu_indices(n, k = 1)])

plt.figure()
plt.plot(dd)
plt.show()

dbscan = DBSCAN(eps = 10, min_samples = 3)

cls = dbscan.fit_predict(dbDat)
print("Cluster membership values:\n{}".format(cls))

plot_labelled_scatter(dbDat.values, cls + 1, 
        ['Noise', 'Cluster 0', 'Cluster 1', 'Cluster 2'])

www = "https://stat.ethz.ch/Teaching/Datasets/WBL/crime2.dat"
crime = pd.read_csv(www, sep=r"\s+")
crime.describe()

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Antes de aplicar ACP, cada variable debe ser centrada y de varianza igual a 1
X_normalized = StandardScaler().fit(crime).transform(crime) 

from sklearn.decomposition import PCA  # Importa el algoritmo de reducción de dimensionalidad PCA.
from sklearn.cluster import KMeans     # Importa el algoritmo KMeans para clustering.

# Aplica PCA (Análisis de Componentes Principales) para reducir los datos normalizados a 2 dimensiones.
# Esto permite visualizar mejor los datos y eliminar redundancias entre variables.
pca = PCA(n_components=2).fit(X_normalized)

# Transforma los datos originales normalizados al nuevo espacio de 2 componentes principales.
X_pca = pca.transform(X_normalized)  # Matriz con las dos nuevas variables principales.

# Imprime cuánta varianza explican los dos primeros componentes.
# Esto indica qué porcentaje de la información original se mantiene en la reducción.
print('Varianza explicada:', pca.explained_variance_ratio_)

# Crea el modelo KMeans para 3 clústeres y lo ajusta sobre los datos ya transformados con PCA.
grupos = KMeans(n_clusters=3, n_init=20, random_state=42)
grupos.fit(X_pca)

# Grafica los datos en el espacio reducido (PCA), coloreados según los clústeres asignados por KMeans.
plot_labelled_scatter(X_pca, grupos.labels_, ['Cluster 1', 'Cluster 2', 'Cluster 3'])

from sklearn.cluster import DBSCAN  # Importa el algoritmo DBSCAN (clustering basado en densidad).
import numpy as np                  # Importa NumPy para manipulación de arrays.

# Crea el modelo DBSCAN con parámetros ajustados:
# eps = 0.8: radio de vecindad para considerar puntos como vecinos.
# min_samples = 3: mínimo número de vecinos (incluyéndose) para que un punto sea considerado núcleo de un clúster.
dbscan = DBSCAN(eps=0.8, min_samples=3)

# Ajusta el modelo sobre los datos reducidos a 2D con PCA.
# Devuelve etiquetas de clúster para cada punto, donde -1 indica puntos ruidosos (no agrupados).
cls = dbscan.fit_predict(X_pca)

# Imprime las etiquetas únicas asignadas por DBSCAN (por ejemplo: [-1, 0, 1] si hay ruido y dos clústeres).
print(np.unique(cls))

# Grafica los puntos en el espacio reducido (PCA), sumando 1 a las etiquetas para que el ruido (-1) pase a 0.
# Esto permite graficar correctamente el ruido con la etiqueta 'Noise', y los demás como 'Cluster 0', 'Cluster 1', etc.
plot_labelled_scatter(X_pca, cls + 1,
                      ['Noise', 'Cluster 0', 'Cluster 1', 'Cluster 2'])

from sklearn.cluster import KMeans, AgglomerativeClustering, DBSCAN
from sklearn.metrics import silhouette_score, calinski_harabasz_score
from IPython.display import display


def evaluar_agrupamiento(X, etiquetas, metodo, excluir_ruido=True):
    """Calcula métricas internas y resume la cobertura de una solución de clustering."""
    X = np.asarray(X)
    etiquetas = np.asarray(etiquetas)

    es_ruido = etiquetas == -1
    n_ruido = int(es_ruido.sum())

    if excluir_ruido:
        mascara = ~es_ruido
    else:
        mascara = np.ones(len(etiquetas), dtype=bool)

    X_eval = X[mascara]
    etiquetas_eval = etiquetas[mascara]
    grupos_validos = np.unique(etiquetas_eval)
    n_clusters = len(grupos_validos)

    # Silueta y CH requieren al menos dos clústeres y más observaciones que grupos.
    puede_evaluarse = (
        n_clusters >= 2
        and len(X_eval) > n_clusters
    )

    if puede_evaluarse:
        silueta = silhouette_score(X_eval, etiquetas_eval)
        ch = calinski_harabasz_score(X_eval, etiquetas_eval)
        nota = ""
    else:
        silueta = np.nan
        ch = np.nan
        nota = "No se pueden calcular los índices: se requieren al menos dos clústeres válidos."

    return {
        "Método": metodo,
        "Clústeres": n_clusters,
        "Observaciones evaluadas": len(X_eval),
        "Ruido (%)": 100 * n_ruido / len(etiquetas),
        "Silueta": silueta,
        "Calinski-Harabasz": ch,
        "Nota": nota
    }

# Los tres métodos se evalúan sobre la misma representación: las dos componentes principales.
modelos = {
    "K-means": KMeans(n_clusters=3, n_init=20, random_state=42),
    "Aglomerativo (Ward)": AgglomerativeClustering(n_clusters=3, linkage="ward"),
    "DBSCAN": DBSCAN(eps=0.8, min_samples=3)
}

resultados = []
etiquetas_modelos = {}

for nombre, modelo in modelos.items():
    etiquetas = modelo.fit_predict(X_pca)
    etiquetas_modelos[nombre] = etiquetas
    resultados.append(
        evaluar_agrupamiento(
            X_pca,
            etiquetas,
            metodo=nombre,
            excluir_ruido=True
        )
    )

evaluacion_clustering = (
    pd.DataFrame(resultados)
    .sort_values("Silueta", ascending=False, na_position="last")
    .reset_index(drop=True)
)

display(
    evaluacion_clustering.style.format({
        "Ruido (%)": "{:.1f}",
        "Silueta": "{:.3f}",
        "Calinski-Harabasz": "{:.2f}"
    })
)

resultados_validos = evaluacion_clustering.dropna(subset=["Silueta"])

if not resultados_validos.empty:
    mejor_silueta = resultados_validos.loc[resultados_validos["Silueta"].idxmax(), "Método"]
    mejor_ch = resultados_validos.loc[resultados_validos["Calinski-Harabasz"].idxmax(), "Método"]

    print(f"Mayor Silueta: {mejor_silueta}")
    print(f"Mayor índice de Calinski–Harabasz: {mejor_ch}")
else:
    print("Ninguna solución produjo al menos dos clústeres evaluables.")

# Parámetros iniciales. Modifique eps_frutas y min_samples_frutas
# para estudiar la sensibilidad de DBSCAN.
eps_frutas = 0.20
min_samples_frutas = 3

modelos_frutas = {
    "K-means": KMeans(n_clusters=4, n_init=20, random_state=42),
    "Aglomerativo (Ward)": AgglomerativeClustering(n_clusters=4, linkage="ward"),
    "DBSCAN": DBSCAN(eps=eps_frutas, min_samples=min_samples_frutas)
}

resultados_frutas = []

for nombre, modelo in modelos_frutas.items():
    etiquetas = modelo.fit_predict(X_fruits_normalized)
    resultados_frutas.append(
        evaluar_agrupamiento(
            X_fruits_normalized,
            etiquetas,
            metodo=nombre,
            excluir_ruido=True
        )
    )

evaluacion_frutas = (
    pd.DataFrame(resultados_frutas)
    .sort_values("Silueta", ascending=False, na_position="last")
    .reset_index(drop=True)
)

display(
    evaluacion_frutas.style.format({
        "Ruido (%)": "{:.1f}",
        "Silueta": "{:.3f}",
        "Calinski-Harabasz": "{:.2f}"
    })
)