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 hierdie voorbeeld moet K-Means 4 groepe vind. Die klein aanvalsgroep (met ongewone hoë duur ~200) sal idealiter sy eie groep vorm gegewe sy afstand van normale groepe. Ons druk die grootte en sentrums van die groepe uit om die resultate te interpreteer. In 'n werklike scenario kan 'n mens die groep met 'n paar punte as potensiële anomalieë etiketteer of sy lede ondersoek vir kwaadwillige aktiwiteit.

Hiërargiese Groepering

Hiërargiese groepering bou 'n hiërargie van groepe op deur óf 'n onder-na-bo (agglomeratiewe) benadering óf 'n bo-na-onder (divisiewe) benadering te gebruik:

1. Agglomeratief (Onder-Na-Bo): Begin met elke datapunt as 'n aparte groep en kombineer herhaaldelik die naaste groepe totdat 'n enkele groep oorbly of 'n stopkriterium bereik word.
2. Divisief (Bo-Na-Onder): Begin met al die datapunte in 'n enkele groep en verdeel herhaaldelik die groepe totdat elke datapunt sy eie groep is of 'n stopkriterium bereik word.

Agglomeratiewe groepering vereis 'n definisie van inter-groep afstand en 'n skakelingskriterium om te besluit watter groepe saamgevoeg moet word. Algemene skakelingsmetodes sluit enkele skakeling (afstand van die naaste punte tussen twee groepe), volledige skakeling (afstand van die verste punte), gemiddelde skakeling, ensovoorts in, en die afstandsmetrie is dikwels Euclidies. Die keuse van skakeling beïnvloed die vorm van die groepe wat geproduseer word. Daar is geen behoefte om die aantal groepe K vooraf te spesifiseer nie; jy kan die dendrogram op 'n gekose vlak "sny" om die gewenste aantal groepe te verkry.

Hiërargiese groepering produseer 'n dendrogram, 'n boomagtige struktuur wat die verhoudings tussen groepe op verskillende vlakke van granulariteit toon. Die dendrogram kan op 'n gewenste vlak gesny word om 'n spesifieke aantal groepe te verkry.

Aannames en Beperkings

Hiërargiese groepering neem nie 'n spesifieke groepvorm aan nie en kan geneste groepe vasvang. Dit is nuttig om taksonomie of verhoudings tussen groepe te ontdek (bv. om kwaadwillige sagteware volgens familie subgroepe te groepeer). Dit is deterministies (geen ewekansige inisialisering probleme nie). 'n Sleutelvoordeel is die dendrogram, wat insig bied in die data se groeperingsstruktuur op alle skale – sekuriteitsontleders kan 'n toepaslike afsnit besluit om betekenisvolle groepe te identifiseer. Dit is egter rekenaarintensief (tipies $O(n^2)$ tyd of erger vir naïewe implementasies) en nie haalbaar vir baie groot datastelle nie. Dit is ook 'n gulsige prosedure – sodra 'n samesmelting of splitsing gedoen is, kan dit nie ongedaan gemaak word nie, wat kan lei tot suboptimale groepe as 'n fout vroeg gebeur. Uitskieters kan ook sommige skakelstrategieë beïnvloed (enkele skakeling kan die "ketting" effek veroorsaak waar groepe via uitskieters skakel).

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 (Digtheid-gebaseerde Ruimtelike Groepering van Toepassings met Ruis)

DBSCAN is 'n digtheid-gebaseerde groeperingsalgoritme wat punte wat naby mekaar gepak is, saamgroepeer terwyl dit punte in lae-digtheid gebiede as uitskieters merk. Dit is veral nuttig vir datastelle met verskillende digthede en nie-sferiese vorms.

DBSCAN werk deur twee parameters te definieer:

• Epsilon (ε): Die maksimum afstand tussen twee punte om as deel van dieselfde groep beskou te word.
• MinPts: Die minimum aantal punte wat benodig word om 'n digte gebied (kernpunt) te vorm.

DBSCAN identifiseer kernpunte, grenspunte en ruispunte:

• Kernpunt: 'n Punt met ten minste MinPts bure binne ε afstand.
• Grenspunt: 'n Punt wat binne ε afstand van 'n kernpunt is, maar minder as MinPts bure het.
• Ruispunt: 'n Punt wat nie 'n kernpunt of 'n grenspunt is nie.

Groepering vorder deur 'n onbesoekte kernpunt te kies, dit as 'n nuwe groep te merk, en dan alle punte wat digtheid-bereikbaar is vanaf dit (kernpunte en hul bure, ens.) rekursief by te voeg. Grenspunte word by die groep van 'n nabye kern gevoeg. Nadat alle bereikbare punte uitgebrei is, beweeg DBSCAN na 'n ander onbesoekte kern om 'n nuwe groep te begin. Punte wat nie deur enige kern bereik is nie, bly as ruis gemerk.

Aannames en Beperkings

Aannames & Sterkte:: DBSCAN neem nie sferiese groepe aan nie – dit kan arbitrêr gevormde groepe vind (selfs ketting-agtige of aangrensende groepe). Dit bepaal outomaties die aantal groepe gebaseer op datadigtheid en kan effektief uitskieters as ruis identifiseer. Dit maak dit kragtig vir werklike data met onreëlmatige vorms en ruis. Dit is robuust teen uitskieters (in teenstelling met K-Means, wat hulle in groepe dwing). Dit werk goed wanneer groepe ongeveer uniforme digtheid het.

Beperkings: DBSCAN se prestasie hang af van die keuse van toepaslike ε en MinPts waardes. Dit kan sukkel met data wat verskillende digthede het – 'n enkele ε kan nie beide digte en dun groepe akkommodeer nie. As ε te klein is, merk dit die meeste punte as ruis; te groot, en groepe kan verkeerd saamvloei. Ook, DBSCAN kan ondoeltreffend wees op baie groot datastelle (naïef $O(n^2)$, hoewel ruimtelike indeksering kan help). In hoë-dimensionele kenmerkruimtes kan die konsep van “afstand binne ε” minder betekenisvol word (die vloek van dimensionaliteit), en DBSCAN mag versigtige parameterafstemming benodig of mag misluk om intuïtiewe groepe te vind. Ten spyte van hierdie, adresseer uitbreidings soos HDBSCAN sommige probleme (soos verskillende digtheid).

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

Hoofkomponentanalise (PCA)

PCA is 'n tegniek vir dimensionaliteitsvermindering wat 'n nuwe stel ortogonale as (hoofkomponente) vind wat die maksimum variansie in die data vasvang. In eenvoudige terme draai PCA die data en projekteer dit op 'n nuwe koördinaatstelsel sodat die eerste hoofkomponent (PC1) die grootste moontlike variansie verduidelik, die tweede PC (PC2) die grootste variansie ortogonaal tot PC1 verduidelik, en so aan. Wiskundig bereken PCA die eie vektore van die data se kovariansiematrix – hierdie eie vektore is die richtings van die hoofkomponente, en die ooreenstemmende eie waardes dui die hoeveelheid variansie aan wat deur elkeen verduidelik word. Dit word dikwels gebruik vir kenmerk ekstraksie, visualisering, en geraasvermindering.

Let daarop dat dit nuttig is as die dataset dimensies beduidende lineêre afhanklikhede of korrelasies bevat.

PCA werk deur die hoofkomponente van die data te identifiseer, wat die richtings van maksimum variansie is. Die stappe wat betrokke is by PCA is:

1. Standaardisering: Sentraal die data deur die gemiddelde af te trek en dit na eenheidsvariansie te skaal.
2. Kovariansiematrix: Bereken die kovariansiematrix van die gestandaardiseerde data om die verhoudings tussen kenmerke te verstaan.
3. Eie waarde ontbinding: Voer eie waarde ontbinding op die kovariansiematrix uit om die eie waardes en eie vektore te verkry.
4. Kies Hoofkomponente: Sorteer die eie waardes in aflopende volgorde en kies die top K eie vektore wat ooreenstem met die grootste eie waardes. Hierdie eie vektore vorm die nuwe kenmerkruimte.
5. Transformeer Data: Projekteer die oorspronklike data op die nuwe kenmerkruimte met behulp van die geselekteerde hoofkomponente. PCA word wyd gebruik vir data visualisering, geraasvermindering, en as 'n voorverwerkings stap vir ander masjienleer algoritmes. Dit help om die dimensionaliteit van die data te verminder terwyl dit sy essensiële struktuur behou.

Eie waardes en Eie vektore

'n Eie waarde is 'n skaal wat die hoeveelheid variansie aandui wat deur sy ooreenstemmende eie vektor vasgevang word. 'n Eie vektor verteenwoordig 'n rigting in die kenmerkruimte waarlangs die data die meeste varieer.

Stel jou voor A is 'n vierkantige matriks, en v is 'n nie-nul vektor sodat: A * v = λ * v waar:

• A is 'n vierkantige matriks soos [ [1, 2], [2, 1]] (bv. kovariansiematrix)
• v is 'n eie vektor (bv. [1, 1])

Dan, A * v = [ [1, 2], [2, 1]] * [1, 1] = [3, 3] wat die eie waarde λ vermenigvuldig met die eie vektor v sal wees, wat die eie waarde λ = 3 maak.

Eie waardes en Eie vektore in PCA

Kom ons verduidelik dit met 'n voorbeeld. Stel jou voor jy het 'n dataset met baie grys skaal prente van gesigte van 100x100 pixels. Elke pixel kan as 'n kenmerk beskou word, so jy het 10,000 kenmerke per beeld (of 'n vektor van 10000 komponente per beeld). As jy die dimensionaliteit van hierdie dataset met PCA wil verminder, sal jy die volgende stappe volg:

1. Standaardisering: Sentraal die data deur die gemiddelde van elke kenmerk (pixel) van die dataset af te trek.
2. Kovariansiematrix: Bereken die kovariansiematrix van die gestandaardiseerde data, wat vasvang hoe kenmerke (pixels) saam varieer.

• Let daarop dat die kovariansie tussen twee veranderlikes (pixels in hierdie geval) aandui hoe baie hulle saam verander, so die idee hier is om uit te vind watter pixels geneig is om saam te verhoog of te verlaag met 'n lineêre verhouding.
• Byvoorbeeld, as pixel 1 en pixel 2 geneig is om saam te verhoog, sal die kovariansie tussen hulle positief wees.
• Die kovariansiematrix sal 'n 10,000x10,000 matriks wees waar elke inskrywing die kovariansie tussen twee pixels verteenwoordig.

3. Los die eie waarde vergelyking op: Die eie waarde vergelyking om op te los is C * v = λ * v waar C die kovariansiematrix is, v die eie vektor is, en λ die eie waarde is. Dit kan opgelos word met metodes soos:

• Eie waarde ontbinding: Voer eie waarde ontbinding op die kovariansiematrix uit om die eie waardes en eie vektore te verkry.
• Singuliere waarde ontbinding (SVD): Alternatiewelik kan jy SVD gebruik om die datamatriks in singuliere waardes en vektore te ontbind, wat ook die hoofkomponente kan oplewer.

4. Kies Hoofkomponente: Sorteer die eie waardes in aflopende volgorde en kies die top K eie vektore wat ooreenstem met die grootste eie waardes. Hierdie eie vektore verteenwoordig die richtings van maksimum variansie in die data.

Aannames en Beperkings

PCA neem aan dat hoofasse van variansie betekenisvol is – dit is 'n lineêre metode, so dit vang lineêre korrelasies in data vas. Dit is nie-begeleide omdat dit slegs die kenmerk kovariansie gebruik. Voordele van PCA sluit geraasvermindering in (klein-variansie komponente stem dikwels ooreen met geraas) en dekorelasie van kenmerke. Dit is rekenaar-effektief vir matig hoë dimensies en dikwels 'n nuttige voorverwerkings stap vir ander algoritmes (om die vloek van dimensionaliteit te verminder). Een beperking is dat PCA beperk is tot lineêre verhoudings – dit sal nie komplekse nie-lineêre struktuur vasvang nie (terwyl outokoders of t-SNE dit mag). Ook kan PCA komponente moeilik wees om te interpreteer in terme van oorspronklike kenmerke (dit is kombinasies van oorspronklike kenmerke). In kuberveiligheid moet 'n mens versigtig wees: 'n aanval wat net 'n subtiele verandering in 'n lae-variansie kenmerk veroorsaak, mag nie in die top PC's verskyn nie (aangesien PCA variansie prioritiseer, nie noodwendig "interessantheid" nie).

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)

'n Gaussian Mixture Model neem aan dat data gegenereer word uit 'n mengsel van verskeie Gaussian (normale) verspreidings met onbekende parameters. In wese is dit 'n probabilistiese klusteringmodel: dit probeer om elke punt sagkens aan een van K Gaussian komponente toe te ken. Elke Gaussian komponent k het 'n gemiddelde vektor (μ_k), kovariansiematrix (Σ_k), en 'n menggewig (π_k) wat verteenwoordig hoe algemeen daardie kluster is. Anders as K-Means wat "harde" toekennings doen, gee GMM elke punt 'n waarskynlikheid om tot elke kluster te behoort.

GMM-aanpassing word tipies gedoen via die Verwachting-Maximisasie (EM) algoritme:

• Inisialisering: Begin met aanvanklike raaiskote vir die gemiddeldes, kovariansies, en mengkoëffisiënte (of gebruik K-Means resultate as 'n beginpunt).

• E-stap (Verwagting): Gegewe huidige parameters, bereken die verantwoordelikheid van elke kluster vir elke punt: essensieel r_nk = P(z_k | x_n) waar z_k die latente veranderlike is wat klusterlidmaatskap vir punt x_n aandui. Dit word gedoen met behulp van Bayes se stelling, waar ons die posterior waarskynlikheid van elke punt wat tot elke kluster behoort, gebaseer op die huidige parameters, bereken. Die verantwoordelikhede word bereken as:

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

waar:

• ( \pi_k ) is die mengkoëffisiënt vir kluster k (vooraf waarskynlikheid van kluster k),

• ( \mathcal{N}(x_n | \mu_k, \Sigma_k) ) is die Gaussian waarskynlikheidsdigtheidsfunksie vir punt ( x_n ) gegewe gemiddelde ( \mu_k ) en kovariansie ( \Sigma_k ).

• M-stap (Maximisasie): Werk die parameters op met behulp van die verantwoordelikhede wat in die E-stap bereken is:

• Werk elke gemiddelde μ_k op as die gewogen gemiddelde van punte, waar gewigte die verantwoordelikhede is.

• Werk elke kovariansie Σ_k op as die gewogen kovariansie van punte wat aan kluster k toegewys is.

• Werk mengkoëffisiënte π_k op as die gemiddelde verantwoordelikheid vir kluster k.

• Herhaal E- en M-stappe totdat konvergensie plaasvind (parameters stabiliseer of waarskynlikheidsverbetering onder 'n drempel is).

Die resultaat is 'n stel Gaussian verspreidings wat saam die algehele dataverspreiding modelleer. Ons kan die aangepaste GMM gebruik om te kluster deur elke punt aan die Gaussian met die hoogste waarskynlikheid toe te ken, of die waarskynlikhede vir onsekerheid te behou. 'n Mens kan ook die waarskynlikheid van nuwe punte evalueer om te sien of hulle by die model pas (nuttig vir anomaliedetektering).

Aannames en Beperkings

GMM is 'n generalisering van K-Means wat kovariansie inkorporeer, sodat klusters ellipsoïdaal kan wees (nie net sferies nie). Dit hanteer klusters van verskillende groottes en vorms as die kovariansie vol is. Sagte klustering is 'n voordeel wanneer klustergrense vaag is – byvoorbeeld, in kuberveiligheid kan 'n gebeurtenis eienskappe van verskeie aanvalstipes hê; GMM kan daardie onsekerheid met waarskynlikhede weerspieël. GMM bied ook 'n probabilistiese digtheidskattings van die data, nuttig vir die opsporing van uitskieters (punte met lae waarskynlikheid onder al die mengkomponente).

Aan die ander kant vereis GMM die spesifisering van die aantal komponente K (alhoewel 'n mens kriteria soos BIC/AIC kan gebruik om dit te kies). EM kan soms stadig konvergeer of na 'n plaaslike optimum, so inisialisering is belangrik (dikwels EM verskeie kere gedoen). As die data nie werklik 'n mengsel van Gaussians volg nie, kan die model 'n swak pas wees. Daar is ook 'n risiko dat een Gaussian krimp om net 'n uitskieter te dek (alhoewel regularisering of minimum kovariansie grense dit kan verminder).

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

import pandas as pd
from hdbscan import HDBSCAN
from sklearn.preprocessing import StandardScaler

# df has features extracted from proxy logs
features = [
"avg_interval",      # seconds between requests
"uri_length_mean",   # average URI length
"user_agent_entropy" # Shannon entropy of UA string
]
X = StandardScaler().fit_transform(df[features])

hdb = HDBSCAN(min_cluster_size=15,  # at least 15 similar beacons to be a group
metric="euclidean",
prediction_data=True)
labels = hdb.fit_predict(X)

df["cluster"] = labels
# Anything with label == -1 is noise → inspect as potential C2
suspects = df[df["cluster"] == -1]
print("Suspect beacon count:", len(suspects))

pyod benchmark --input logs.csv --label attack --n_jobs 8

from pyod.models import ECOD, IForest
from pyod.utils.data import generate_data, evaluate_print
from pyod.utils.example import visualize

X_train, y_train, X_test, y_test = generate_data(
n_train=5000, n_test=1000, n_features=16,
contamination=0.02, random_state=42)

models = [ECOD(), IForest()]

# majority vote – flag if any model thinks it is anomalous
anomaly_scores = sum(m.fit(X_train).decision_function(X_test) for m in models) / len(models)

evaluate_print("Ensemble", y_test, anomaly_scores)