Algoritmi nesupervizovanog učenja

Nesupervizovano učenje

Nesupervizovano učenje je vrsta mašinskog učenja gde se model obučava na podacima bez označenih odgovora. Cilj je pronaći obrasce, strukture ili odnose unutar podataka. Za razliku od supervizovanog učenja, gde model uči iz označenih primera, algoritmi nesupervizovanog učenja rade sa neoznačenim podacima. Nesupervizovano učenje se često koristi za zadatke kao što su klasterizacija, smanjenje dimenzionalnosti i detekcija anomalija. Može pomoći u otkrivanju skrivenih obrazaca u podacima, grupisanju sličnih stavki ili smanjenju složenosti podataka uz očuvanje njihovih suštinskih karakteristika.

K-Means klasterizacija

K-Means je algoritam klasterizacije zasnovan na centroidima koji deli podatke u K klastera dodeljujući svaku tačku najbližem srednjem klasteru. Algoritam funkcioniše na sledeći način:

1. Inicijalizacija: Izaberite K početnih centara klastera (centroida), često nasumično ili putem pametnijih metoda kao što je k-means++
2. Dodeljivanje: Dodelite svaku tačku podataka najbližem centroidu na osnovu metričke udaljenosti (npr. Euklidska udaljenost).
3. Ažuriranje: Ponovo izračunajte centre uzimajući prosek svih tačaka podataka dodeljenih svakom klasteru.
4. Ponoviti: Koraci 2–3 se ponavljaju dok se dodeljivanje klastera ne stabilizuje (centroidi se više ne pomeraju značajno).

Odabir K

Broj klastera (K) je hiperparametar koji treba definisati pre pokretanja algoritma. Tehnike poput Elbow metode ili Silhouette skora mogu pomoći u određivanju odgovarajuće vrednosti za K procenom performansi klasterizacije:

• Elbow metoda: Prikazujte sumu kvadratnih udaljenosti svake tačke do njenog dodeljenog centroida klastera kao funkciju K. Tražite "lakat" tačku gde se stopa opadanja naglo menja, što ukazuje na odgovarajući broj klastera.
• Silhouette skor: Izračunajte silhouette skor za različite vrednosti K. Viši silhouette skor ukazuje na bolje definisane klastere.

Pretpostavke i ograničenja

K-Means pretpostavlja da su klasteri sferni i jednake veličine, što možda nije tačno za sve skupove podataka. Osetljiv je na početno postavljanje centroida i može konvergirati ka lokalnim minimumima. Pored toga, K-Means nije pogodan za skupove podataka sa različitim gustinama ili neglobularnim oblicima i karakteristikama različitih razmera. Koraci predobrada poput normalizacije ili standardizacije mogu biti neophodni kako bi se osiguralo da sve karakteristike ravnomerno doprinose izračunavanju udaljenosti.

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

Hijerarhijsko Klasterovanje

Hijerarhijsko klasterovanje gradi hijerarhiju klastera koristeći ili pristup odozdo prema gore (aglomerativni) ili pristup odozgo prema dole (divizivni):

1. Aglomerativno (odozdo prema gore): Počnite sa svakom tačkom podataka kao posebnim klasterom i iterativno spajajte najbliže klastere dok ne ostane jedan klaster ili se ne ispuni kriterijum zaustavljanja.
2. Divizivno (odozgo prema dole): Počnite sa svim tačkama podataka u jednom klasteru i iterativno delite klastere dok svaka tačka podataka ne postane svoj vlastiti klaster ili se ne ispuni kriterijum zaustavljanja.

Aglomerativno klasterovanje zahteva definiciju međuklaster udaljenosti i kriterijum povezivanja da bi se odlučilo koji klasteri će se spojiti. Uobičajene metode povezivanja uključuju pojedinačno povezivanje (udaljenost najbližih tačaka između dva klastera), potpuno povezivanje (udaljenost najdaljih tačaka), prosečno povezivanje itd., a metrička udaljenost je često euklidska. Izbor povezivanja utiče na oblik proizvedenih klastera. Nema potrebe da se unapred definiše broj klastera K; možete "prerezati" dendrogram na odabranom nivou da biste dobili željeni broj klastera.

Hijerarhijsko klasterovanje proizvodi dendrogram, strukturu nalik drvetu koja prikazuje odnose između klastera na različitim nivoima granularnosti. Dendrogram se može prerezati na željenom nivou da bi se dobio specifičan broj klastera.

Pretpostavke i Ograničenja

Hijerarhijsko klasterovanje ne pretpostavlja određeni oblik klastera i može uhvatiti ugnježdene klastere. Korisno je za otkrivanje taksonomije ili odnosa među grupama (npr. grupisanje malvera po porodicama). Determinističko je (nema problema sa nasumičnom inicijalizacijom). Ključna prednost je dendrogram, koji pruža uvid u strukturu klasterovanja podataka na svim razmerama – analitičari bezbednosti mogu odlučiti o odgovarajućem preseku da identifikuju značajne klastere. Međutim, računski je skup (tipično $O(n^2)$ vremena ili gore za naivne implementacije) i nije izvodljiv za veoma velike skupove podataka. Takođe je pohlepna procedura – jednom kada se spajanje ili deljenje izvrši, ne može se poništiti, što može dovesti do suboptimalnih klastera ako se greška dogodi rano. Izuzeci takođe mogu uticati na neke strategije povezivanja (jednostavno povezivanje može izazvati efekat "lančanja" gde se klasteri povezuju putem izuzetaka).

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 (Klasterovanje na bazi gustine sa šumom)

DBSCAN je algoritam klasterovanja zasnovan na gustini koji grupiše tačke koje su blisko smeštene zajedno, dok označava tačke u oblastima niske gustine kao izuzetke. Posebno je koristan za skupove podataka sa različitim gustinama i nesfernim oblicima.

DBSCAN funkcioniše definisanjem dva parametra:

• Epsilon (ε): Maksimalna udaljenost između dve tačke da bi se smatrale delom istog klastera.
• MinPts: Minimalan broj tačaka potrebnih za formiranje guste oblasti (glavna tačka).

DBSCAN identifikuje glavne tačke, tačke na granici i tačke šuma:

• Glavna tačka: Tačka sa najmanje MinPts suseda unutar ε udaljenosti.
• Tačka na granici: Tačka koja se nalazi unutar ε udaljenosti od glavne tačke, ali ima manje od MinPts suseda.
• Tačka šuma: Tačka koja nije ni glavna tačka ni tačka na granici.

Klasterovanje se nastavlja biranjem neposećene glavne tačke, označavanjem kao novog klastera, a zatim rekurzivnim dodavanjem svih tačaka koje su dostupne po gustini (glavne tačke i njihovi susedi, itd.). Tačke na granici se dodaju klasteru bliske glavne tačke. Nakon proširenja svih dostupnih tačaka, DBSCAN prelazi na drugu neposećenu glavnu tačku da započne novi klaster. Tačke koje nisu dostignute od strane nijedne glavne tačke ostaju označene kao šum.

Pretpostavke i Ograničenja

Pretpostavke i Snage: DBSCAN ne pretpostavlja sferne klastere – može pronaći klastere proizvoljnog oblika (čak i lančaste ili susedne klastere). Automatski određuje broj klastera na osnovu gustine podataka i može efikasno identifikovati izuzetke kao šum. Ovo ga čini moćnim za stvarne podatke sa nepravilnim oblicima i šumom. Otporan je na izuzetke (za razliku od K-Means, koji ih prisiljava u klastere). Dobro funkcioniše kada klasteri imaju otprilike uniformnu gustinu.

Ograničenja: Performanse DBSCAN-a zavise od izbora odgovarajućih ε i MinPts vrednosti. Može imati problema sa podacima koji imaju različite gustine – jedna ε ne može obuhvatiti i guste i retke klastere. Ako je ε previše mala, označava većinu tačaka kao šum; prevelika, i klasteri se mogu pogrešno spojiti. Takođe, DBSCAN može biti neefikasan na veoma velikim skupovima podataka (naivno $O(n^2)$, iako prostorno indeksiranje može pomoći). U visokodimenzionalnim prostorima karakteristika, koncept "udaljenosti unutar ε" može postati manje značajan (prokletstvo dimenzionalnosti), i DBSCAN može zahtevati pažljivo podešavanje parametara ili može propasti u pronalaženju intuitivnih klastera. I pored ovoga, proširenja poput HDBSCAN rešavaju neka pitanja (poput varijabilne gustine).

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

Analiza glavnih komponenti (PCA)

PCA je tehnika za smanjenje dimenzionalnosti koja pronalazi novi skup ortogonalnih osa (glavnih komponenti) koje hvataju maksimalnu varijansu u podacima. U jednostavnim terminima, PCA rotira i projektuje podatke na novi koordinatni sistem tako da prva glavna komponenta (PC1) objašnjava najveću moguću varijansu, druga PC (PC2) objašnjava najveću varijansu ortogonalnu na PC1, i tako dalje. Matematički, PCA izračunava sopstvene vektore kovarijantne matrice podataka – ovi sopstveni vektori su pravci glavnih komponenti, a odgovarajući sopstveni vrednosti ukazuju na količinu varijanse koju objašnjava svaki. Često se koristi za ekstrakciju karakteristika, vizualizaciju i smanjenje šuma.

Napomena da je ovo korisno ako dimenzije skupa podataka sadrže značajne linearne zavisnosti ili korelacije.

PCA funkcioniše identifikovanjem glavnih komponenti podataka, koje su pravci maksimalne varijanse. Koraci uključeni u PCA su:

1. Standardizacija: Centriranje podataka oduzimanjem proseka i skaliranjem na jediničnu varijansu.
2. Kovarijantna matrica: Izračunavanje kovarijantne matrice standardizovanih podataka kako bi se razumele veze između karakteristika.
3. Dezintegracija sopstvenih vrednosti: Izvršavanje dezintegracije sopstvenih vrednosti na kovarijantnoj matrici kako bi se dobile sopstvene vrednosti i sopstveni vektori.
4. Odabir glavnih komponenti: Sortiranje sopstvenih vrednosti u opadajućem redosledu i odabir vrhunskih K sopstvenih vektora koji odgovaraju najvećim sopstvenim vrednostima. Ovi sopstveni vektori formiraju novi prostor karakteristika.
5. Transformacija podataka: Projekcija originalnih podataka na novi prostor karakteristika koristeći odabrane glavne komponente. PCA se široko koristi za vizualizaciju podataka, smanjenje šuma i kao korak predobrada za druge algoritme mašinskog učenja. Pomaže u smanjenju dimenzionalnosti podataka dok zadržava njegovu suštinsku strukturu.

Sopstvene vrednosti i sopstveni vektori

Sopstvena vrednost je skalar koji ukazuje na količinu varijanse koju hvata njen odgovarajući sopstveni vektor. Sopstveni vektor predstavlja pravac u prostoru karakteristika duž kojeg se podaci najviše menjaju.

Zamislite da je A kvadratna matrica, a v je nenulti vektor tako da: A * v = λ * v gde:

• A je kvadratna matrica poput [ [1, 2], [2, 1]] (npr., kovarijantna matrica)
• v je sopstveni vektor (npr., [1, 1])

Tada, A * v = [ [1, 2], [2, 1]] * [1, 1] = [3, 3] što će biti sopstvena vrednost λ pomnožena sa sopstvenim vektorom v, čineći sopstvenu vrednost λ = 3.

Sopstvene vrednosti i sopstveni vektori u PCA

Objasnimo ovo sa primerom. Zamislite da imate skup podataka sa puno slika lica u sivim tonovima dimenzija 100x100 piksela. Svaki piksel se može smatrati karakteristikom, tako da imate 10,000 karakteristika po slici (ili vektor od 10000 komponenti po slici). Ako želite da smanjite dimenzionalnost ovog skupa podataka koristeći PCA, pratili biste ove korake:

1. Standardizacija: Centriranje podataka oduzimanjem proseka svake karakteristike (piksela) iz skupa podataka.
2. Kovarijantna matrica: Izračunavanje kovarijantne matrice standardizovanih podataka, koja hvata kako se karakteristike (pikseli) zajedno menjaju.

• Napomena da kovarijansa između dve varijable (piksela u ovom slučaju) ukazuje na to koliko se zajedno menjaju, tako da je ideja ovde otkriti koji piksela imaju tendenciju da se povećavaju ili smanjuju zajedno sa linearnom vezom.
• Na primer, ako piksel 1 i piksel 2 imaju tendenciju da se zajedno povećavaju, kovarijansa između njih će biti pozitivna.
• Kovarijantna matrica će biti 10,000x10,000 matrica gde svaki unos predstavlja kovarijansu između dva piksela.

3. Rešavanje sopstvene vrednosti: Sopstvena vrednost koju treba rešiti je C * v = λ * v gde je C kovarijantna matrica, v je sopstveni vektor, a λ je sopstvena vrednost. Može se rešiti korišćenjem metoda kao što su:

• Dezintegracija sopstvenih vrednosti: Izvršavanje dezintegracije sopstvenih vrednosti na kovarijantnoj matrici kako bi se dobile sopstvene vrednosti i sopstveni vektori.
• Dezintegracija singularnih vrednosti (SVD): Alternativno, možete koristiti SVD za dekompoziciju matrice podataka u singularne vrednosti i vektore, što takođe može dati glavne komponente.

4. Odabir glavnih komponenti: Sortiranje sopstvenih vrednosti u opadajućem redosledu i odabir vrhunskih K sopstvenih vektora koji odgovaraju najvećim sopstvenim vrednostima. Ovi sopstveni vektori predstavljaju pravce maksimalne varijanse u podacima.

Pretpostavke i ograničenja

PCA pretpostavlja da su glavne ose varijanse značajne – to je linearna metoda, tako da hvata linearne korelacije u podacima. To je nesupervizovana metoda jer koristi samo kovarijansu karakteristika. Prednosti PCA uključuju smanjenje šuma (komponente male varijanse često odgovaraju šumu) i dekorelaciju karakteristika. Efikasna je u računski umjerenim visokim dimenzijama i često je koristan korak predobrada za druge algoritme (da ublaži prokletstvo dimenzionalnosti). Jedno ograničenje je to što je PCA ograničen na linearne odnose – neće uhvatiti složenu nelinearnu strukturu (dok bi autoenkoderi ili t-SNE mogli). Takođe, komponente PCA mogu biti teške za interpretaciju u smislu originalnih karakteristika (one su kombinacije originalnih karakteristika). U sajber bezbednosti, treba biti oprezan: napad koji uzrokuje samo suptilnu promenu u karakteristici male varijanse možda se neće pojaviti u vrhunskim PC-ima (pošto PCA prioritizuje varijansu, a ne nužno "zanimljivost").

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)

Gaussian Mixture Model pretpostavlja da su podaci generisani iz mešavine several Gaussian (normal) distributions with unknown parameters. U suštini, to je probabilistički model klasterisanja: pokušava da blago dodeli svaku tačku jednom od K Gaussian komponenti. Svaka Gaussian komponenta k ima vektor srednje vrednosti (μ_k), kovarijantnu matricu (Σ_k) i težinu mešanja (π_k) koja predstavlja koliko je taj klaster prisutan. Za razliku od K-Means koji vrši "tvrde" dodeljivanje, GMM daje svakoj tački verovatnoću pripadnosti svakom klasteru.

GMM prilagođavanje se obično vrši putem algoritma Expectation-Maximization (EM):

• Inicijalizacija: Počnite sa početnim pretpostavkama za srednje vrednosti, kovarijanse i koeficijente mešanja (ili koristite rezultate K-Means kao početnu tačku).

• E-korak (Očekivanje): S obzirom na trenutne parametre, izračunajte odgovornost svakog klastera za svaku tačku: suštinski r_nk = P(z_k | x_n) gde je z_k latentna varijabla koja ukazuje na članstvo u klasteru za tačku x_n. Ovo se radi koristeći Bayesovu teoremu, gde izračunavamo posteriornu verovatnoću svake tačke da pripada svakom klasteru na osnovu trenutnih parametara. Odgovornosti se izračunavaju kao:

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

gde:

• ( \pi_k ) je koeficijent mešanja za klaster k (prior verovatnoća klastera k),

• ( \mathcal{N}(x_n | \mu_k, \Sigma_k) ) je Gaussian funkcija gustine verovatnoće za tačku ( x_n ) s obzirom na srednju vrednost ( \mu_k ) i kovarijansu ( \Sigma_k ).

• M-korak (Maksimizacija): Ažurirajte parametre koristeći odgovornosti izračunate u E-koraku:

• Ažurirajte svaku srednju vrednost μ_k kao ponderisanu srednju vrednost tačaka, gde su težine odgovornosti.

• Ažurirajte svaku kovarijansu Σ_k kao ponderisanu kovarijansu tačaka dodeljenih klasteru k.

• Ažurirajte koeficijente mešanja π_k kao prosečnu odgovornost za klaster k.

• Iterirajte E i M korake dok ne dođe do konvergencije (parametri se stabilizuju ili poboljšanje verovatnoće je ispod praga).

Rezultat je skup Gaussian distribucija koje kolektivno modeliraju ukupnu distribuciju podataka. Možemo koristiti prilagođeni GMM za klasterisanje dodeljivanjem svake tačke Gaussian-u sa najvišom verovatnoćom, ili zadržati verovatnoće za nesigurnost. Takođe se može proceniti verovatnoća novih tačaka da vide da li se uklapaju u model (korisno za otkrivanje anomalija).

Pretpostavke i Ograničenja

GMM je generalizacija K-Means koja uključuje kovarijansu, tako da klasteri mogu biti elipsoidni (ne samo sferni). Rukuje klasterima različitih veličina i oblika ako je kovarijansa puna. Mekano klasterisanje je prednost kada su granice klastera nejasne – npr., u sajber bezbednosti, događaj može imati osobine više tipova napada; GMM može odražavati tu nesigurnost sa verovatnoćama. GMM takođe pruža procenu gustine verovatnoće podataka, korisnu za otkrivanje outliera (tačke sa niskom verovatnoćom pod svim komponentama mešavine).

S druge strane, GMM zahteva da se specificira broj komponenti K (iako se mogu koristiti kriterijumi poput BIC/AIC za njegovu selekciju). EM ponekad može sporo konvergirati ili do lokalnog optimuma, tako da je inicijalizacija važna (često se EM pokreće više puta). Ako podaci zapravo ne prate mešavinu Gaussian-a, model može biti loše prilagođen. Takođe postoji rizik da jedan Gaussian smanji da pokrije samo outlier (iako regularizacija ili minimalne granice kovarijanse mogu to ublažiti).

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