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}")

In diesem Beispiel sollte K-Means 4 Cluster finden. Der kleine Angriffscluster (mit ungewöhnlich hoher Dauer ~200) wird idealerweise seinen eigenen Cluster bilden, gegeben seiner Distanz zu normalen Clustern. Wir drucken die Clustergrößen und -zentren aus, um die Ergebnisse zu interpretieren. In einem realen Szenario könnte man den Cluster mit wenigen Punkten als potenzielle Anomalien kennzeichnen oder seine Mitglieder auf bösartige Aktivitäten untersuchen.

Hierarchisches Clustering

Hierarchisches Clustering baut eine Hierarchie von Clustern auf, entweder mit einem Bottom-Up (agglomerativen) Ansatz oder einem Top-Down (divisiven) Ansatz:

1. Agglomerativ (Bottom-Up): Beginnen Sie mit jedem Datenpunkt als separatem Cluster und fügen Sie iterativ die nächstgelegenen Cluster zusammen, bis ein einzelner Cluster übrig bleibt oder ein Abbruchkriterium erfüllt ist.
2. Divisiv (Top-Down): Beginnen Sie mit allen Datenpunkten in einem einzigen Cluster und teilen Sie die Cluster iterativ, bis jeder Datenpunkt sein eigener Cluster ist oder ein Abbruchkriterium erfüllt ist.

Agglomeratives Clustering erfordert eine Definition der Inter-Cluster-Distanz und ein Verknüpfungskriterium, um zu entscheiden, welche Cluster zusammengeführt werden sollen. Zu den gängigen Verknüpfungsmethoden gehören die Einzelverknüpfung (Abstand der nächstgelegenen Punkte zwischen zwei Clustern), die vollständige Verknüpfung (Abstand der entferntesten Punkte), die durchschnittliche Verknüpfung usw., und die Distanzmetrik ist oft euklidisch. Die Wahl der Verknüpfung beeinflusst die Form der produzierten Cluster. Es ist nicht notwendig, die Anzahl der Cluster K im Voraus festzulegen; Sie können das Dendrogramm auf einem gewählten Niveau "schneiden", um die gewünschte Anzahl von Clustern zu erhalten.

Hierarchisches Clustering produziert ein Dendrogramm, eine baumartige Struktur, die die Beziehungen zwischen Clustern auf verschiedenen Granularitätsebenen zeigt. Das Dendrogramm kann auf einem gewünschten Niveau geschnitten werden, um eine spezifische Anzahl von Clustern zu erhalten.

Annahmen und Einschränkungen

Hierarchisches Clustering nimmt keine bestimmte Clusterform an und kann geschachtelte Cluster erfassen. Es ist nützlich, um Taxonomien oder Beziehungen zwischen Gruppen zu entdecken (z. B. Malware nach Familienuntergruppen zu gruppieren). Es ist deterministisch (keine Probleme mit zufälliger Initialisierung). Ein wesentlicher Vorteil ist das Dendrogramm, das Einblicke in die Clusterstruktur der Daten auf allen Skalen bietet – Sicherheitsanalysten können einen geeigneten Schnittpunkt entscheiden, um bedeutungsvolle Cluster zu identifizieren. Es ist jedoch rechenintensiv (typischerweise $O(n^2)$ Zeit oder schlechter für naive Implementierungen) und nicht praktikabel für sehr große Datensätze. Es ist auch ein gieriges Verfahren – einmal durchgeführte Zusammenführungen oder Teilungen können nicht rückgängig gemacht werden, was zu suboptimalen Clustern führen kann, wenn ein Fehler früh auftritt. Ausreißer können auch einige Verknüpfungsstrategien beeinflussen (Einzelverknüpfung kann den "Verkettungseffekt" verursachen, bei dem Cluster über Ausreißer verbunden werden).

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 (Dichtebasiertes räumliches Clustering von Anwendungen mit Rauschen)

DBSCAN ist ein dichtebasiierter Clustering-Algorithmus, der Punkte gruppiert, die eng beieinander liegen, während Punkte in Regionen mit niedriger Dichte als Ausreißer markiert werden. Es ist besonders nützlich für Datensätze mit variierenden Dichten und nicht-sphärischen Formen.

DBSCAN funktioniert, indem es zwei Parameter definiert:

• Epsilon (ε): Die maximale Entfernung zwischen zwei Punkten, um als Teil desselben Clusters betrachtet zu werden.
• MinPts: Die minimale Anzahl von Punkten, die erforderlich ist, um eine dichte Region (Kernpunkt) zu bilden.

DBSCAN identifiziert Kernpunkte, Randpunkte und Rauschpunkte:

• Kernpunkt: Ein Punkt mit mindestens MinPts Nachbarn innerhalb der ε-Distanz.
• Randpunkt: Ein Punkt, der sich innerhalb der ε-Distanz eines Kernpunkts befindet, aber weniger als MinPts Nachbarn hat.
• Rauschpunkt: Ein Punkt, der weder ein Kernpunkt noch ein Randpunkt ist.

Das Clustering erfolgt, indem ein unbesuchter Kernpunkt ausgewählt, als neues Cluster markiert und dann rekursiv alle Punkte hinzugefügt werden, die von ihm aus dichte-erreichbar sind (Kernpunkte und deren Nachbarn usw.). Randpunkte werden dem Cluster eines nahegelegenen Kerns hinzugefügt. Nachdem alle erreichbaren Punkte erweitert wurden, wechselt DBSCAN zu einem anderen unbesuchten Kern, um ein neues Cluster zu starten. Punkte, die von keinem Kern erreicht werden, bleiben als Rauschen gekennzeichnet.

Annahmen und Einschränkungen

Annahmen & Stärken: DBSCAN geht nicht von sphärischen Clustern aus – es kann beliebig geformte Cluster finden (sogar kettenartige oder benachbarte Cluster). Es bestimmt automatisch die Anzahl der Cluster basierend auf der Datendichte und kann Ausreißer effektiv als Rauschen identifizieren. Dies macht es leistungsstark für reale Daten mit unregelmäßigen Formen und Rauschen. Es ist robust gegenüber Ausreißern (im Gegensatz zu K-Means, das sie in Cluster zwingt). Es funktioniert gut, wenn Cluster ungefähr eine einheitliche Dichte haben.

Einschränkungen: Die Leistung von DBSCAN hängt von der Wahl geeigneter ε- und MinPts-Werte ab. Es kann Schwierigkeiten mit Daten haben, die variierende Dichten aufweisen – ein einzelnes ε kann sowohl dichte als auch spärliche Cluster nicht berücksichtigen. Wenn ε zu klein ist, kennzeichnet es die meisten Punkte als Rauschen; zu groß, und Cluster können fälschlicherweise zusammengeführt werden. Außerdem kann DBSCAN bei sehr großen Datensätzen ineffizient sein (naiv $O(n^2)$, obwohl räumliche Indizierung helfen kann). In hochdimensionalen Merkmalsräumen kann das Konzept der „Entfernung innerhalb von ε“ weniger sinnvoll werden (der Fluch der Dimensionalität), und DBSCAN benötigt möglicherweise eine sorgfältige Parameteranpassung oder kann scheitern, intuitive Cluster zu finden. Trotz dieser Einschränkungen adressieren Erweiterungen wie HDBSCAN einige Probleme (wie variierende Dichte).

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])

Hauptkomponentenanalyse (PCA)

PCA ist eine Technik zur Dimensionsreduktion, die eine neue Menge orthogonaler Achsen (Hauptkomponenten) findet, die die maximale Varianz in den Daten erfassen. Einfach ausgedrückt, rotiert und projiziert PCA die Daten auf ein neues Koordinatensystem, sodass die erste Hauptkomponente (PC1) die größtmögliche Varianz erklärt, die zweite PC (PC2) die größte Varianz, die orthogonal zu PC1 ist, und so weiter. Mathematisch berechnet PCA die Eigenvektoren der Kovarianzmatrix der Daten – diese Eigenvektoren sind die Richtungen der Hauptkomponenten, und die entsprechenden Eigenwerte geben die Menge der von jeder erklärten Varianz an. Es wird häufig für Merkmals-Extraktion, Visualisierung und Rauschreduktion verwendet.

Beachten Sie, dass dies nützlich ist, wenn die Dimensionen des Datensatzes signifikante lineare Abhängigkeiten oder Korrelationen enthalten.

PCA funktioniert, indem es die Hauptkomponenten der Daten identifiziert, die die Richtungen der maximalen Varianz sind. Die Schritte, die an PCA beteiligt sind, sind:

1. Standardisierung: Zentrieren Sie die Daten, indem Sie den Mittelwert subtrahieren und sie auf eine Einheitliche Varianz skalieren.
2. Kovarianzmatrix: Berechnen Sie die Kovarianzmatrix der standardisierten Daten, um die Beziehungen zwischen den Merkmalen zu verstehen.
3. Eigenwertzerlegung: Führen Sie eine Eigenwertzerlegung der Kovarianzmatrix durch, um die Eigenwerte und Eigenvektoren zu erhalten.
4. Hauptkomponenten auswählen: Sortieren Sie die Eigenwerte in absteigender Reihenfolge und wählen Sie die obersten K Eigenvektoren aus, die den größten Eigenwerten entsprechen. Diese Eigenvektoren bilden den neuen Merkmalsraum.
5. Daten transformieren: Projizieren Sie die ursprünglichen Daten auf den neuen Merkmalsraum unter Verwendung der ausgewählten Hauptkomponenten. PCA wird häufig für die Datenvisualisierung, Rauschreduktion und als Vorverarbeitungsschritt für andere maschinelle Lernalgorithmen verwendet. Es hilft, die Dimensionalität der Daten zu reduzieren, während die wesentliche Struktur erhalten bleibt.

Eigenwerte und Eigenvektoren

Ein Eigenwert ist ein Skalar, der die Menge der Varianz angibt, die durch seinen entsprechenden Eigenvektor erfasst wird. Ein Eigenvektor stellt eine Richtung im Merkmalsraum dar, entlang derer sich die Daten am meisten ändern.

Stellen Sie sich vor, A ist eine quadratische Matrix, und v ist ein nicht-null Vektor, sodass: A * v = λ * v wobei:

• A eine quadratische Matrix wie [ [1, 2], [2, 1]] (z.B. Kovarianzmatrix) ist
• v ein Eigenvektor ist (z.B. [1, 1])

Dann ist A * v = [ [1, 2], [2, 1]] * [1, 1] = [3, 3], was der Eigenwert λ multipliziert mit dem Eigenvektor v sein wird, sodass der Eigenwert λ = 3 ist.

Eigenwerte und Eigenvektoren in PCA

Lassen Sie uns dies mit einem Beispiel erklären. Stellen Sie sich vor, Sie haben einen Datensatz mit vielen Graustufenbildern von Gesichtern mit 100x100 Pixeln. Jedes Pixel kann als Merkmal betrachtet werden, sodass Sie 10.000 Merkmale pro Bild haben (oder einen Vektor von 10.000 Komponenten pro Bild). Wenn Sie die Dimensionalität dieses Datensatzes mit PCA reduzieren möchten, würden Sie die folgenden Schritte ausführen:

1. Standardisierung: Zentrieren Sie die Daten, indem Sie den Mittelwert jedes Merkmals (Pixels) vom Datensatz abziehen.
2. Kovarianzmatrix: Berechnen Sie die Kovarianzmatrix der standardisierten Daten, die erfasst, wie Merkmale (Pixel) zusammen variieren.

• Beachten Sie, dass die Kovarianz zwischen zwei Variablen (in diesem Fall Pixel) angibt, wie sehr sie sich gemeinsam ändern, sodass die Idee hier darin besteht, herauszufinden, welche Pixel dazu neigen, gemeinsam mit einer linearen Beziehung zu steigen oder zu fallen.
• Wenn beispielsweise Pixel 1 und Pixel 2 dazu neigen, gemeinsam zu steigen, wird die Kovarianz zwischen ihnen positiv sein.
• Die Kovarianzmatrix wird eine 10.000x10.000 Matrix sein, in der jeder Eintrag die Kovarianz zwischen zwei Pixeln darstellt.

3. Lösen Sie die Eigenwertgleichung: Die zu lösende Eigenwertgleichung ist C * v = λ * v, wobei C die Kovarianzmatrix, v der Eigenvektor und λ der Eigenwert ist. Sie kann mit Methoden wie:

• Eigenwertzerlegung: Führen Sie eine Eigenwertzerlegung der Kovarianzmatrix durch, um die Eigenwerte und Eigenvektoren zu erhalten.
• Singulärwertzerlegung (SVD): Alternativ können Sie SVD verwenden, um die Datenmatrix in singuläre Werte und Vektoren zu zerlegen, die ebenfalls die Hauptkomponenten liefern können.

4. Hauptkomponenten auswählen: Sortieren Sie die Eigenwerte in absteigender Reihenfolge und wählen Sie die obersten K Eigenvektoren aus, die den größten Eigenwerten entsprechen. Diese Eigenvektoren repräsentieren die Richtungen der maximalen Varianz in den Daten.

Annahmen und Einschränkungen

PCA geht davon aus, dass Hauptachsen der Varianz sinnvoll sind – es ist eine lineare Methode, daher erfasst sie lineare Korrelationen in den Daten. Es ist unüberwacht, da es nur die Merkmalskovarianz verwendet. Zu den Vorteilen von PCA gehören Rauschreduktion (kleinere Varianzkomponenten entsprechen oft Rauschen) und Dekorrelation der Merkmale. Es ist rechnerisch effizient für mäßig hohe Dimensionen und oft ein nützlicher Vorverarbeitungsschritt für andere Algorithmen (um den Fluch der Dimensionalität zu mildern). Eine Einschränkung ist, dass PCA auf lineare Beziehungen beschränkt ist – es erfasst keine komplexen nichtlinearen Strukturen (während Autoencoder oder t-SNE dies tun könnten). Außerdem können PCA-Komponenten schwer zu interpretieren sein in Bezug auf die ursprünglichen Merkmale (sie sind Kombinationen der ursprünglichen Merkmale). In der Cybersicherheit muss man vorsichtig sein: Ein Angriff, der nur eine subtile Veränderung in einem Merkmal mit niedriger Varianz verursacht, könnte in den obersten PCs nicht sichtbar sein (da PCA die Varianz priorisiert, nicht unbedingt die „Interessantheit“).

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])

Gaussian Mixture Models (GMM)

Ein Gaussian Mixture Model geht davon aus, dass Daten aus einer Mischung von mehreren Gaussian (normalen) Verteilungen mit unbekannten Parametern generiert werden. Im Wesentlichen handelt es sich um ein probabilistisches Clustering-Modell: Es versucht, jeden Punkt sanft einem der K Gaussian-Komponenten zuzuordnen. Jede Gaussian-Komponente k hat einen Mittelwertvektor (μ_k), eine Kovarianzmatrix (Σ_k) und ein Mischgewicht (π_k), das darstellt, wie verbreitet dieser Cluster ist. Im Gegensatz zu K-Means, das „harte“ Zuordnungen vornimmt, gibt GMM jedem Punkt eine Wahrscheinlichkeit, zu jedem Cluster zu gehören.

Das Anpassen von GMM erfolgt typischerweise über den Expectation-Maximization (EM)-Algorithmus:

• Initialisierung: Beginnen Sie mit anfänglichen Schätzungen für die Mittelwerte, Kovarianzen und Mischkoeffizienten (oder verwenden Sie die Ergebnisse von K-Means als Ausgangspunkt).

• E-Schritt (Erwartung): Berechnen Sie die Verantwortung jedes Clusters für jeden Punkt anhand der aktuellen Parameter: im Wesentlichen r_nk = P(z_k | x_n), wobei z_k die latente Variable ist, die die Clusterzugehörigkeit für den Punkt x_n angibt. Dies geschieht unter Verwendung des Satzes von Bayes, wobei wir die posteriori Wahrscheinlichkeit jedes Punktes berechnen, zu jedem Cluster basierend auf den aktuellen Parametern zu gehören. Die Verantwortlichkeiten werden wie folgt berechnet:

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)}

wobei:

• ( \pi_k ) der Mischkoeffizient für Cluster k (priori Wahrscheinlichkeit von Cluster k) ist,

• ( \mathcal{N}(x_n | \mu_k, \Sigma_k) ) die Gaussian-Wahrscheinlichkeitsdichtefunktion für den Punkt ( x_n ) gegeben den Mittelwert ( \mu_k ) und die Kovarianz ( \Sigma_k ) ist.

• M-Schritt (Maximierung): Aktualisieren Sie die Parameter unter Verwendung der im E-Schritt berechneten Verantwortlichkeiten:

• Aktualisieren Sie jeden Mittelwert μ_k als den gewichteten Durchschnitt der Punkte, wobei die Gewichte die Verantwortlichkeiten sind.

• Aktualisieren Sie jede Kovarianz Σ_k als die gewichtete Kovarianz der den Cluster k zugewiesenen Punkte.

• Aktualisieren Sie die Mischkoeffizienten π_k als den durchschnittlichen Verantwortlichkeitswert für Cluster k.

• Iterieren Sie E- und M-Schritte, bis die Konvergenz erreicht ist (Parameter stabilisieren sich oder die Verbesserung der Wahrscheinlichkeit liegt unter einem Schwellenwert).

Das Ergebnis ist eine Menge von Gaussian-Verteilungen, die gemeinsam die gesamte Datenverteilung modellieren. Wir können das angepasste GMM verwenden, um zu clustern, indem wir jeden Punkt dem Gaussian mit der höchsten Wahrscheinlichkeit zuweisen oder die Wahrscheinlichkeiten für Unsicherheit beibehalten. Man kann auch die Wahrscheinlichkeit neuer Punkte bewerten, um zu sehen, ob sie zum Modell passen (nützlich für die Anomalieerkennung).

Annahmen und Einschränkungen

GMM ist eine Verallgemeinerung von K-Means, die Kovarianz einbezieht, sodass Cluster ellipsoid sein können (nicht nur sphärisch). Es verarbeitet Cluster unterschiedlicher Größen und Formen, wenn die Kovarianz vollständig ist. Weiches Clustering ist ein Vorteil, wenn die Clustergrenzen unscharf sind – z.B. in der Cybersicherheit könnte ein Ereignis Merkmale mehrerer Angriffsarten aufweisen; GMM kann diese Unsicherheit mit Wahrscheinlichkeiten widerspiegeln. GMM bietet auch eine probabilistische Dichteschätzung der Daten, die nützlich ist, um Ausreißer (Punkte mit niedriger Wahrscheinlichkeit unter allen Mischkomponenten) zu erkennen.

Auf der negativen Seite erfordert GMM die Angabe der Anzahl der Komponenten K (obwohl man Kriterien wie BIC/AIC verwenden kann, um sie auszuwählen). EM kann manchmal langsam konvergieren oder zu einem lokalen Optimum führen, daher ist die Initialisierung wichtig (oft wird EM mehrfach ausgeführt). Wenn die Daten tatsächlich keiner Mischung von Gaussians folgen, kann das Modell schlecht passen. Es besteht auch das Risiko, dass ein Gaussian schrumpft, um nur einen Ausreißer abzudecken (obwohl Regularisierung oder Mindestkovarianzgrenzen dies mildern können).

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()