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

Bu örnekte, K-Means 4 küme bulmalıdır. Küçük saldırı kümesi (olağandışı yüksek süre ~200) normal kümelerden uzaklığı nedeniyle ideal olarak kendi kümesini oluşturacaktır. Sonuçları yorumlamak için küme boyutlarını ve merkezlerini yazdırıyoruz. Gerçek bir senaryoda, birkaç noktadan oluşan kümeyi potansiyel anormallikler olarak etiketlemek veya üyelerini kötü niyetli faaliyetler için incelemek mümkündür.

Hiyerarşik Kümeleme

Hiyerarşik kümeleme, ya aşağıdan yukarı (agglomeratif) bir yaklaşım ya da yukarıdan aşağı (bölücü) bir yaklaşım kullanarak bir küme hiyerarşisi oluşturur:

1. Agglomeratif (Aşağıdan Yukarı): Her veri noktasını ayrı bir küme olarak başlatın ve en yakın kümeleri tekrarlayarak birleştirin, ta ki tek bir küme kalana veya bir durdurma kriteri karşılanana kadar.
2. Bölücü (Yukarıdan Aşağı): Tüm veri noktalarını tek bir kümede başlatın ve her veri noktası kendi kümesi olana veya bir durdurma kriteri karşılanana kadar kümeleri tekrarlayarak bölün.

Agglomeratif kümeleme, kümeler arası mesafenin tanımını ve hangi kümelerin birleştirileceğini belirlemek için bir bağlantı kriteri gerektirir. Yaygın bağlantı yöntemleri arasında tek bağlantı (iki küme arasındaki en yakın noktaların mesafesi), tam bağlantı (en uzak noktaların mesafesi), ortalama bağlantı vb. bulunur ve mesafe metriği genellikle Öklidyen'dir. Bağlantı seçimi, üretilen kümelerin şeklini etkiler. Kümelerin sayısını K önceden belirtmeye gerek yoktur; istenen sayıda küme elde etmek için dendrogramı seçilen bir seviyede "kesebilirsiniz".

Hiyerarşik kümeleme, farklı ayrıntı seviyelerinde kümeler arasındaki ilişkileri gösteren bir ağaç benzeri yapı olan bir dendrogram üretir. Dendrogram, belirli bir sayıda küme elde etmek için istenen bir seviyede kesilebilir.

Varsayımlar ve Sınırlamalar

Hiyerarşik kümeleme belirli bir küme şekli varsaymaz ve iç içe geçmiş kümeleri yakalayabilir. Gruplar arasındaki taksonomi veya ilişkileri keşfetmek için faydalıdır (örneğin, kötü amaçlı yazılımları aile alt gruplarına göre gruplamak). Deterministiktir (rastgele başlatma sorunları yoktur). Önemli bir avantaj, verinin kümeleme yapısını tüm ölçeklerde anlamaya yardımcı olan dendrogramdır – güvenlik analistleri anlamlı kümeleri tanımlamak için uygun bir kesim noktası belirleyebilir. Ancak, hesaplama açısından pahalıdır (genellikle $O(n^2)$ zaman veya daha kötü, naif uygulamalar için) ve çok büyük veri setleri için uygulanabilir değildir. Ayrıca, birleştirme veya bölme yapıldığında geri alınamaz, bu da erken bir hata olursa alt optimal kümelere yol açabilir. Aykırı değerler de bazı bağlantı stratejilerini etkileyebilir (tek bağlantı, kümelerin aykırı değerler aracılığıyla bağlandığı "zincirleme" etkisini yaratabilir).

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 (Gürültü ile Uygulamaların Yoğunluk Tabanlı Mekansal Kümeleme)

DBSCAN, yakın bir şekilde paketlenmiş noktaları bir araya getiren ve düşük yoğunluklu bölgelerdeki noktaları aykırı değer olarak işaretleyen yoğunluk tabanlı bir kümeleme algoritmasıdır. Farklı yoğunluklara ve küresel olmayan şekillere sahip veri setleri için özellikle yararlıdır.

DBSCAN, iki parametre tanımlayarak çalışır:

• Epsilon (ε): İki noktanın aynı kümeye ait olarak kabul edilmesi için maksimum mesafe.
• MinPts: Yoğun bir bölge (çekirdek nokta) oluşturmak için gereken minimum nokta sayısı.

DBSCAN, çekirdek noktaları, sınır noktaları ve gürültü noktalarını tanımlar:

• Çekirdek Nokta: ε mesafesi içinde en az MinPts komşusu olan bir nokta.
• Sınır Noktası: Bir çekirdek noktasının ε mesafesi içinde olan ancak MinPts'ten daha az komşusu olan bir nokta.
• Gürültü Noktası: Ne bir çekirdek nokta ne de bir sınır noktası olan bir nokta.

Kümeleme, ziyaret edilmemiş bir çekirdek noktasını seçerek başlar, onu yeni bir küme olarak işaretler ve ardından ondan yoğunlukla ulaşılabilir tüm noktaları (çekirdek noktalar ve komşuları vb.) özyinelemeli olarak ekler. Sınır noktaları, yakın bir çekirdek kümesine eklenir. Tüm ulaşılabilir noktalar genişletildikten sonra, DBSCAN yeni bir küme başlatmak için başka bir ziyaret edilmemiş çekirdek noktasına geçer. Hiçbir çekirdek tarafından ulaşılmayan noktalar gürültü olarak etiketlenir.

Varsayımlar ve Sınırlamalar

Varsayımlar & Güçlü Yönler: DBSCAN, küresel kümeler varsaymaz – keyfi şekilli kümeleri bulabilir (hatta zincir benzeri veya bitişik kümeler). Veri yoğunluğuna dayalı olarak küme sayısını otomatik olarak belirler ve aykırı değerleri gürültü olarak etkili bir şekilde tanımlayabilir. Bu, düzensiz şekiller ve gürültü içeren gerçek dünya verileri için güçlü kılar. Aykırı değerlere karşı dayanıklıdır (K-Means'in aksine, onları kümelere zorlamaz). Kümeler yaklaşık olarak eşit yoğunlukta olduğunda iyi çalışır.

Sınırlamalar: DBSCAN'ın performansı uygun ε ve MinPts değerlerini seçmeye bağlıdır. Farklı yoğunluklara sahip verilerle zorlanabilir – tek bir ε, hem yoğun hem de seyrek kümeleri karşılayamaz. Eğer ε çok küçükse, çoğu noktayı gürültü olarak etiketler; çok büyükse, kümeler yanlış bir şekilde birleşebilir. Ayrıca, DBSCAN çok büyük veri setlerinde verimsiz olabilir (naif olarak $O(n^2)$, ancak mekansal indeksleme yardımcı olabilir). Yüksek boyutlu özellik alanlarında, “ε içindeki mesafe” kavramı daha az anlamlı hale gelebilir (boyutlanma laneti) ve DBSCAN dikkatli parametre ayarlaması gerektirebilir veya sezgisel kümeleri bulmakta başarısız olabilir. Bununla birlikte, HDBSCAN gibi uzantılar bazı sorunları (değişen yoğunluk gibi) ele alır.

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

Temel Bileşen Analizi (PCA)

PCA, verilerdeki maksimum varyansı yakalayan yeni bir ortogonal eksen seti (temel bileşenler) bulan boyut azaltma tekniğidir. Basit terimlerle, PCA verileri yeni bir koordinat sistemine döndürür ve projekte eder, böylece birinci temel bileşen (PC1) mümkün olan en büyük varyansı açıklar, ikinci PC (PC2) PC1'e dik en büyük varyansı açıklar ve bu şekilde devam eder. Matematiksel olarak, PCA verinin kovaryans matrisinin özvektillerini hesaplar - bu özvektiller temel bileşen yönleridir ve karşılık gelen özdeğerler her birinin açıkladığı varyans miktarını gösterir. Genellikle özellik çıkarımı, görselleştirme ve gürültü azaltma için kullanılır.

Bu, veri kümesi boyutlarının önemli lineer bağımlılıklar veya korelasyonlar içeriyorsa faydalıdır.

PCA, verilerin temel bileşenlerini tanımlayarak çalışır; bu, maksimum varyans yönleridir. PCA'da yer alan adımlar şunlardır:

1. Standartlaştırma: Verileri ortalamadan çıkararak ve birim varyansa ölçeklendirerek merkezleme.
2. Kovaryans Matrisi: Özellikler arasındaki ilişkileri anlamak için standartlaştırılmış verinin kovaryans matrisini hesaplama.
3. Özdeğer Ayrıştırması: Özdeğerleri ve özvektilleri elde etmek için kovaryans matrisinde özdeğer ayrıştırması yapma.
4. Temel Bileşenleri Seçme: Özdeğerleri azalan sırada sıralayın ve en büyük özdeğerlere karşılık gelen en üst K özvektörü seçin. Bu özvektiller yeni özellik alanını oluşturur.
5. Veriyi Dönüştürme: Seçilen temel bileşenleri kullanarak orijinal veriyi yeni özellik alanına projekte etme. PCA, veri görselleştirme, gürültü azaltma ve diğer makine öğrenimi algoritmaları için bir ön işleme adımı olarak yaygın olarak kullanılır. Verinin boyutunu azaltırken temel yapısını korumaya yardımcı olur.

Özdeğerler ve Özvektiller

Bir özdeğer, karşılık gelen özvektili tarafından yakalanan varyans miktarını gösteren bir skalar değerdir. Bir özvektör, verilerin en çok değiştiği yönü temsil eder.

A'nın bir kare matris olduğunu ve v'nin sıfırdan farklı bir vektör olduğunu varsayalım: A * v = λ * v burada:

• A, [ [1, 2], [2, 1]] gibi bir kare matristir (örneğin, kovaryans matrisi)
• v bir özvektördür (örneğin, [1, 1])

O zaman, A * v = [ [1, 2], [2, 1]] * [1, 1] = [3, 3] olacaktır; bu, özdeğer λ'nın özvektör v ile çarpılmasıdır ve özdeğer λ = 3 olur.

PCA'daki Özdeğerler ve Özvektiller

Bunu bir örnekle açıklayalım. 100x100 piksel boyutunda birçok gri tonlamalı yüz resmi içeren bir veri kümesine sahip olduğunuzu hayal edin. Her piksel bir özellik olarak kabul edilebilir, bu nedenle her görüntü için 10.000 özellik (veya her görüntü için 10000 bileşenden oluşan bir vektör) vardır. Bu veri kümesinin boyutunu PCA kullanarak azaltmak istiyorsanız, şu adımları izlersiniz:

1. Standartlaştırma: Her özelliğin (pikselin) ortalamasını veri kümesinden çıkararak verileri merkezleme.
2. Kovaryans Matrisi: Özelliklerin (piksel) birlikte nasıl değiştiğini yakalayan standartlaştırılmış verinin kovaryans matrisini hesaplama.

• İki değişken (bu durumda pikseller) arasındaki kovaryans, birlikte ne kadar değiştiklerini gösterir, bu nedenle burada amaç, hangi piksellerin lineer bir ilişki ile birlikte artma veya azalma eğiliminde olduğunu bulmaktır.
• Örneğin, piksel 1 ve piksel 2 birlikte artma eğilimindeyse, aralarındaki kovaryans pozitif olacaktır.
• Kovaryans matrisi, her bir girişin iki piksel arasındaki kovaryansı temsil ettiği 10.000x10.000 boyutunda bir matris olacaktır.

3. Özdeğer denklemini çözme: Çözülmesi gereken özdeğer denklemi C * v = λ * v şeklindedir; burada C kovaryans matrisidir, v özvektördür ve λ özdeğerdir. Şu yöntemlerle çözülebilir:

• Özdeğer Ayrıştırması: Özdeğerleri ve özvektilleri elde etmek için kovaryans matrisinde özdeğer ayrıştırması yapma.
• Tekil Değer Ayrıştırması (SVD): Alternatif olarak, verileri tekil değerler ve vektörler olarak ayrıştırmak için SVD kullanabilirsiniz; bu da temel bileşenleri elde edebilir.

4. Temel Bileşenleri Seçme: Özdeğerleri azalan sırada sıralayın ve en büyük özdeğerlere karşılık gelen en üst K özvektörü seçin. Bu özvektiller, verideki maksimum varyans yönlerini temsil eder.

Varsayımlar ve Sınırlamalar

PCA, temel varyans eksenlerinin anlamlı olduğunu varsayar - bu, lineer bir yöntemdir, bu nedenle verilerdeki lineer korelasyonları yakalar. Sadece özellik kovaryansını kullandığı için denetimsizdir. PCA'nın avantajları arasında gürültü azaltma (küçük varyanslı bileşenler genellikle gürültü ile ilişkilidir) ve özelliklerin dekorrelasyonu bulunur. Orta derecede yüksek boyutlar için hesaplama açısından verimlidir ve diğer algoritmalar için genellikle yararlı bir ön işleme adımıdır (boyut lanetini hafifletmek için). Bir sınırlama, PCA'nın yalnızca lineer ilişkilere sınırlı olmasıdır - karmaşık doğrusal olmayan yapıları yakalayamaz (oysa otomatik kodlayıcılar veya t-SNE yakalayabilir). Ayrıca, PCA bileşenleri, orijinal özellikler açısından yorumlanması zor olabilir (orijinal özelliklerin kombinasyonlarıdır). Siber güvenlikte, dikkatli olunmalıdır: düşük varyanslı bir özellikte yalnızca hafif bir değişiklik yaratan bir saldırı, en üst PC'lerde görünmeyebilir (çünkü PCA varyansı önceliklendirir, mutlaka "ilginçliği" değil).

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 Karışım Modelleri (GMM)

Bir Gaussian Karışım Modeli, verilerin bilinmeyen parametrelerle birkaç Gaussian (normal) dağılımının karışımından üretildiğini varsayar. Özünde, bu olasılıksal bir kümeleme modelidir: her noktayı K Gaussian bileşeninden birine yumuşak bir şekilde atamaya çalışır. Her Gaussian bileşeni k'nin bir ortalama vektörü (μ_k), bir kovaryans matrisine (Σ_k) ve o kümenin ne kadar yaygın olduğunu temsil eden bir karışım ağırlığı (π_k) vardır. K-Means'in "sert" atamalar yaptığı yerden farklı olarak, GMM her noktaya her kümede bulunma olasılığı verir.

GMM uyumu genellikle Beklenti-Maksimizasyon (EM) algoritması aracılığıyla yapılır:

• Başlatma: Ortalama, kovaryans ve karışım katsayıları için başlangıç tahminleri ile başlayın (veya başlangıç noktası olarak K-Means sonuçlarını kullanın).

• E-adımı (Beklenti): Mevcut parametreler verildiğinde, her nokta için her kümenin sorumluluğunu hesaplayın: esasen r_nk = P(z_k | x_n) burada z_k, x_n noktasının küme üyeliğini gösteren gizli değişkendir. Bu, Bayes teoremi kullanılarak yapılır; burada her noktanın mevcut parametrelere dayanarak her kümeye ait olma posterior olasılığını hesaplarız. Sorumluluklar şu şekilde hesaplanır:

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

burada:

• ( \pi_k ) küme k için karışım katsayısıdır (küme k'nin öncel olasılığı),

• ( \mathcal{N}(x_n | \mu_k, \Sigma_k) ) ortalama ( \mu_k ) ve kovaryans ( \Sigma_k ) verildiğinde nokta ( x_n ) için Gaussian olasılık yoğunluk fonksiyonudur.

• M-adımı (Maksimizasyon): E-adımında hesaplanan sorumlulukları kullanarak parametreleri güncelleyin:

• Her ortalamayı μ_k, noktaların ağırlıklı ortalaması olarak güncelleyin; burada ağırlıklar sorumluluklardır.

• Her kovaryansı Σ_k, küme k'ye atanan noktaların ağırlıklı kovaryansı olarak güncelleyin.

• Karışım katsayılarını π_k, küme k için ortalama sorumluluk olarak güncelleyin.

• E ve M adımlarını yakınsama sağlanana kadar yineleyin (parametreler stabilize olana veya olasılık iyileşmesi bir eşik altına düşene kadar).

Sonuç, genel veri dağılımını topluca modelleyen bir dizi Gaussian dağılımıdır. Uyumlu GMM'yi, her noktayı en yüksek olasılığa sahip Gaussian'a atayarak kümelemek için kullanabiliriz veya belirsizlik için olasılıkları saklayabiliriz. Yeni noktaların modelle uyumlu olup olmadığını değerlendirmek için de olasılıkları değerlendirebiliriz (anomali tespiti için yararlıdır).

Varsayımlar ve Sınırlamalar

GMM, kovaryansı içeren K-Means'in bir genellemesidir, böylece kümeler elipsoidal olabilir (sadece küresel değil). Kovaryans tam olduğunda farklı boyut ve şekillerdeki kümeleri işleyebilir. Yumuşak kümeleme, küme sınırları belirsiz olduğunda bir avantajdır – örneğin, siber güvenlikte bir olay birden fazla saldırı türünün özelliklerini taşıyabilir; GMM bu belirsizliği olasılıklarla yansıtabilir. GMM ayrıca verinin olasılıksal yoğunluk tahminini sağlar, bu da aykırı değerleri (tüm karışım bileşenleri altında düşük olasılığa sahip noktalar) tespit etmek için yararlıdır.

Diğer yandan, GMM bileşen sayısı K'nın belirtilmesini gerektirir (bunu seçmek için BIC/AIC gibi kriterler kullanılabilir). EM bazen yavaş yakınsama sağlayabilir veya yerel bir optimuma ulaşabilir, bu nedenle başlatma önemlidir (genellikle EM'yi birden fazla kez çalıştırmak gerekir). Veriler aslında Gaussian karışımını takip etmiyorsa, model kötü bir uyum sağlayabilir. Ayrıca, bir Gaussian'ın yalnızca bir aykırı değeri kapsayacak şekilde küçülme riski vardır (bunu hafifletmek için düzenleme veya minimum kovaryans sınırları kullanılabilir).

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