Kufikiria tuna kumbukumbu za muunganisho wa mtandao zenye vipengele vingi (mfano, muda, bytes, hesabu). Tutaunda dataset ya bandia ya vipimo 4 (ikiwa na uhusiano kati ya vipengele) na kutumia PCA kupunguza hadi vipimo 2 kwa ajili ya uonyeshaji au uchambuzi zaidi.

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

Hapa tulichukua makundi ya awali ya trafiki ya kawaida na kupanua kila kipengele cha data kwa vipengele viwili vya ziada (pakiti na makosa) vinavyohusiana na bytes na muda. PCA inatumika kubana vipengele 4 kuwa vipengele 2 vya msingi. Tunachapisha uwiano wa tofauti iliyoelezewa, ambayo inaweza kuonyesha kwamba, sema, >95% ya tofauti inakamatwa na vipengele 2 (kumanisha kupoteza kwa habari kidogo). Matokeo pia yanaonyesha umbo la data likipungua kutoka (1500, 4) hadi (1500, 2). Pointi chache za kwanza katika nafasi ya PCA zinatolewa kama mfano. Katika mazoezi, mtu anaweza kuchora data_2d ili kuangalia kwa kuona kama makundi yanaweza kutofautishwa. Ikiwa kasoro ilikuwa ipo, mtu anaweza kuiona kama pointi iliyoko mbali na kundi kuu katika nafasi ya PCA. Hivyo, PCA inasaidia kuondoa data ngumu kuwa mfumo unaoweza kudhibitiwa kwa tafsiri ya kibinadamu au kama ingizo kwa algorithimu nyingine.

Gaussian Mixture Models (GMM)

Mfano wa Mchanganyiko wa Gaussian unadhani data inazalishwa kutoka mchanganyiko wa usambazaji kadhaa wa Gaussian (kawaida) wenye vigezo visivyojulikana. Kwa msingi, ni mfano wa makundi ya uwezekano: inajaribu kwa upole kupeana kila pointi kwa moja ya vipengele K vya Gaussian. Kila kipengele cha Gaussian k kina vector ya wastani (μ_k), matrix ya covariance (Σ_k), na uzito wa mchanganyiko (π_k) unaowrepresenta jinsi kundi hilo lilivyo maarufu. Tofauti na K-Means ambayo inafanya "ugawaji" mgumu, GMM inampa kila pointi uwezekano wa kuwa katika kila kundi.

Ulinganifu wa GMM kawaida hufanywa kupitia algorithm ya Expectation-Maximization (EM):

• Kuanza: Anza na makadirio ya awali ya wastani, covariances, na coefficients za mchanganyiko (au tumia matokeo ya K-Means kama hatua ya mwanzo).

• E-step (Matarajio): Iwapo vigezo vya sasa, hesabu jukumu la kila kundi kwa kila pointi: kimsingi r_nk = P(z_k | x_n) ambapo z_k ni variable ya siri inayoashiria uanachama wa kundi kwa pointi x_n. Hii inafanywa kwa kutumia nadharia ya Bayes, ambapo tunahesabu uwezekano wa nyuma wa kila pointi kuwa katika kila kundi kulingana na vigezo vya sasa. Majukumu yanahesabiwa kama:

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

ambapo:

• ( \pi_k ) ni coefficient ya mchanganyiko kwa kundi k (uwezekano wa awali wa kundi k),

• ( \mathcal{N}(x_n | \mu_k, \Sigma_k) ) ni kazi ya uwezekano wa density ya Gaussian kwa pointi ( x_n ) ikizingatia wastani ( \mu_k ) na covariance ( \Sigma_k ).

• M-step (Uboreshaji): Sasisha vigezo kwa kutumia majukumu yaliyohesabiwa katika hatua ya E:

• Sasisha kila wastani μ_k kama wastani wa uzito wa pointi, ambapo uzito ni majukumu.

• Sasisha kila covariance Σ_k kama covariance ya uzito wa pointi zilizotengwa kwa kundi k.

• Sasisha coefficients za mchanganyiko π_k kama wastani wa jukumu kwa kundi k.

• Rudia hatua za E na M hadi kufikia muafaka (vigezo vinapojisimamia au kuboresha uwezekano uko chini ya kigezo).

Matokeo ni seti ya usambazaji wa Gaussian ambayo kwa pamoja inasimamia usambazaji wa data kwa ujumla. Tunaweza kutumia GMM iliyofanywa kuunda makundi kwa kupeana kila pointi kwa Gaussian yenye uwezekano mkubwa, au kuweka uwezekano kwa ajili ya kutokuwa na uhakika. Mtu anaweza pia kutathmini uwezekano wa pointi mpya ili kuona kama zinafaa katika mfano (inayofaa kwa kugundua kasoro).

Dhana na Mipaka

GMM ni jumla ya K-Means ambayo inajumuisha covariance, hivyo makundi yanaweza kuwa ya ellipsoidal (siyo tu ya mpira). Inashughulikia makundi ya ukubwa na sura tofauti ikiwa covariance ni kamili. Kugawanya kwa upole ni faida wakati mipaka ya kundi ni fuzzy – e.g., katika usalama wa mtandao, tukio linaweza kuwa na sifa za aina kadhaa za shambulio; GMM inaweza kuonyesha kutokuwa na uhakika hiyo kwa uwezekano. GMM pia inatoa tathmini ya density ya uwezekano wa data, inayofaa kwa kugundua nje (pointi zenye uwezekano mdogo chini ya vipengele vyote vya mchanganyiko).

Kwa upande wa hasara, GMM inahitaji kufafanua idadi ya vipengele K (ingawa mtu anaweza kutumia vigezo kama BIC/AIC kuichagua). EM inaweza wakati mwingine kuja kwa muafaka polepole au kwa muafaka wa ndani, hivyo kuanzisha ni muhimu (mara nyingi inafanya EM mara kadhaa). Ikiwa data haifuati mchanganyiko wa Gaussians, mfano unaweza kuwa na ufanisi duni. Pia kuna hatari ya Gaussian mmoja kupungua ili kufunika tu nje (ingawa udhibiti au mipaka ya chini ya covariance inaweza kupunguza hiyo).

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)

Katika msimbo huu, tunafundisha GMM na Gaussians 3 kwenye trafiki ya kawaida (tukidhani tunajua wasifu 3 wa trafiki halali). Maana na covariances zilizochapishwa zinaelezea makundi haya (kwa mfano, maana moja inaweza kuwa karibu [50,500] inayohusiana na kituo cha kundi moja, n.k.). Kisha tunajaribu muunganisho wa kutatanisha [duration=200, bytes=800]. predict_proba inatoa uwezekano wa pointi hii kuhusika na kila moja ya makundi 3 – tungeweza kutarajia uwezekano huu kuwa wa chini sana au kupindishwa sana kwani [200,800] iko mbali na makundi ya kawaida. Alama ya jumla ya score_samples (log-likelihood) inachapishwa; thamani ya chini sana inaonyesha kuwa pointi hiyo haifai vizuri kwenye mfano, ikionyesha kama anomalous. Katika mazoezi, mtu anaweza kuweka kigezo kwenye log-likelihood (au kwenye uwezekano wa juu) ili kuamua ikiwa pointi ni ya kutosha kutokuwa na hatari. GMM hivyo hutoa njia iliyo na kanuni ya kufanya ugunduzi wa anomalies na pia inatoa makundi laini yanayotambua kutokuwa na uhakika.

Isolation Forest

Isolation Forest ni algorithm ya ugunduzi wa anomalies ya kundi inayotegemea wazo la kutenga pointi kwa bahati nasibu. Kanuni ni kwamba anomalies ni chache na tofauti, hivyo ni rahisi kuzitenga kuliko pointi za kawaida. Isolation Forest inajenga miti nyingi za kutenga binary (miti ya maamuzi ya bahati nasibu) ambazo zinagawanya data kwa bahati nasibu. Kila node kwenye mti, kipengele cha bahati nasibu kinachaguliwa na thamani ya kugawanya ya bahati nasibu inachaguliwa kati ya min na max ya kipengele hicho kwa data katika node hiyo. Kugawanya hii kunagawanya data katika matawi mawili. Mti unakua hadi kila pointi itengwe katika jani lake mwenyewe au urefu wa juu wa mti unafikiwa.

Ugunduzi wa anomalies unafanywa kwa kuangalia urefu wa njia ya kila pointi katika miti hii ya bahati nasibu – idadi ya kugawanya inayohitajika kutenga pointi hiyo. Kwa njia ya kawaida, anomalies (outliers) huwa zinatengwa haraka zaidi kwa sababu kugawanya kwa bahati nasibu kuna uwezekano mkubwa wa kutenganisha outlier (ambaye yuko katika eneo la sparse) kuliko pointi za kawaida katika kundi lenye msongamano. Isolation Forest inakadiria alama ya anomaly kutoka kwa urefu wa wastani wa njia juu ya miti zote: urefu wa njia ya wastani mfupi → zaidi ya anomalous. Alama kawaida huwekwa sawa kwa [0,1] ambapo 1 inamaanisha uwezekano mkubwa wa anomaly.

Dhana na Mipaka

Faida: Isolation Forest haitaji dhana ya usambazaji; inashughulikia moja kwa moja kutengwa. Ni bora kwenye data zenye vipimo vingi na seti kubwa za data (ugumu wa moja kwa moja $O(n\log n)$ kwa kujenga msitu) kwani kila mti unategemea pointi na vipengele na kugawanya tu. Inashughulikia vizuri vipengele vya nambari na inaweza kuwa haraka zaidi kuliko mbinu zinazotegemea umbali ambazo zinaweza kuwa $O(n^2)$. Pia inatoa moja kwa moja alama ya anomaly, hivyo unaweza kuweka kigezo cha tahadhari (au kutumia kipimo cha uchafuzi kuamua kiotomatiki kikomo kulingana na sehemu inayotarajiwa ya anomaly).

Mipaka: Kwa sababu ya asili yake ya bahati nasibu, matokeo yanaweza kutofautiana kidogo kati ya mbio (ingawa kwa miti nyingi hii ni ndogo). Ikiwa data ina vipengele vingi visivyo na maana au ikiwa anomalies hazitofautiani kwa nguvu katika kipengele chochote, kutengwa kunaweza kutokuwa na ufanisi (kugawanya kwa bahati nasibu kunaweza kutenga pointi za kawaida kwa bahati – hata hivyo, kuhesabu miti mingi hupunguza hili). Pia, Isolation Forest kwa ujumla inadhani kuwa anomalies ni wachache (ambayo mara nyingi ni kweli katika hali za usalama wa mtandao).

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