비지도 학습 알고리즘

Reading time: 27 minutes

비지도 학습

비지도 학습은 레이블이 없는 응답으로 데이터에 대해 모델을 훈련시키는 기계 학습의 한 유형입니다. 목표는 데이터 내에서 패턴, 구조 또는 관계를 찾는 것입니다. 레이블이 있는 예제에서 모델이 학습하는 감독 학습과 달리, 비지도 학습 알고리즘은 레이블이 없는 데이터로 작업합니다.
비지도 학습은 클러스터링, 차원 축소 및 이상 탐지와 같은 작업에 자주 사용됩니다. 데이터 내의 숨겨진 패턴을 발견하거나 유사한 항목을 그룹화하거나 데이터의 본질적인 특성을 유지하면서 복잡성을 줄이는 데 도움이 될 수 있습니다.

K-평균 클러스터링

K-평균은 각 점을 가장 가까운 클러스터 평균에 할당하여 데이터를 K개의 클러스터로 분할하는 중심 기반 클러스터링 알고리즘입니다. 알고리즘은 다음과 같이 작동합니다:

1. 초기화: K개의 초기 클러스터 중심(센트로이드)을 선택합니다. 보통 무작위로 또는 k-means++와 같은 더 스마트한 방법을 통해 선택합니다.
2. 할당: 거리 메트릭(예: 유클리드 거리)을 기반으로 각 데이터 포인트를 가장 가까운 센트로이드에 할당합니다.
3. 업데이트: 각 클러스터에 할당된 모든 데이터 포인트의 평균을 취하여 센트로이드를 재계산합니다.
4. 반복: 클러스터 할당이 안정화될 때까지(센트로이드가 더 이상 크게 이동하지 않음) 2-3단계를 반복합니다.

K 선택

클러스터 수(K)는 알고리즘을 실행하기 전에 정의해야 하는 하이퍼파라미터입니다. Elbow Method 또는 Silhouette Score와 같은 기술은 클러스터링 성능을 평가하여 K에 적절한 값을 결정하는 데 도움이 될 수 있습니다:

• Elbow Method: 각 점에서 할당된 클러스터 센트로이드까지의 제곱 거리의 합을 K의 함수로 플롯합니다. 감소율이 급격히 변화하는 "팔꿈치" 지점을 찾아 적절한 클러스터 수를 나타냅니다.
• Silhouette Score: 다양한 K 값에 대한 실루엣 점수를 계산합니다. 더 높은 실루엣 점수는 더 잘 정의된 클러스터를 나타냅니다.

가정 및 한계

K-평균은 클러스터가 구형이고 크기가 동일하다고 가정하며, 이는 모든 데이터셋에 대해 성립하지 않을 수 있습니다. 초기 센트로이드 배치에 민감하며 지역 최소값으로 수렴할 수 있습니다. 또한 K-평균은 밀도가 다르거나 비구형 모양의 데이터셋 및 서로 다른 스케일의 특성에는 적합하지 않습니다. 모든 특성이 거리 계산에 동일하게 기여하도록 보장하기 위해 정규화 또는 표준화와 같은 전처리 단계가 필요할 수 있습니다.

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

이 예제에서 K-Means는 4개의 클러스터를 찾아야 합니다. 비정상적으로 높은 지속 시간(~200)을 가진 작은 공격 클러스터는 정상 클러스터와의 거리로 인해 이상적으로 자체 클러스터를 형성할 것입니다. 우리는 결과를 해석하기 위해 클러스터 크기와 중심을 출력합니다. 실제 시나리오에서는 몇 개의 포인트로 클러스터에 잠재적 이상 징후로 레이블을 붙이거나 악의적인 활동을 위해 구성원을 검사할 수 있습니다.

계층적 클러스터링

계층적 클러스터링은 바닥에서 위로(응집적) 접근 방식 또는 위에서 아래로(분할적) 접근 방식을 사용하여 클러스터의 계층을 구축합니다:

1. 응집적 (Bottom-Up): 각 데이터 포인트를 별도의 클러스터로 시작하고 가장 가까운 클러스터를 반복적으로 병합하여 단일 클러스터가 남거나 중지 기준이 충족될 때까지 진행합니다.
2. 분할적 (Top-Down): 모든 데이터 포인트를 단일 클러스터로 시작하고 각 데이터 포인트가 자신의 클러스터가 되거나 중지 기준이 충족될 때까지 클러스터를 반복적으로 분할합니다.

응집적 클러스터링은 클러스터 간 거리 정의와 어떤 클러스터를 병합할지를 결정하는 연결 기준이 필요합니다. 일반적인 연결 방법에는 단일 연결(두 클러스터 간 가장 가까운 포인트의 거리), 완전 연결(가장 먼 포인트의 거리), 평균 연결 등이 있으며, 거리 측정은 종종 유클리드입니다. 연결의 선택은 생성된 클러스터의 형태에 영향을 미칩니다. 클러스터 수 K를 미리 지정할 필요는 없으며, 원하는 클러스터 수를 얻기 위해 선택한 수준에서 덴드로그램을 "컷"할 수 있습니다.

계층적 클러스터링은 덴드로그램을 생성하며, 이는 서로 다른 수준의 세분화에서 클러스터 간의 관계를 보여주는 나무와 같은 구조입니다. 덴드로그램은 특정 클러스터 수를 얻기 위해 원하는 수준에서 잘릴 수 있습니다.

가정 및 한계

계층적 클러스터링은 특정 클러스터 형태를 가정하지 않으며 중첩된 클러스터를 포착할 수 있습니다. 이는 그룹 간의 분류법이나 관계를 발견하는 데 유용합니다(예: 악성 코드를 패밀리 하위 그룹으로 그룹화). 이는 결정적이며(무작위 초기화 문제 없음) 주요 장점은 덴드로그램으로, 모든 규모에서 데이터의 클러스터링 구조에 대한 통찰력을 제공합니다 – 보안 분석가는 의미 있는 클러스터를 식별하기 위해 적절한 컷오프를 결정할 수 있습니다. 그러나 계산 비용이 많이 들며(일반적으로 단순 구현의 경우 $O(n^2)$ 시간 또는 그 이상) 매우 큰 데이터 세트에는 실현 가능하지 않습니다. 또한 이는 탐욕적 절차로, 병합이나 분할이 이루어진 후에는 되돌릴 수 없으며, 초기 실수로 인해 최적이 아닌 클러스터가 발생할 수 있습니다. 이상치는 일부 연결 전략(단일 연결이 이상치를 통해 클러스터를 연결하는 "체인" 효과를 유발할 수 있음)에 영향을 미칠 수 있습니다.

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 (밀도 기반 공간 클러스터링 알고리즘)

DBSCAN은 밀도 기반 클러스터링 알고리즘으로, 밀집된 점들을 함께 그룹화하고 저밀도 지역의 점들을 이상치로 표시합니다. 이는 다양한 밀도와 비구형 형태를 가진 데이터셋에 특히 유용합니다.

DBSCAN은 두 개의 매개변수를 정의하여 작동합니다:

• Epsilon (ε): 동일 클러스터의 일부로 간주될 두 점 사이의 최대 거리.
• MinPts: 밀집 지역(핵심 점)을 형성하는 데 필요한 최소 점 수.

DBSCAN은 핵심 점, 경계 점 및 노이즈 점을 식별합니다:

• 핵심 점: ε 거리 내에 최소 MinPts 이웃이 있는 점.
• 경계 점: 핵심 점의 ε 거리 내에 있지만 MinPts 이웃이 부족한 점.
• 노이즈 점: 핵심 점도 경계 점도 아닌 점.

클러스터링은 방문하지 않은 핵심 점을 선택하고 이를 새로운 클러스터로 표시한 다음, 그로부터 밀도에 도달 가능한 모든 점(핵심 점 및 그 이웃 등)을 재귀적으로 추가하는 방식으로 진행됩니다. 경계 점은 인근 핵심의 클러스터에 추가됩니다. 모든 도달 가능한 점을 확장한 후, DBSCAN은 다른 방문하지 않은 핵심으로 이동하여 새로운 클러스터를 시작합니다. 어떤 핵심에 의해서도 도달되지 않은 점은 노이즈로 남아 있습니다.

가정 및 한계

가정 및 강점: DBSCAN은 구형 클러스터를 가정하지 않습니다 – 임의의 형태의 클러스터(체인형 또는 인접 클러스터 등)를 찾을 수 있습니다. 데이터 밀도에 따라 클러스터 수를 자동으로 결정하며, 이상치를 노이즈로 효과적으로 식별할 수 있습니다. 이는 불규칙한 형태와 노이즈를 가진 실제 데이터에 강력합니다. 이상치에 대해 강건하며(K-Means와 달리 클러스터로 강제로 넣지 않음), 클러스터가 대략 균일한 밀도를 가질 때 잘 작동합니다.

한계: DBSCAN의 성능은 적절한 ε 및 MinPts 값을 선택하는 데 의존합니다. 밀도가 다양한 데이터에 대해 어려움을 겪을 수 있으며, 단일 ε는 밀집 클러스터와 희소 클러스터를 모두 수용할 수 없습니다. ε가 너무 작으면 대부분의 점을 노이즈로 레이블링하고, 너무 크면 클러스터가 잘못 병합될 수 있습니다. 또한, DBSCAN은 매우 큰 데이터셋에서 비효율적일 수 있으며(단순하게 $O(n^2)$, 공간 인덱싱이 도움이 될 수 있음), 고차원 특성 공간에서는 “ε 내 거리” 개념이 덜 의미 있게 될 수 있습니다(차원의 저주) 및 DBSCAN은 신중한 매개변수 조정이 필요하거나 직관적인 클러스터를 찾지 못할 수 있습니다. 그럼에도 불구하고 HDBSCAN과 같은 확장은 일부 문제(예: 밀도 변화)를 해결합니다.

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

주성분 분석 (PCA)

PCA는 데이터의 최대 분산을 포착하는 새로운 직교 축(주성분) 집합을 찾는 차원 축소 기법입니다. 간단히 말해, PCA는 데이터를 새로운 좌표계로 회전하고 투영하여 첫 번째 주성분(PC1)이 가능한 최대 분산을 설명하고, 두 번째 주성분(PC2)이 PC1에 수직인 최대 분산을 설명하도록 합니다. 수학적으로 PCA는 데이터의 공분산 행렬의 고유벡터를 계산합니다. 이 고유벡터는 주성분 방향이며, 해당 고유값은 각 고유벡터가 설명하는 분산의 양을 나타냅니다. PCA는 종종 특징 추출, 시각화 및 노이즈 감소에 사용됩니다.

이것은 데이터셋 차원에 상당한 선형 의존성 또는 상관관계가 포함된 경우 유용합니다.

PCA는 데이터의 주성분을 식별하여 최대 분산 방향을 찾습니다. PCA에 포함된 단계는 다음과 같습니다:

1. 표준화: 평균을 빼고 단위 분산으로 스케일링하여 데이터를 중심에 맞춥니다.
2. 공분산 행렬: 표준화된 데이터의 공분산 행렬을 계산하여 특징 간의 관계를 이해합니다.
3. 고유값 분해: 공분산 행렬에 대해 고유값 분해를 수행하여 고유값과 고유벡터를 얻습니다.
4. 주성분 선택: 고유값을 내림차순으로 정렬하고 가장 큰 고유값에 해당하는 상위 K개의 고유벡터를 선택합니다. 이 고유벡터는 새로운 특징 공간을 형성합니다.
5. 데이터 변환: 선택된 주성분을 사용하여 원본 데이터를 새로운 특징 공간에 투영합니다. PCA는 데이터 시각화, 노이즈 감소 및 다른 머신러닝 알고리즘의 전처리 단계로 널리 사용됩니다. 데이터의 차원을 줄이면서 본질적인 구조를 유지하는 데 도움이 됩니다.

고유값과 고유벡터

고유값은 해당 고유벡터가 포착하는 분산의 양을 나타내는 스칼라입니다. 고유벡터는 데이터가 가장 많이 변하는 방향을 나타냅니다.

A가 정방 행렬이고, v가 0이 아닌 벡터라고 가정합시다: A * v = λ * v 여기서:

• A는 [ [1, 2], [2, 1]]과 같은 정방 행렬입니다(예: 공분산 행렬)
• v는 고유벡터입니다(예: [1, 1])

그럼 A * v = [ [1, 2], [2, 1]] * [1, 1] = [3, 3]가 되어 고유값 λ는 고유벡터 v에 곱해져 λ = 3이 됩니다.

PCA에서의 고유값과 고유벡터

예를 들어 설명해 보겠습니다. 100x100 픽셀의 얼굴 그레이스케일 이미지가 많은 데이터셋이 있다고 가정해 보겠습니다. 각 픽셀은 특징으로 간주될 수 있으므로 이미지당 10,000개의 특징(또는 이미지당 10,000개의 구성 요소 벡터)이 있습니다. 이 데이터셋의 차원을 PCA를 사용하여 줄이려면 다음 단계를 따릅니다:

1. 표준화: 각 특징(픽셀)의 평균을 데이터셋에서 빼서 데이터를 중심에 맞춥니다.
2. 공분산 행렬: 표준화된 데이터의 공분산 행렬을 계산하여 특징(픽셀) 간의 변동성을 포착합니다.

• 두 변수(이 경우 픽셀) 간의 공분산은 함께 얼마나 변하는지를 나타내므로, 여기서의 아이디어는 어떤 픽셀이 선형 관계로 함께 증가하거나 감소하는지를 찾는 것입니다.
• 예를 들어, 픽셀 1과 픽셀 2가 함께 증가하는 경향이 있다면, 이들 간의 공분산은 양수가 될 것입니다.
• 공분산 행렬은 10,000x10,000 행렬이 되며, 각 항목은 두 픽셀 간의 공분산을 나타냅니다.

3. 고유값 방정식 해결: 해결해야 할 고유값 방정식은 C * v = λ * v이며, 여기서 C는 공분산 행렬, v는 고유벡터, λ는 고유값입니다. 다음과 같은 방법으로 해결할 수 있습니다:

• 고유값 분해: 공분산 행렬에 대해 고유값 분해를 수행하여 고유값과 고유벡터를 얻습니다.
• 특이값 분해 (SVD): 또는 SVD를 사용하여 데이터 행렬을 특이값과 벡터로 분해하여 주성분을 얻을 수 있습니다.

4. 주성분 선택: 고유값을 내림차순으로 정렬하고 가장 큰 고유값에 해당하는 상위 K개의 고유벡터를 선택합니다. 이 고유벡터는 데이터의 최대 분산 방향을 나타냅니다.

가정 및 한계

PCA는 분산의 주축이 의미가 있다고 가정합니다 – 이는 선형 방법이므로 데이터의 선형 상관관계를 포착합니다. PCA는 특징 공분산만 사용하므로 비지도 학습입니다. PCA의 장점에는 노이즈 감소(작은 분산 구성 요소는 종종 노이즈에 해당)와 특징의 비상관화가 포함됩니다. 이는 중간 정도의 높은 차원에 대해 계산적으로 효율적이며, 종종 다른 알고리즘의 전처리 단계로 유용합니다(차원의 저주를 완화하기 위해). 한계 중 하나는 PCA가 선형 관계에만 제한된다는 것입니다 – 복잡한 비선형 구조는 포착하지 못합니다(오토인코더나 t-SNE는 포착할 수 있습니다). 또한 PCA 구성 요소는 원래 특징 측면에서 해석하기 어려울 수 있습니다(원래 특징의 조합이기 때문입니다). 사이버 보안에서는 주의해야 합니다: 낮은 분산 특징에서 미세한 변화만 일으키는 공격은 상위 PC에서 나타나지 않을 수 있습니다(왜냐하면 PCA는 반드시 "흥미로움"이 아니라 분산을 우선시하기 때문입니다).

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)

가우시안 혼합 모델은 데이터가 알려지지 않은 매개변수를 가진 여러 가우시안(정상) 분포의 혼합에서 생성된다고 가정합니다. 본질적으로, 이는 확률적 클러스터링 모델입니다: 각 포인트를 K개의 가우시안 구성 요소 중 하나에 부드럽게 할당하려고 합니다. 각 가우시안 구성 요소 k는 평균 벡터(μ_k), 공분산 행렬(Σ_k), 그리고 해당 클러스터의 유병률을 나타내는 혼합 가중치(π_k)를 가집니다. K-평균과 달리 GMM은 각 포인트에 각 클러스터에 속할 확률을 부여합니다.

GMM 적합은 일반적으로 기대-최대화(EM) 알고리즘을 통해 수행됩니다:

• 초기화: 평균, 공분산 및 혼합 계수에 대한 초기 추정값으로 시작합니다(또는 K-평균 결과를 시작점으로 사용할 수 있습니다).

• E-단계(기대): 현재 매개변수를 고려하여 각 클러스터가 각 포인트에 대한 책임을 계산합니다: 본질적으로 r_nk = P(z_k | x_n) 여기서 z_k는 포인트 x_n에 대한 클러스터 소속을 나타내는 잠재 변수입니다. 이는 베이즈 정리를 사용하여 현재 매개변수를 기반으로 각 포인트가 각 클러스터에 속할 후행 확률을 계산합니다. 책임은 다음과 같이 계산됩니다:

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

여기서:

• ( \pi_k )는 클러스터 k에 대한 혼합 계수(클러스터 k의 사전 확률)입니다.

• ( \mathcal{N}(x_n | \mu_k, \Sigma_k) )는 평균 ( \mu_k )와 공분산 ( \Sigma_k )가 주어졌을 때 포인트 ( x_n )에 대한 가우시안 확률 밀도 함수입니다.

• M-단계(최대화): E-단계에서 계산된 책임을 사용하여 매개변수를 업데이트합니다:

• 각 평균 μ_k를 책임을 가중 평균으로 업데이트합니다.

• 클러스터 k에 할당된 포인트의 가중 공분산으로 각 공분산 Σ_k를 업데이트합니다.

• 클러스터 k에 대한 평균 책임으로 혼합 계수 π_k를 업데이트합니다.

• E 및 M 단계를 반복하여 수렴할 때까지(매개변수가 안정화되거나 우도 개선이 임계값 이하로 떨어질 때까지).

결과는 전체 데이터 분포를 집합적으로 모델링하는 가우시안 분포 집합입니다. 적합된 GMM을 사용하여 각 포인트를 가장 높은 확률을 가진 가우시안에 할당하여 클러스터링하거나 불확실성을 위해 확률을 유지할 수 있습니다. 새로운 포인트의 우도를 평가하여 모델에 적합한지 확인할 수도 있습니다(이상 탐지에 유용).

가정 및 한계

GMM은 공분산을 포함하는 K-평균의 일반화로, 클러스터가 타원형일 수 있습니다(구형에 국한되지 않음). 공분산이 완전할 경우 서로 다른 크기와 모양의 클러스터를 처리합니다. 클러스터 경계가 모호할 때 소프트 클러스터링은 장점이 있습니다 – 예를 들어, 사이버 보안에서 이벤트는 여러 공격 유형의 특성을 가질 수 있습니다; GMM은 확률로 그 불확실성을 반영할 수 있습니다. GMM은 또한 데이터의 확률 밀도 추정을 제공하여 이상치(모든 혼합 구성 요소 아래에서 낮은 우도를 가진 포인트)를 탐지하는 데 유용합니다.

단점으로는 GMM이 구성 요소 K의 수를 지정해야 한다는 점이 있습니다(그러나 BIC/AIC와 같은 기준을 사용하여 선택할 수 있습니다). EM은 때때로 느리게 수렴하거나 지역 최적점에 수렴할 수 있으므로 초기화가 중요합니다(종종 EM을 여러 번 실행합니다). 데이터가 실제로 가우시안의 혼합을 따르지 않는 경우 모델이 잘 맞지 않을 수 있습니다. 하나의 가우시안이 단지 이상치를 덮기 위해 축소되는 위험도 있으며(정규화 또는 최소 공분산 경계로 완화할 수 있음).

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