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. Агломеративний (Знизу-вгору): Починаємо з кожної точки даних як окремого кластера і ітеративно об'єднуємо найближчі кластери, поки не залишиться один кластер або не буде досягнуто критерію зупинки.
2. Дискретний (Зверху-вниз): Починаємо з усіх точок даних в одному кластері і ітеративно розділяємо кластери, поки кожна точка даних не стане своїм власним кластером або не буде досягнуто критерію зупинки.

Агломеративна кластеризація вимагає визначення відстані між кластерами та критерію зв'язку для вирішення, які кластери об'єднувати. Загальні методи зв'язку включають одиничний зв'язок (відстань найближчих точок між двома кластерами), повний зв'язок (відстань найвіддаленіших точок), середній зв'язок тощо, а метрика відстані часто є евклідичною. Вибір зв'язку впливає на форму отриманих кластерів. Немає необхідності заздалегідь визначати кількість кластерів 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 (Density-Based Spatial Clustering of Applications with Noise)

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) пояснює найбільшу можливу дисперсію, друга PC (PC2) пояснює найбільшу дисперсію, ортогональну до PC1, і так далі. Математично PCA обчислює власні вектори матриці коваріації даних – ці власні вектори є напрямками головних компонент, а відповідні власні значення вказують на кількість дисперсії, поясненої кожним. Це часто використовується для видобутку ознак, візуалізації та зменшення шуму.

Зверніть увагу, що це корисно, якщо розміри набору даних містять значні лінійні залежності або кореляції.

PCA працює, визначаючи головні компоненти даних, які є напрямками максимальної дисперсії. Кроки, що входять до PCA, такі:

1. Стандартизація: Центруйте дані, віднімаючи середнє та масштабируючи до одиничної дисперсії.
2. Матриця коваріації: Обчисліть матрицю коваріації стандартизованих даних, щоб зрозуміти взаємозв'язки між ознаками.
3. Декомпозиція власних значень: Виконайте декомпозицію власних значень на матриці коваріації, щоб отримати власні значення та власні вектори.
4. Вибір головних компонент: Відсортуйте власні значення у спадному порядку та виберіть верхні K власних векторів, що відповідають найбільшим власним значенням. Ці власні вектори формують новий простір ознак.
5. Перетворення даних: Проєктуйте оригінальні дані на новий простір ознак, використовуючи вибрані головні компоненти. PCA широко використовується для візуалізації даних, зменшення шуму та як етап попередньої обробки для інших алгоритмів машинного навчання. Це допомагає зменшити розмірність даних, зберігаючи їх основну структуру.

Власні значення та власні вектори

Власне значення - це скаляр, який вказує на кількість дисперсії, захопленої його відповідним власним вектором. Власний вектор представляє напрямок у просторі ознак, уздовж якого дані змінюються найбільше.

Уявіть, що A - це квадратна матриця, а v - ненульовий вектор, такий що: 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 ознак на зображення (або вектор з 10000 компонент на зображення). Якщо ви хочете зменшити розмірність цього набору даних за допомогою PCA, ви повинні виконати такі кроки:

1. Стандартизація: Центруйте дані, віднімаючи середнє значення кожної ознаки (пікселя) з набору даних.
2. Матриця коваріації: Обчисліть матрицю коваріації стандартизованих даних, яка захоплює, як ознаки (пікселі) змінюються разом.

• Зверніть увагу, що коваріація між двома змінними (пікселями в даному випадку) вказує на те, наскільки вони змінюються разом, тому ідея полягає в тому, щоб з'ясувати, які пікселі, як правило, збільшуються або зменшуються разом з лінійною залежністю.
• Наприклад, якщо піксель 1 і піксель 2, як правило, збільшуються разом, коваріація між ними буде позитивною.
• Матриця коваріації буде матрицею 10,000x10,000, де кожен елемент представляє коваріацію між двома пікселями.

3. Розв'язання рівняння власних значень: Рівняння власних значень, яке потрібно розв'язати, є C * v = λ * v, де C - матриця коваріації, v - власний вектор, а λ - власне значення. Його можна розв'язати за допомогою методів, таких як:

• Декомпозиція власних значень: Виконайте декомпозицію власних значень на матриці коваріації, щоб отримати власні значення та власні вектори.
• Сингулярна декомпозиція (SVD): Альтернативно, ви можете використовувати SVD для розкладання матриці даних на сингулярні значення та вектори, що також може дати головні компоненти.

4. Вибір головних компонент: Відсортуйте власні значення у спадному порядку та виберіть верхні K власних векторів, що відповідають найбільшим власним значенням. Ці власні вектори представляють напрямки максимальної дисперсії в даних.

Припущення та обмеження

PCA припускає, що головні осі дисперсії є значущими – це лінійний метод, тому він захоплює лінійні кореляції в даних. Це некероване навчання, оскільки воно використовує лише коваріацію ознак. Переваги PCA включають зменшення шуму (компоненти з малою дисперсією часто відповідають шуму) та декореляцію ознак. Це обчислювально ефективно для помірно високих розмірностей і часто є корисним етапом попередньої обробки для інших алгоритмів (щоб пом'якшити прокляття розмірності). Одне з обмежень полягає в тому, що PCA обмежена лінійними зв'язками – вона не захоплює складну нелінійну структуру (тоді як автоенкодери або t-SNE можуть). Крім того, компоненти PCA можуть бути важкими для інтерпретації з точки зору оригінальних ознак (вони є комбінаціями оригінальних ознак). У кібербезпеці потрібно бути обережним: атака, яка викликає лише незначну зміну в ознаці з низькою дисперсією, може не з'явитися в верхніх ПК (оскільки 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-Means, який робить "жорсткі" призначення, GMM надає кожній точці ймовірність належності до кожного кластера.

Підгонка GMM зазвичай виконується за допомогою алгоритму очікування-максимізації (EM):

• Ініціалізація: Почати з початкових припущень для середніх, коваріацій та коефіцієнтів змішування (або використовувати результати K-Means як початкову точку).

• 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) ) є функцією ймовірності Гаусса для точки ( x_n ) з урахуванням середнього ( \mu_k ) та коваріації ( \Sigma_k ).

• M-крок (Максимізація): Оновити параметри, використовуючи відповідальності, обчислені в E-кроці:

• Оновити кожне середнє μ_k як зважене середнє точок, де ваги є відповідальностями.

• Оновити кожну коваріацію Σ_k як зважену коваріацію точок, призначених кластеру k.

• Оновити коефіцієнти змішування π_k як середню відповідальність для кластера k.

• Ітерація E та M кроків до збіжності (параметри стабілізуються або поліпшення ймовірності нижче порогу).

Результатом є набір Гауссових розподілів, які колективно моделюють загальний розподіл даних. Ми можемо використовувати підганяний GMM для кластеризації, призначаючи кожну точку Гауссу з найвищою ймовірністю, або зберігати ймовірності для невизначеності. Також можна оцінити ймовірність нових точок, щоб перевірити, чи підходять вони до моделі (корисно для виявлення аномалій).

Припущення та обмеження

GMM є узагальненням K-Means, яке включає коваріацію, тому кластери можуть бути еліпсоїдними (не лише сферичними). Воно обробляє кластери різних розмірів і форм, якщо коваріація повна. М'яка кластеризація є перевагою, коли межі кластерів є нечіткими – наприклад, у кібербезпеці подія може мати риси кількох типів атак; 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()