Algorytmy Uczenia Nadzorowanego

Reading time: 30 minutes

Uczenie Nadzorowane

Uczenie nadzorowane to rodzaj uczenia maszynowego, w którym model jest trenowany na danych bez oznaczonych odpowiedzi. Celem jest znalezienie wzorców, struktur lub relacji w danych. W przeciwieństwie do uczenia nadzorowanego, gdzie model uczy się na podstawie oznaczonych przykładów, algorytmy uczenia nienadzorowanego pracują z danymi nieoznaczonymi. Uczenie nienadzorowane jest często wykorzystywane do zadań takich jak klasteryzacja, redukcja wymiarów i wykrywanie anomalii. Może pomóc w odkrywaniu ukrytych wzorców w danych, grupowaniu podobnych elementów lub redukcji złożoności danych przy jednoczesnym zachowaniu ich istotnych cech.

Klasteryzacja K-Średnich

K-Średnich to algorytm klasteryzacji oparty na centroidach, który dzieli dane na K klastrów, przypisując każdy punkt do najbliższego średniego klastra. Algorytm działa w następujący sposób:

1. Inicjalizacja: Wybierz K początkowych centrów klastrów (centroidów), często losowo lub za pomocą inteligentniejszych metod, takich jak k-średnich++.
2. Przypisanie: Przypisz każdy punkt danych do najbliższego centroidu na podstawie metryki odległości (np. odległość euklidesowa).
3. Aktualizacja: Przelicz centroidy, biorąc średnią ze wszystkich punktów danych przypisanych do każdego klastra.
4. Powtórz: Kroki 2–3 są powtarzane, aż przypisania klastrów się ustabilizują (centroidy przestają się znacząco poruszać).

Wybór K

Liczba klastrów (K) jest hiperparametrem, który należy zdefiniować przed uruchomieniem algorytmu. Techniki takie jak Metoda Łokcia lub Wskaźnik Silhouette mogą pomóc w określeniu odpowiedniej wartości dla K, oceniając wydajność klasteryzacji:

• Metoda Łokcia: Narysuj sumę kwadratów odległości od każdego punktu do przypisanego centroidu klastra w funkcji K. Szukaj punktu "łokcia", w którym tempo spadku gwałtownie się zmienia, co wskazuje na odpowiednią liczbę klastrów.
• Wskaźnik Silhouette: Oblicz wskaźnik silhouette dla różnych wartości K. Wyższy wskaźnik silhouette wskazuje na lepiej zdefiniowane klastry.

Założenia i Ograniczenia

K-Średnich zakłada, że klastry są sferyczne i równo wymiarowe, co może nie być prawdą dla wszystkich zestawów danych. Jest wrażliwy na początkowe umiejscowienie centroidów i może zbiegać do lokalnych minimów. Dodatkowo, K-Średnich nie jest odpowiedni dla zestawów danych o zmiennej gęstości lub nienałogowych kształtach oraz cechach o różnych skalach. Kroki wstępne, takie jak normalizacja lub standaryzacja, mogą być konieczne, aby zapewnić, że wszystkie cechy przyczyniają się równo do obliczeń odległości.

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

Klasteryzacja Hierarchiczna

Klasteryzacja hierarchiczna buduje hierarchię klastrów, używając podejścia od dołu do góry (agglomeratywnego) lub od góry do dołu (dzielącego):

1. Agglomeratywne (Od Dołu do Góry): Rozpocznij od każdego punktu danych jako osobnego klastra i iteracyjnie łącz najbliższe klastry, aż pozostanie jeden klaster lub zostanie spełniony kryterium zatrzymania.
2. Dzielące (Od Góry do Dołu): Rozpocznij od wszystkich punktów danych w jednym klastrze i iteracyjnie dziel klastry, aż każdy punkt danych stanie się swoim własnym klastrem lub zostanie spełniony kryterium zatrzymania.

Klasteryzacja agglomeratywna wymaga zdefiniowania odległości między klastrami oraz kryterium łączenia, aby zdecydować, które klastry połączyć. Powszechne metody łączenia obejmują pojedyncze łączenie (odległość najbliższych punktów między dwoma klastrami), pełne łączenie (odległość najdalszych punktów), średnie łączenie itp., a metryka odległości często jest euklidesowa. Wybór metody łączenia wpływa na kształt produkowanych klastrów. Nie ma potrzeby wstępnego określania liczby klastrów K; można "przeciąć" dendrogram na wybranym poziomie, aby uzyskać pożądaną liczbę klastrów.

Klasteryzacja hierarchiczna produkuje dendrogram, strukturę przypominającą drzewo, która pokazuje relacje między klastrami na różnych poziomach szczegółowości. Dendrogram można przeciąć na pożądanym poziomie, aby uzyskać określoną liczbę klastrów.

Założenia i Ograniczenia

Klasteryzacja hierarchiczna nie zakłada określonego kształtu klastra i może uchwycić zagnieżdżone klastry. Jest przydatna do odkrywania taksonomii lub relacji między grupami (np. grupowanie złośliwego oprogramowania według podgrup rodzinnych). Jest deterministyczna (brak problemów z losową inicjalizacją). Kluczową zaletą jest dendrogram, który dostarcza wglądu w strukturę klasteryzacji danych na wszystkich poziomach – analitycy bezpieczeństwa mogą zdecydować o odpowiednim poziomie odcięcia, aby zidentyfikować znaczące klastry. Jednak jest to kosztowne obliczeniowo (zwykle czas $O(n^2)$ lub gorszy dla naiwnej implementacji) i niepraktyczne dla bardzo dużych zbiorów danych. Jest to również procedura zachłanna – po wykonaniu połączenia lub podziału nie można tego cofnąć, co może prowadzić do suboptymalnych klastrów, jeśli błąd wystąpi wcześnie. Odkrywcy mogą również wpływać na niektóre strategie łączenia (pojedyncze łączenie może powodować efekt "łańcuchowania", gdzie klastry łączą się przez odkrywców).

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ęstościowe Grupowanie Przestrzenne Aplikacji z Szumem)

DBSCAN to algorytm grupowania oparty na gęstości, który łączy punkty blisko siebie, jednocześnie oznaczając punkty w obszarach o niskiej gęstości jako odstające. Jest szczególnie przydatny dla zbiorów danych o zmiennej gęstości i nienawykłych kształtach.

DBSCAN działa, definiując dwa parametry:

• Epsilon (ε): Maksymalna odległość między dwoma punktami, aby mogły być uznane za część tej samej grupy.
• MinPts: Minimalna liczba punktów wymagana do utworzenia gęstego obszaru (punkt rdzeniowy).

DBSCAN identyfikuje punkty rdzeniowe, punkty brzegowe i punkty szumowe:

• Punkt Rdzeniowy: Punkt z co najmniej MinPts sąsiadami w odległości ε.
• Punkt Brzegowy: Punkt, który znajduje się w odległości ε od punktu rdzeniowego, ale ma mniej niż MinPts sąsiadów.
• Punkt Szumowy: Punkt, który nie jest ani punktem rdzeniowym, ani punktem brzegowym.

Grupowanie odbywa się poprzez wybranie nieodwiedzonego punktu rdzeniowego, oznaczenie go jako nową grupę, a następnie rekurencyjne dodawanie wszystkich punktów osiągalnych gęstościowo z niego (punkty rdzeniowe i ich sąsiedzi itp.). Punkty brzegowe są dodawane do grupy pobliskiego punktu rdzeniowego. Po rozszerzeniu wszystkich osiągalnych punktów, DBSCAN przechodzi do innego nieodwiedzonego punktu rdzeniowego, aby rozpocząć nową grupę. Punkty, które nie zostały osiągnięte przez żaden punkt rdzeniowy, pozostają oznaczone jako szum.

Założenia i Ograniczenia

Założenia i Mocne Strony: DBSCAN nie zakłada sferycznych grup – może znajdować grupy o dowolnych kształtach (nawet łańcuchowych lub sąsiadujących). Automatycznie określa liczbę grup na podstawie gęstości danych i skutecznie identyfikuje odstające jako szum. To czyni go potężnym narzędziem dla danych rzeczywistych o nieregularnych kształtach i szumie. Jest odporny na odstające (w przeciwieństwie do K-Means, który zmusza je do grup). Działa dobrze, gdy grupy mają mniej więcej jednolitą gęstość.

Ograniczenia: Wydajność DBSCAN zależy od wyboru odpowiednich wartości ε i MinPts. Może mieć trudności z danymi o zmiennej gęstości – pojedyncze ε nie może pomieścić zarówno gęstych, jak i rzadkich grup. Jeśli ε jest zbyt małe, oznacza większość punktów jako szum; zbyt duże, a grupy mogą się niepoprawnie łączyć. Ponadto, DBSCAN może być nieefektywny na bardzo dużych zbiorach danych (naiwnie $O(n^2)$, chociaż indeksowanie przestrzenne może pomóc). W przestrzeniach cech o wysokiej wymiarowości pojęcie „odległości w ε” może stać się mniej znaczące (klątwa wymiarowości), a DBSCAN może wymagać starannego dostrajania parametrów lub może nie znaleźć intuicyjnych grup. Mimo to, rozszerzenia takie jak HDBSCAN rozwiązują niektóre problemy (jak zmienna gęstość).

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 Głównych Składników (PCA)

PCA to technika redukcji wymiarowości, która znajduje nowy zestaw ortogonalnych osi (głównych składników), które uchwycają maksymalną wariancję w danych. Mówiąc prosto, PCA obraca i projektuje dane na nowy układ współrzędnych, tak aby pierwszy główny składnik (PC1) wyjaśniał największą możliwą wariancję, drugi PC (PC2) wyjaśniał największą wariancję ortogonalną do PC1, i tak dalej. Matematycznie, PCA oblicza wektory własne macierzy kowariancji danych – te wektory własne to kierunki głównych składników, a odpowiadające im wartości własne wskazują ilość wariancji wyjaśnianej przez każdy z nich. Często jest używane do ekstrakcji cech, wizualizacji i redukcji szumów.

Należy zauważyć, że jest to przydatne, jeśli wymiary zbioru danych zawierają znaczące zależności liniowe lub korelacje.

PCA działa poprzez identyfikację głównych składników danych, którymi są kierunki maksymalnej wariancji. Kroki zaangażowane w PCA to:

1. Standaryzacja: Wyśrodkowanie danych poprzez odjęcie średniej i skalowanie do jednostkowej wariancji.
2. Macierz Kowariancji: Obliczenie macierzy kowariancji standaryzowanych danych, aby zrozumieć relacje między cechami.
3. Rozkład Wartości Własnych: Wykonanie rozkładu wartości własnych na macierzy kowariancji, aby uzyskać wartości własne i wektory własne.
4. Wybór Głównych Składników: Posortowanie wartości własnych w porządku malejącym i wybranie najlepszych K wektorów własnych odpowiadających największym wartościom własnym. Te wektory własne tworzą nową przestrzeń cech.
5. Transformacja Danych: Projekcja oryginalnych danych na nową przestrzeń cech przy użyciu wybranych głównych składników. PCA jest szeroko stosowane do wizualizacji danych, redukcji szumów i jako krok wstępny dla innych algorytmów uczenia maszynowego. Pomaga zmniejszyć wymiarowość danych, zachowując ich istotną strukturę.

Wartości Własne i Wektory Własne

Wartość własna to skalar, który wskazuje ilość wariancji uchwyconej przez odpowiadający jej wektor własny. Wektor własny reprezentuje kierunek w przestrzeni cech, wzdłuż którego dane zmieniają się najbardziej.

Wyobraź sobie, że A jest macierzą kwadratową, a v jest wektorem różnym od zera, tak że: A * v = λ * v gdzie:

• A to macierz kwadratowa, jak [ [1, 2], [2, 1]] (np. macierz kowariancji)
• v to wektor własny (np. [1, 1])

Wtedy A * v = [ [1, 2], [2, 1]] * [1, 1] = [3, 3], co będzie wartością własną λ pomnożoną przez wektor własny v, co daje wartość własną λ = 3.

Wartości Własne i Wektory Własne w PCA

Wyjaśnijmy to na przykładzie. Wyobraź sobie, że masz zbiór danych z wieloma szaro-skalowymi zdjęciami twarzy o rozmiarze 100x100 pikseli. Każdy piksel można uznać za cechę, więc masz 10 000 cech na obraz (lub wektor 10000 komponentów na obraz). Jeśli chcesz zmniejszyć wymiarowość tego zbioru danych za pomocą PCA, powinieneś postępować zgodnie z tymi krokami:

1. Standaryzacja: Wyśrodkowanie danych poprzez odjęcie średniej każdej cechy (piksela) od zbioru danych.
2. Macierz Kowariancji: Obliczenie macierzy kowariancji standaryzowanych danych, która uchwyca, jak cechy (piksele) zmieniają się razem.

• Należy zauważyć, że kowariancja między dwiema zmiennymi (pikselami w tym przypadku) wskazuje, jak bardzo zmieniają się razem, więc pomysł polega na odkryciu, które piksele mają tendencję do wzrostu lub spadku razem w relacji liniowej.
• Na przykład, jeśli piksel 1 i piksel 2 mają tendencję do wzrostu razem, kowariancja między nimi będzie dodatnia.
• Macierz kowariancji będzie macierzą 10 000x10 000, gdzie każdy wpis reprezentuje kowariancję między dwoma pikselami.

3. Rozwiąż równanie wartości własnych: Równanie wartości własnych do rozwiązania to C * v = λ * v, gdzie C to macierz kowariancji, v to wektor własny, a λ to wartość własna. Można je rozwiązać za pomocą metod takich jak:

• Rozkład Wartości Własnych: Wykonanie rozkładu wartości własnych na macierzy kowariancji, aby uzyskać wartości własne i wektory własne.
• Rozkład Wartości Singularnych (SVD): Alternatywnie, można użyć SVD do rozkładu macierzy danych na wartości i wektory singularne, co również może dać główne składniki.

4. Wybór Głównych Składników: Posortowanie wartości własnych w porządku malejącym i wybranie najlepszych K wektorów własnych odpowiadających największym wartościom własnym. Te wektory własne reprezentują kierunki maksymalnej wariancji w danych.

Założenia i Ograniczenia

PCA zakłada, że główne osie wariancji są znaczące – jest to metoda liniowa, więc uchwyca liniowe korelacje w danych. Jest nienadzorowana, ponieważ wykorzystuje tylko kowariancję cech. Zalety PCA obejmują redukcję szumów (komponenty o małej wariancji często odpowiadają szumowi) i dekorelację cech. Jest obliczeniowo wydajne dla umiarkowanie wysokich wymiarów i często jest używane jako krok wstępny dla innych algorytmów (aby złagodzić przekleństwo wymiarowości). Jednym z ograniczeń jest to, że PCA jest ograniczone do relacji liniowych – nie uchwyci złożonej nieliniowej struktury (podczas gdy autoenkodery lub t-SNE mogą). Ponadto komponenty PCA mogą być trudne do interpretacji w kontekście oryginalnych cech (są kombinacjami oryginalnych cech). W cyberbezpieczeństwie należy być ostrożnym: atak, który powoduje tylko subtelną zmianę w cechach o niskiej wariancji, może nie pojawić się w głównych komponentach (ponieważ PCA priorytetowo traktuje wariancję, a niekoniecznie „interesującość”).

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

Modele Mieszanek Gaussowskich (GMM)

Model Mieszanek Gaussowskich zakłada, że dane są generowane z mieszanki kilku rozkładów Gaussowskich (normalnych) o nieznanych parametrach. W istocie jest to probabilistyczny model klastrowania: stara się łagodnie przypisać każdy punkt do jednego z K komponentów Gaussowskich. Każdy komponent Gaussowski k ma wektor średni (μ_k), macierz kowariancji (Σ_k) oraz wagę mieszania (π_k), która reprezentuje, jak powszechny jest ten klaster. W przeciwieństwie do K-Means, który dokonuje "twardych" przypisań, GMM nadaje każdemu punktowi prawdopodobieństwo przynależności do każdego klastra.

Dopasowanie GMM zazwyczaj odbywa się za pomocą algorytmu Oczekiwania-Maksymalizacji (EM):

• Inicjalizacja: Rozpocznij od początkowych oszacowań dla średnich, kowariancji i współczynników mieszania (lub użyj wyników K-Means jako punktu wyjścia).

• E-krok (Oczekiwanie): Mając obecne parametry, oblicz odpowiedzialność każdego klastra dla każdego punktu: zasadniczo r_nk = P(z_k | x_n), gdzie z_k to zmienna utajona wskazująca przynależność do klastra dla punktu x_n. To jest robione przy użyciu twierdzenia Bayesa, gdzie obliczamy prawdopodobieństwo a posteriori każdego punktu przynależności do każdego klastra na podstawie obecnych parametrów. Odpowiedzialności oblicza się jako:

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

gdzie:

• ( \pi_k ) to współczynnik mieszania dla klastra k (prawdopodobieństwo a priori klastra k),

• ( \mathcal{N}(x_n | \mu_k, \Sigma_k) ) to funkcja gęstości prawdopodobieństwa Gaussa dla punktu ( x_n ) przy danej średniej ( \mu_k ) i kowariancji ( \Sigma_k ).

• M-krok (Maksymalizacja): Zaktualizuj parametry, używając odpowiedzialności obliczonych w kroku E:

• Zaktualizuj każdą średnią μ_k jako ważoną średnią punktów, gdzie wagi to odpowiedzialności.

• Zaktualizuj każdą kowariancję Σ_k jako ważoną kowariancję punktów przypisanych do klastra k.

• Zaktualizuj współczynniki mieszania π_k jako średnią odpowiedzialność dla klastra k.

• Iteruj kroki E i M, aż do zbieżności (parametry stabilizują się lub poprawa prawdopodobieństwa jest poniżej progu).

Wynikiem jest zestaw rozkładów Gaussowskich, które wspólnie modelują ogólny rozkład danych. Możemy użyć dopasowanego GMM do klastrowania, przypisując każdy punkt do Gaussa o najwyższym prawdopodobieństwie, lub zachować prawdopodobieństwa dla niepewności. Można również ocenić prawdopodobieństwo nowych punktów, aby sprawdzić, czy pasują do modelu (przydatne w wykrywaniu anomalii).

Założenia i ograniczenia

GMM jest uogólnieniem K-Means, które uwzględnia kowariancję, dzięki czemu klastry mogą być elipsoidalne (nie tylko sferyczne). Radzi sobie z klastrami o różnych rozmiarach i kształtach, jeśli kowariancja jest pełna. Miękkie klastrowanie jest zaletą, gdy granice klastrów są nieostre – np. w cyberbezpieczeństwie zdarzenie może mieć cechy wielu typów ataków; GMM może odzwierciedlać tę niepewność za pomocą prawdopodobieństw. GMM dostarcza również probabilistycznej estymacji gęstości danych, co jest przydatne do wykrywania wartości odstających (punktów o niskim prawdopodobieństwie w ramach wszystkich komponentów mieszanki).

Z drugiej strony, GMM wymaga określenia liczby komponentów K (choć można użyć kryteriów takich jak BIC/AIC do jej wyboru). EM czasami może zbiegać się wolno lub do lokalnego optimum, więc inicjalizacja jest ważna (często uruchamia się EM wiele razy). Jeśli dane w rzeczywistości nie podążają za mieszanką Gaussów, model może być słabo dopasowany. Istnieje również ryzyko, że jeden Gauss skurczy się, aby pokryć tylko wartość odstającą (choć regularizacja lub minimalne ograniczenia kowariancji mogą to złagodzić).

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