Algoritmos de Aprendizaje No Supervisado

Reading time: 36 minutes

Aprendizaje No Supervisado

El aprendizaje no supervisado es un tipo de aprendizaje automático donde el modelo se entrena con datos sin respuestas etiquetadas. El objetivo es encontrar patrones, estructuras o relaciones dentro de los datos. A diferencia del aprendizaje supervisado, donde el modelo aprende de ejemplos etiquetados, los algoritmos de aprendizaje no supervisado trabajan con datos no etiquetados. El aprendizaje no supervisado se utiliza a menudo para tareas como agrupamiento, reducción de dimensionalidad y detección de anomalías. Puede ayudar a descubrir patrones ocultos en los datos, agrupar elementos similares o reducir la complejidad de los datos mientras se preservan sus características esenciales.

Agrupamiento K-Means

K-Means es un algoritmo de agrupamiento basado en centroides que particiona los datos en K grupos asignando cada punto al centroide del grupo más cercano. El algoritmo funciona de la siguiente manera:

1. Inicialización: Elegir K centros de grupo iniciales (centroides), a menudo de forma aleatoria o mediante métodos más inteligentes como k-means++.
2. Asignación: Asignar cada punto de datos al centroide más cercano basado en una métrica de distancia (por ejemplo, distancia euclidiana).
3. Actualización: Recalcular los centroides tomando la media de todos los puntos de datos asignados a cada grupo.
4. Repetir: Los pasos 2–3 se repiten hasta que las asignaciones de grupos se estabilizan (los centroides ya no se mueven significativamente).

Selección de K

El número de grupos (K) es un hiperparámetro que debe definirse antes de ejecutar el algoritmo. Técnicas como el Método del Codo o la Puntuación de Silueta pueden ayudar a determinar un valor apropiado para K evaluando el rendimiento del agrupamiento:

• Método del Codo: Graficar la suma de las distancias al cuadrado desde cada punto hasta su centroide de grupo asignado como una función de K. Buscar un punto de "codo" donde la tasa de disminución cambia drásticamente, indicando un número adecuado de grupos.
• Puntuación de Silueta: Calcular la puntuación de silueta para diferentes valores de K. Una puntuación de silueta más alta indica grupos mejor definidos.

Suposiciones y Limitaciones

K-Means asume que los grupos son esféricos y de tamaño igual, lo cual puede no ser cierto para todos los conjuntos de datos. Es sensible a la colocación inicial de los centroides y puede converger a mínimos locales. Además, K-Means no es adecuado para conjuntos de datos con densidades variables o formas no globulares y características con diferentes escalas. Los pasos de preprocesamiento como la normalización o estandarización pueden ser necesarios para asegurar que todas las características contribuyan de manera equitativa a los cálculos de distancia.

import numpy as np
from sklearn.cluster import KMeans

# Simulate synthetic network traffic data (e.g., [duration, bytes]).
# Three normal clusters and one small attack cluster.
rng = np.random.RandomState(42)
normal1 = rng.normal(loc=[50, 500], scale=[10, 100], size=(500, 2))   # Cluster 1
normal2 = rng.normal(loc=[60, 1500], scale=[8, 200], size=(500, 2))   # Cluster 2
normal3 = rng.normal(loc=[70, 3000], scale=[5, 300], size=(500, 2))   # Cluster 3
attack = rng.normal(loc=[200, 800], scale=[5, 50], size=(50, 2))      # Small attack cluster

X = np.vstack([normal1, normal2, normal3, attack])
# Run K-Means clustering into 4 clusters (we expect it to find the 4 groups)
kmeans = KMeans(n_clusters=4, random_state=0, n_init=10)
labels = kmeans.fit_predict(X)

# Analyze resulting clusters
clusters, counts = np.unique(labels, return_counts=True)
print(f"Cluster labels: {clusters}")
print(f"Cluster sizes: {counts}")
print("Cluster centers (duration, bytes):")
for idx, center in enumerate(kmeans.cluster_centers_):
print(f"  Cluster {idx}: {center}")

Agrupamiento Jerárquico

El agrupamiento jerárquico construye una jerarquía de clústeres utilizando un enfoque de abajo hacia arriba (aglomerativo) o un enfoque de arriba hacia abajo (divisivo):

1. Aglomerativo (De Abajo Hacia Arriba): Comienza con cada punto de datos como un clúster separado y fusiona iterativamente los clústeres más cercanos hasta que queda un solo clúster o se cumple un criterio de detención.
2. Divisivo (De Arriba Hacia Abajo): Comienza con todos los puntos de datos en un solo clúster y divide iterativamente los clústeres hasta que cada punto de datos es su propio clúster o se cumple un criterio de detención.

El agrupamiento aglomerativo requiere una definición de distancia entre clústeres y un criterio de enlace para decidir qué clústeres fusionar. Los métodos de enlace comunes incluyen enlace simple (distancia de los puntos más cercanos entre dos clústeres), enlace completo (distancia de los puntos más lejanos), enlace promedio, etc., y la métrica de distancia suele ser euclidiana. La elección del enlace afecta la forma de los clústeres producidos. No es necesario especificar de antemano el número de clústeres K; se puede "cortar" el dendrograma en un nivel elegido para obtener el número deseado de clústeres.

El agrupamiento jerárquico produce un dendrograma, una estructura en forma de árbol que muestra las relaciones entre clústeres en diferentes niveles de granularidad. El dendrograma se puede cortar en un nivel deseado para obtener un número específico de clústeres.

Suposiciones y Limitaciones

El agrupamiento jerárquico no asume una forma particular de clúster y puede capturar clústeres anidados. Es útil para descubrir taxonomía o relaciones entre grupos (por ejemplo, agrupar malware por subgrupos familiares). Es determinista (sin problemas de inicialización aleatoria). Una ventaja clave es el dendrograma, que proporciona información sobre la estructura de agrupamiento de los datos a todas las escalas: los analistas de seguridad pueden decidir un corte apropiado para identificar clústeres significativos. Sin embargo, es computacionalmente costoso (típicamente $O(n^2)$ o peor para implementaciones ingenuas) y no es factible para conjuntos de datos muy grandes. También es un procedimiento codicioso: una vez que se realiza una fusión o división, no se puede deshacer, lo que puede llevar a clústeres subóptimos si ocurre un error temprano. Los valores atípicos también pueden afectar algunas estrategias de enlace (el enlace simple puede causar el efecto de "encadenamiento" donde los clústeres se vinculan a través de valores atípicos).

from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import linkage, dendrogram

# Perform agglomerative clustering (bottom-up) on the data
agg = AgglomerativeClustering(n_clusters=None, distance_threshold=0, linkage='ward')
# distance_threshold=0 gives the full tree without cutting (we can cut manually)
agg.fit(X)

print(f"Number of merge steps: {agg.n_clusters_ - 1}")  # should equal number of points - 1
# Create a dendrogram using SciPy for visualization (optional)
Z = linkage(X, method='ward')
# Normally, you would plot the dendrogram. Here we'll just compute cluster labels for a chosen cut:
clusters_3 = AgglomerativeClustering(n_clusters=3, linkage='ward').fit_predict(X)
print(f"Labels with 3 clusters: {np.unique(clusters_3)}")
print(f"Cluster sizes for 3 clusters: {np.bincount(clusters_3)}")

DBSCAN (Agrupamiento Espacial Basado en Densidad de Aplicaciones con Ruido)

DBSCAN es un algoritmo de agrupamiento basado en densidad que agrupa puntos que están estrechamente empaquetados mientras marca puntos en regiones de baja densidad como atípicos. Es particularmente útil para conjuntos de datos con densidades variables y formas no esféricas.

DBSCAN funciona definiendo dos parámetros:

• Epsilon (ε): La distancia máxima entre dos puntos para ser considerados parte del mismo clúster.
• MinPts: El número mínimo de puntos requeridos para formar una región densa (punto central).

DBSCAN identifica puntos centrales, puntos de frontera y puntos de ruido:

• Punto Central: Un punto con al menos MinPts vecinos dentro de la distancia ε.
• Punto de Frontera: Un punto que está dentro de la distancia ε de un punto central pero tiene menos de MinPts vecinos.
• Punto de Ruido: Un punto que no es ni un punto central ni un punto de frontera.

El agrupamiento procede eligiendo un punto central no visitado, marcándolo como un nuevo clúster, y luego agregando recursivamente todos los puntos alcanzables por densidad desde él (puntos centrales y sus vecinos, etc.). Los puntos de frontera se agregan al clúster de un núcleo cercano. Después de expandir todos los puntos alcanzables, DBSCAN se mueve a otro núcleo no visitado para comenzar un nuevo clúster. Los puntos no alcanzados por ningún núcleo permanecen etiquetados como ruido.

Suposiciones y Limitaciones

Suposiciones y Fortalezas:: DBSCAN no asume clústeres esféricos; puede encontrar clústeres de forma arbitraria (incluso clústeres en cadena o adyacentes). Determina automáticamente el número de clústeres basado en la densidad de datos y puede identificar efectivamente atípicos como ruido. Esto lo hace poderoso para datos del mundo real con formas irregulares y ruido. Es robusto ante atípicos (a diferencia de K-Means, que los fuerza a entrar en clústeres). Funciona bien cuando los clústeres tienen densidad aproximadamente uniforme.

Limitaciones: El rendimiento de DBSCAN depende de elegir valores apropiados de ε y MinPts. Puede tener dificultades con datos que tienen densidades variables; un solo ε no puede acomodar clústeres densos y escasos. Si ε es demasiado pequeño, etiqueta la mayoría de los puntos como ruido; si es demasiado grande, los clústeres pueden fusionarse incorrectamente. Además, DBSCAN puede ser ineficiente en conjuntos de datos muy grandes (naivamente $O(n^2)$, aunque la indexación espacial puede ayudar). En espacios de características de alta dimensión, el concepto de "distancia dentro de ε" puede volverse menos significativo (la maldición de la dimensionalidad), y DBSCAN puede necesitar un ajuste cuidadoso de parámetros o puede no encontrar clústeres intuitivos. A pesar de esto, extensiones como HDBSCAN abordan algunos problemas (como la densidad variable).

from sklearn.cluster import DBSCAN

# Generate synthetic data: 2 normal clusters and 5 outlier points
cluster1 = rng.normal(loc=[100, 1000], scale=[5, 100], size=(100, 2))
cluster2 = rng.normal(loc=[120, 2000], scale=[5, 100], size=(100, 2))
outliers = rng.uniform(low=[50, 50], high=[180, 3000], size=(5, 2))  # scattered anomalies
data = np.vstack([cluster1, cluster2, outliers])

# Run DBSCAN with chosen eps and MinPts
eps = 15.0   # radius for neighborhood
min_pts = 5  # minimum neighbors to form a dense region
db = DBSCAN(eps=eps, min_samples=min_pts).fit(data)
labels = db.labels_  # cluster labels (-1 for noise)

# Analyze clusters and noise
num_clusters = len(set(labels) - {-1})
num_noise = np.sum(labels == -1)
print(f"DBSCAN found {num_clusters} clusters and {num_noise} noise points")
print("Cluster labels for first 10 points:", labels[:10])

Análisis de Componentes Principales (PCA)

PCA es una técnica para reducción de dimensionalidad que encuentra un nuevo conjunto de ejes ortogonales (componentes principales) que capturan la máxima varianza en los datos. En términos simples, PCA rota y proyecta los datos en un nuevo sistema de coordenadas de tal manera que el primer componente principal (PC1) explica la mayor varianza posible, el segundo PC (PC2) explica la mayor varianza ortogonal a PC1, y así sucesivamente. Matemáticamente, PCA calcula los eigenvectores de la matriz de covarianza de los datos; estos eigenvectores son las direcciones de los componentes principales, y los eigenvalores correspondientes indican la cantidad de varianza explicada por cada uno. Se utiliza a menudo para extracción de características, visualización y reducción de ruido.

Tenga en cuenta que esto es útil si las dimensiones del conjunto de datos contienen dependencias o correlaciones lineales significativas.

PCA funciona identificando los componentes principales de los datos, que son las direcciones de máxima varianza. Los pasos involucrados en PCA son:

1. Estandarización: Centrar los datos restando la media y escalándolos a varianza unitaria.
2. Matriz de Covarianza: Calcular la matriz de covarianza de los datos estandarizados para entender las relaciones entre características.
3. Descomposición de Eigenvalores: Realizar la descomposición de eigenvalores en la matriz de covarianza para obtener los eigenvalores y eigenvectores.
4. Seleccionar Componentes Principales: Ordenar los eigenvalores en orden descendente y seleccionar los K eigenvectores superiores correspondientes a los eigenvalores más grandes. Estos eigenvectores forman el nuevo espacio de características.
5. Transformar Datos: Proyectar los datos originales en el nuevo espacio de características utilizando los componentes principales seleccionados. PCA se utiliza ampliamente para visualización de datos, reducción de ruido y como un paso de preprocesamiento para otros algoritmos de aprendizaje automático. Ayuda a reducir la dimensionalidad de los datos mientras se retiene su estructura esencial.

Eigenvalores y Eigenvectores

Un eigenvalor es un escalar que indica la cantidad de varianza capturada por su correspondiente eigenvector. Un eigenvector representa una dirección en el espacio de características a lo largo de la cual los datos varían más.

Imagina que A es una matriz cuadrada, y v es un vector no nulo tal que: A * v = λ * v donde:

• A es una matriz cuadrada como [ [1, 2], [2, 1]] (por ejemplo, matriz de covarianza)
• v es un eigenvector (por ejemplo, [1, 1])

Entonces, A * v = [ [1, 2], [2, 1]] * [1, 1] = [3, 3] que será el eigenvalor λ multiplicado por el eigenvector v, haciendo que el eigenvalor λ = 3.

Eigenvalores y Eigenvectores en PCA

Vamos a explicar esto con un ejemplo. Imagina que tienes un conjunto de datos con muchas imágenes en escala de grises de rostros de 100x100 píxeles. Cada píxel puede considerarse una característica, por lo que tienes 10,000 características por imagen (o un vector de 10000 componentes por imagen). Si deseas reducir la dimensionalidad de este conjunto de datos utilizando PCA, seguirías estos pasos:

1. Estandarización: Centrar los datos restando la media de cada característica (píxel) del conjunto de datos.
2. Matriz de Covarianza: Calcular la matriz de covarianza de los datos estandarizados, que captura cómo varían juntas las características (píxeles).

• Tenga en cuenta que la covarianza entre dos variables (píxeles en este caso) indica cuánto cambian juntas, por lo que la idea aquí es averiguar qué píxeles tienden a aumentar o disminuir juntos con una relación lineal.
• Por ejemplo, si el píxel 1 y el píxel 2 tienden a aumentar juntos, la covarianza entre ellos será positiva.
• La matriz de covarianza será una matriz de 10,000x10,000 donde cada entrada representa la covarianza entre dos píxeles.

3. Resolver la ecuación de eigenvalores: La ecuación de eigenvalores a resolver es C * v = λ * v donde C es la matriz de covarianza, v es el eigenvector, y λ es el eigenvalor. Se puede resolver utilizando métodos como:

• Descomposición de Eigenvalores: Realizar la descomposición de eigenvalores en la matriz de covarianza para obtener los eigenvalores y eigenvectores.
• Descomposición en Valores Singulares (SVD): Alternativamente, puedes usar SVD para descomponer la matriz de datos en valores y vectores singulares, lo que también puede dar lugar a los componentes principales.

4. Seleccionar Componentes Principales: Ordenar los eigenvalores en orden descendente y seleccionar los K eigenvectores superiores correspondientes a los eigenvalores más grandes. Estos eigenvectores representan las direcciones de máxima varianza en los datos.

Suposiciones y Limitaciones

PCA asume que los ejes principales de varianza son significativos; es un método lineal, por lo que captura correlaciones lineales en los datos. Es no supervisado ya que utiliza solo la covarianza de las características. Las ventajas de PCA incluyen la reducción de ruido (los componentes de pequeña varianza a menudo corresponden a ruido) y la decorrelación de características. Es computacionalmente eficiente para dimensiones moderadamente altas y a menudo es un paso de preprocesamiento útil para otros algoritmos (para mitigar la maldición de la dimensionalidad). Una limitación es que PCA está limitado a relaciones lineales; no capturará estructuras no lineales complejas (mientras que los autoencoders o t-SNE podrían). Además, los componentes de PCA pueden ser difíciles de interpretar en términos de características originales (son combinaciones de características originales). En ciberseguridad, uno debe ser cauteloso: un ataque que solo causa un cambio sutil en una característica de baja varianza podría no aparecer en los PCs principales (ya que PCA prioriza la varianza, no necesariamente la "interesanteza").

from sklearn.decomposition import PCA

# Create synthetic 4D data (3 clusters similar to before, but add correlated features)
# Base features: duration, bytes (as before)
base_data = np.vstack([normal1, normal2, normal3])  # 1500 points from earlier normal clusters
# Add two more features correlated with existing ones, e.g. packets = bytes/50 + noise, errors = duration/10 + noise
packets = base_data[:, 1] / 50 + rng.normal(scale=0.5, size=len(base_data))
errors = base_data[:, 0] / 10 + rng.normal(scale=0.5, size=len(base_data))
data_4d = np.column_stack([base_data[:, 0], base_data[:, 1], packets, errors])

# Apply PCA to reduce 4D data to 2D
pca = PCA(n_components=2)
data_2d = pca.fit_transform(data_4d)
print("Explained variance ratio of 2 components:", pca.explained_variance_ratio_)
print("Original shape:", data_4d.shape, "Reduced shape:", data_2d.shape)
# We can examine a few transformed points
print("First 5 data points in PCA space:\n", data_2d[:5])

Modelos de Mezcla Gaussiana (GMM)

Un Modelo de Mezcla Gaussiana asume que los datos se generan a partir de una mezcla de varias distribuciones Gaussianas (normales) con parámetros desconocidos. En esencia, es un modelo de agrupamiento probabilístico: intenta asignar suavemente cada punto a uno de K componentes Gaussianos. Cada componente Gaussiano k tiene un vector medio (μ_k), una matriz de covarianza (Σ_k) y un peso de mezcla (π_k) que representa cuán prevalente es ese clúster. A diferencia de K-Means, que hace asignaciones "duras", GMM le da a cada punto una probabilidad de pertenecer a cada clúster.

El ajuste de GMM se realiza típicamente a través del algoritmo de Expectativa-Maximización (EM):

• Inicialización: Comenzar con conjeturas iniciales para las medias, covarianzas y coeficientes de mezcla (o usar los resultados de K-Means como punto de partida).

• Paso E (Expectativa): Dado los parámetros actuales, calcular la responsabilidad de cada clúster para cada punto: esencialmente r_nk = P(z_k | x_n) donde z_k es la variable latente que indica la pertenencia al clúster para el punto x_n. Esto se hace utilizando el teorema de Bayes, donde calculamos la probabilidad posterior de que cada punto pertenezca a cada clúster basado en los parámetros actuales. Las responsabilidades se calculan como:

r_{nk} = \frac{\pi_k \mathcal{N}(x_n | \mu_k, \Sigma_k)}{\sum_{j=1}^{K} \pi_j \mathcal{N}(x_n | \mu_j, \Sigma_j)}

donde:

• ( \pi_k ) es el coeficiente de mezcla para el clúster k (probabilidad a priori del clúster k),

• ( \mathcal{N}(x_n | \mu_k, \Sigma_k) ) es la función de densidad de probabilidad Gaussiana para el punto ( x_n ) dado la media ( \mu_k ) y la covarianza ( \Sigma_k ).

• Paso M (Maximización): Actualizar los parámetros utilizando las responsabilidades calculadas en el paso E:

• Actualizar cada media μ_k como el promedio ponderado de los puntos, donde los pesos son las responsabilidades.

• Actualizar cada covarianza Σ_k como la covarianza ponderada de los puntos asignados al clúster k.

• Actualizar los coeficientes de mezcla π_k como la responsabilidad promedio para el clúster k.

• Iterar los pasos E y M hasta la convergencia (los parámetros se estabilizan o la mejora de la verosimilitud está por debajo de un umbral).

El resultado es un conjunto de distribuciones Gaussianas que modelan colectivamente la distribución general de los datos. Podemos usar el GMM ajustado para agrupar asignando cada punto a la Gaussiana con mayor probabilidad, o mantener las probabilidades para la incertidumbre. También se puede evaluar la verosimilitud de nuevos puntos para ver si se ajustan al modelo (útil para la detección de anomalías).

Suposiciones y Limitaciones

GMM es una generalización de K-Means que incorpora covarianza, por lo que los clústeres pueden ser elipsoidales (no solo esféricos). Maneja clústeres de diferentes tamaños y formas si la covarianza es completa. El agrupamiento suave es una ventaja cuando los límites de los clústeres son difusos – por ejemplo, en ciberseguridad, un evento podría tener rasgos de múltiples tipos de ataque; GMM puede reflejar esa incertidumbre con probabilidades. GMM también proporciona una estimación de densidad probabilística de los datos, útil para detectar valores atípicos (puntos con baja probabilidad bajo todos los componentes de la mezcla).

Por otro lado, GMM requiere especificar el número de componentes K (aunque se pueden usar criterios como BIC/AIC para seleccionarlo). EM a veces puede converger lentamente o a un óptimo local, por lo que la inicialización es importante (a menudo se ejecuta EM múltiples veces). Si los datos no siguen realmente una mezcla de Gaussianas, el modelo puede ser un mal ajuste. También existe el riesgo de que una Gaussiana se reduzca para cubrir solo un valor atípico (aunque la regularización o los límites de covarianza mínima pueden mitigar eso).

from sklearn.mixture import GaussianMixture

# Fit a GMM with 3 components to the normal traffic data
gmm = GaussianMixture(n_components=3, covariance_type='full', random_state=0)
gmm.fit(base_data)  # using the 1500 normal data points from PCA example

# Print the learned Gaussian parameters
print("GMM means:\n", gmm.means_)
print("GMM covariance matrices:\n", gmm.covariances_)

# Take a sample attack-like point and evaluate it
sample_attack = np.array([[200, 800]])  # an outlier similar to earlier attack cluster
probs = gmm.predict_proba(sample_attack)
log_likelihood = gmm.score_samples(sample_attack)
print("Cluster membership probabilities for sample attack:", probs)
print("Log-likelihood of sample attack under GMM:", log_likelihood)

from sklearn.ensemble import IsolationForest

# Combine normal and attack test data from autoencoder example
X_test_if = test_data  # (120 x 2 array with 100 normal and 20 attack points)
# Train Isolation Forest (unsupervised) on the test set itself for demo (in practice train on known normal)
iso_forest = IsolationForest(n_estimators=100, contamination=0.15, random_state=0)
iso_forest.fit(X_test_if)
# Predict anomalies (-1 for anomaly, 1 for normal)
preds = iso_forest.predict(X_test_if)
anomaly_scores = iso_forest.decision_function(X_test_if)  # the higher, the more normal
print("Isolation Forest predicted labels (first 20):", preds[:20])
print("Number of anomalies detected:", np.sum(preds == -1))
print("Example anomaly scores (lower means more anomalous):", anomaly_scores[:5])

# 1 ─────────────────────────────────────────────────────────────────────
#    Create synthetic 4-D dataset
#      • Three clusters of “normal” traffic (duration, bytes)
#      • Two correlated features: packets & errors
#      • Five outlier points to simulate suspicious traffic
# ──────────────────────────────────────────────────────────────────────
import numpy as np
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler

rng = np.random.RandomState(42)

# Base (duration, bytes) clusters
normal1 = rng.normal(loc=[50, 500],  scale=[10, 100], size=(500, 2))
normal2 = rng.normal(loc=[60, 1500], scale=[8,  200], size=(500, 2))
normal3 = rng.normal(loc=[70, 3000], scale=[5,  300], size=(500, 2))

base_data = np.vstack([normal1, normal2, normal3])       # (1500, 2)

# Correlated features
packets = base_data[:, 1] / 50 + rng.normal(scale=0.5, size=len(base_data))
errors  = base_data[:, 0] / 10 + rng.normal(scale=0.5, size=len(base_data))

data_4d = np.column_stack([base_data, packets, errors])  # (1500, 4)

# Outlier / attack points
outliers_4d = np.column_stack([
rng.normal(250, 1, size=5),     # extreme duration
rng.normal(1000, 1, size=5),    # moderate bytes
rng.normal(5, 1, size=5),       # very low packets
rng.normal(25, 1, size=5)       # high errors
])

data_viz = np.vstack([data_4d, outliers_4d])             # (1505, 4)

# 2 ─────────────────────────────────────────────────────────────────────
#    Standardize features (recommended for t-SNE)
# ──────────────────────────────────────────────────────────────────────
scaler = StandardScaler()
data_scaled = scaler.fit_transform(data_viz)

# 3 ─────────────────────────────────────────────────────────────────────
#    Run t-SNE to project 4-D → 2-D
# ──────────────────────────────────────────────────────────────────────
tsne = TSNE(
n_components=2,
perplexity=30,
learning_rate='auto',
init='pca',
random_state=0
)
data_2d = tsne.fit_transform(data_scaled)
print("t-SNE output shape:", data_2d.shape)  # (1505, 2)

# 4 ─────────────────────────────────────────────────────────────────────
#    Visualize: normal traffic vs. outliers
# ──────────────────────────────────────────────────────────────────────
plt.figure(figsize=(8, 6))
plt.scatter(
data_2d[:-5, 0], data_2d[:-5, 1],
label="Normal traffic",
alpha=0.6,
s=10
)
plt.scatter(
data_2d[-5:, 0], data_2d[-5:, 1],
label="Outliers / attacks",
alpha=0.9,
s=40,
marker="X",
edgecolor='k'
)

plt.title("t-SNE Projection of Synthetic Network Traffic")
plt.xlabel("t-SNE component 1")
plt.ylabel("t-SNE component 2")
plt.legend()
plt.tight_layout()
plt.show()