Ми використаємо Набір даних фішингових веб-сайтів (з репозиторію UCI), який містить витягнуті ознаки веб-сайтів (наприклад, чи має URL IP-адресу, вік домену, наявність підозрілих елементів у HTML тощо) та мітку, що вказує, чи є сайт фішинговим або легітимним. Ми навчаємо модель логістичної регресії для класифікації веб-сайтів, а потім оцінюємо її точність, точність, відгук, F1-оцінку та ROC AUC на тестовій вибірці.

import pandas as pd
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

# 1. Load dataset
data = fetch_openml(data_id=4534, as_frame=True)  # PhishingWebsites
df   = data.frame
print(df.head())

# 2. Target mapping ─ legitimate (1) → 0, everything else → 1
df['Result'] = df['Result'].astype(int)
y = (df['Result'] != 1).astype(int)

# 3. Features
X = df.drop(columns=['Result'])

# 4. Train/test split with stratify
## Stratify ensures balanced classes in train/test sets
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, random_state=42, stratify=y)

# 5. Scale
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test  = scaler.transform(X_test)

# 6. Logistic Regression
## L‑BFGS is a modern, memory‑efficient “quasi‑Newton” algorithm that works well for medium/large datasets and supports multiclass natively.
## Upper bound on how many optimization steps the solver may take before it gives up.	Not all steps are guaranteed to be taken, but would be the maximum before a "failed to converge" error.
clf = LogisticRegression(max_iter=1000, solver='lbfgs', random_state=42)
clf.fit(X_train, y_train)

# 7. Evaluation
y_pred = clf.predict(X_test)
y_prob = clf.predict_proba(X_test)[:, 1]

print(f"Accuracy : {accuracy_score(y_test, y_pred):.3f}")
print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall   : {recall_score(y_test, y_pred):.3f}")
print(f"F1-score : {f1_score(y_test, y_pred):.3f}")
print(f"ROC AUC  : {roc_auc_score(y_test, y_prob):.3f}")

"""
Accuracy : 0.928
Precision: 0.934
Recall   : 0.901
F1-score : 0.917
ROC AUC  : 0.979
"""

У цьому прикладі виявлення фішингу логістична регресія генерує ймовірність для кожного веб-сайту бути фішинговим. Оцінюючи точність, точність (precision), відзив (recall) та F1, ми отримуємо уявлення про продуктивність моделі. Наприклад, високий відзив означає, що вона виявляє більшість фішингових сайтів (важливо для безпеки, щоб мінімізувати пропущені атаки), тоді як висока точність означає, що має мало хибних спрацьовувань (важливо, щоб уникнути втоми аналітиків). ROC AUC (Площа під кривою ROC) надає незалежну від порогу міру продуктивності (1.0 є ідеальним, 0.5 не краще, ніж випадковість). Логістична регресія часто добре справляється з такими завданнями, але якщо межа прийняття рішень між фішинговими та легітимними сайтами є складною, можуть знадобитися більш потужні нелінійні моделі.

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

# 1️⃣  NSL‑KDD column names (41 features + class + difficulty)
col_names = [
"duration","protocol_type","service","flag","src_bytes","dst_bytes","land",
"wrong_fragment","urgent","hot","num_failed_logins","logged_in","num_compromised",
"root_shell","su_attempted","num_root","num_file_creations","num_shells",
"num_access_files","num_outbound_cmds","is_host_login","is_guest_login","count",
"srv_count","serror_rate","srv_serror_rate","rerror_rate","srv_rerror_rate",
"same_srv_rate","diff_srv_rate","srv_diff_host_rate","dst_host_count",
"dst_host_srv_count","dst_host_same_srv_rate","dst_host_diff_srv_rate",
"dst_host_same_src_port_rate","dst_host_srv_diff_host_rate","dst_host_serror_rate",
"dst_host_srv_serror_rate","dst_host_rerror_rate","dst_host_srv_rerror_rate",
"class","difficulty_level"
]

# 2️⃣  Load data ➜ *headerless* CSV
train_url = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Train.csv"
test_url  = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Test.csv"

df_train = pd.read_csv(train_url, header=None, names=col_names)
df_test  = pd.read_csv(test_url,  header=None, names=col_names)

# 3️⃣  Encode the 3 nominal features
for col in ['protocol_type', 'service', 'flag']:
le = LabelEncoder().fit(pd.concat([df_train[col], df_test[col]]))
df_train[col] = le.transform(df_train[col])
df_test[col]  = le.transform(df_test[col])

# 4️⃣  Prepare X / y   (binary: 0 = normal, 1 = attack)
X_train = df_train.drop(columns=['class', 'difficulty_level'])
y_train = (df_train['class'].str.lower() != 'normal').astype(int)

X_test  = df_test.drop(columns=['class', 'difficulty_level'])
y_test  = (df_test['class'].str.lower() != 'normal').astype(int)

# 5️⃣  Train Decision‑Tree
clf = DecisionTreeClassifier(max_depth=10, random_state=42)
clf.fit(X_train, y_train)

# 6️⃣  Evaluate
y_pred = clf.predict(X_test)
y_prob = clf.predict_proba(X_test)[:, 1]

print(f"Accuracy : {accuracy_score(y_test, y_pred):.3f}")
print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall   : {recall_score(y_test, y_pred):.3f}")
print(f"F1‑score : {f1_score(y_test, y_pred):.3f}")
print(f"ROC AUC  : {roc_auc_score(y_test, y_prob):.3f}")


"""
Accuracy : 0.772
Precision: 0.967
Recall   : 0.621
F1‑score : 0.756
ROC AUC  : 0.758
"""

У цьому прикладі дерева рішень ми обмежили глибину дерева до 10, щоб уникнути екстремального перенавчання (параметр max_depth=10). Метрики показують, наскільки добре дерево розрізняє нормальний та атакуючий трафік. Високий відгук означає, що воно ловить більшість атак (важливо для IDS), тоді як висока точність означає, що мало хибних тривог. Дерева рішень часто досягають пристойної точності на структурованих даних, але одне дерево може не досягти найкращої можливої продуктивності. Тим не менш, інтерпретованість моделі є великою перевагою — ми могли б дослідити розподіли дерева, щоб побачити, наприклад, які ознаки (наприклад, service, src_bytes тощо) є найвпливовішими для позначення з'єднання як шкідливого.

import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (accuracy_score, precision_score,
recall_score, f1_score, roc_auc_score)

# ──────────────────────────────────────────────
# 1. LOAD DATA  ➜  files have **no header row**, so we
#                 pass `header=None` and give our own column names.
# ──────────────────────────────────────────────
col_names = [                       # 41 features + 2 targets
"duration","protocol_type","service","flag","src_bytes","dst_bytes","land",
"wrong_fragment","urgent","hot","num_failed_logins","logged_in",
"num_compromised","root_shell","su_attempted","num_root","num_file_creations",
"num_shells","num_access_files","num_outbound_cmds","is_host_login",
"is_guest_login","count","srv_count","serror_rate","srv_serror_rate",
"rerror_rate","srv_rerror_rate","same_srv_rate","diff_srv_rate",
"srv_diff_host_rate","dst_host_count","dst_host_srv_count",
"dst_host_same_srv_rate","dst_host_diff_srv_rate",
"dst_host_same_src_port_rate","dst_host_srv_diff_host_rate",
"dst_host_serror_rate","dst_host_srv_serror_rate","dst_host_rerror_rate",
"dst_host_srv_rerror_rate","class","difficulty_level"
]

train_url = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Train.csv"
test_url  = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Test.csv"

df_train = pd.read_csv(train_url, header=None, names=col_names)
df_test  = pd.read_csv(test_url,  header=None, names=col_names)

# ──────────────────────────────────────────────
# 2. PRE‑PROCESSING
# ──────────────────────────────────────────────
# 2‑a) Encode the three categorical columns so that the model
#      receives integers instead of strings.
#      LabelEncoder gives an int to each unique value in the column: {'icmp':0, 'tcp':1, 'udp':2}
for col in ['protocol_type', 'service', 'flag']:
le = LabelEncoder().fit(pd.concat([df_train[col], df_test[col]]))
df_train[col] = le.transform(df_train[col])
df_test[col]  = le.transform(df_test[col])

# 2‑b) Build feature matrix X  (drop target & difficulty)
X_train = df_train.drop(columns=['class', 'difficulty_level'])
X_test  = df_test.drop(columns=['class', 'difficulty_level'])

# 2‑c) Convert multi‑class labels to binary
#      label 0 → 'normal' traffic, label 1 → any attack
y_train = (df_train['class'].str.lower() != 'normal').astype(int)
y_test  = (df_test['class'].str.lower() != 'normal').astype(int)

# ──────────────────────────────────────────────
# 3. MODEL: RANDOM FOREST
# ──────────────────────────────────────────────
# • n_estimators = 100 ➜ build 100 different decision‑trees.
# • max_depth=None  ➜ let each tree grow until pure leaves
#                    (or until it hits other stopping criteria).
# • random_state=42 ➜ reproducible randomness.
model = RandomForestClassifier(
n_estimators=100,
max_depth=None,
random_state=42,
bootstrap=True          # default: each tree is trained on a
# bootstrap sample the same size as
# the original training set.
# max_samples           # ← you can set this (float or int) to
#     use a smaller % of samples per tree.
)

model.fit(X_train, y_train)

# ──────────────────────────────────────────────
# 4. EVALUATION
# ──────────────────────────────────────────────
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]

print(f"Accuracy : {accuracy_score(y_test, y_pred):.3f}")
print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall   : {recall_score(y_test, y_pred):.3f}")
print(f"F1‑score : {f1_score(y_test, y_pred):.3f}")
print(f"ROC AUC  : {roc_auc_score(y_test, y_prob):.3f}")

"""
Accuracy:  0.770
Precision: 0.966
Recall:    0.618
F1-score:  0.754
ROC AUC:   0.962
"""

Випадковий ліс зазвичай досягає сильних результатів у цій задачі виявлення вторгнень. Ми можемо спостерігати покращення в метриках, таких як F1 або AUC, порівняно з єдиним деревом рішень, особливо в recall або precision, залежно від даних. Це узгоджується з розумінням, що "Random Forest (RF) є ансамблевим класифікатором і добре працює в порівнянні з іншими традиційними класифікаторами для ефективної класифікації атак.". У контексті операцій безпеки модель випадкового лісу може надійніше виявляти атаки, зменшуючи кількість хибних сповіщень, завдяки усередненню багатьох правил рішень. Важливість ознак з лісу може показати, які мережеві ознаки є найбільш показовими для атак (наприклад, певні мережеві сервіси або незвичайні кількості пакетів).

import pandas as pd
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import (accuracy_score, precision_score,
recall_score, f1_score, roc_auc_score)

# ─────────────────────────────────────────────────────────────
# 1️⃣  LOAD DATASET   (OpenML id 4534: “PhishingWebsites”)
#     • as_frame=True  ➜  returns a pandas DataFrame
# ─────────────────────────────────────────────────────────────
data = fetch_openml(data_id=4534, as_frame=True)   # or data_name="PhishingWebsites"
df   = data.frame
print(df.head())          # quick sanity‑check

# ─────────────────────────────────────────────────────────────
# 2️⃣  TARGET: 0 = legitimate, 1 = phishing
#     The raw column has values {1, 0, -1}:
#       1  → legitimate   → 0
#       0  &  -1          → phishing    → 1
# ─────────────────────────────────────────────────────────────
y = (df["Result"].astype(int) != 1).astype(int)
X = df.drop(columns=["Result"])

# Train / test split  (stratified keeps class proportions)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, random_state=42, stratify=y)

# ─────────────────────────────────────────────────────────────
# 3️⃣  PRE‑PROCESS: Standardize features (mean‑0 / std‑1)
# ─────────────────────────────────────────────────────────────
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test  = scaler.transform(X_test)

# ─────────────────────────────────────────────────────────────
# 4️⃣  MODEL: RBF‑kernel SVM
#     • C=1.0         (regularization strength)
#     • gamma='scale' (1 / [n_features × var(X)])
#     • probability=True  → enable predict_proba for ROC‑AUC
# ─────────────────────────────────────────────────────────────
clf = SVC(kernel="rbf", C=1.0, gamma="scale",
probability=True, random_state=42)
clf.fit(X_train, y_train)

# ─────────────────────────────────────────────────────────────
# 5️⃣  EVALUATION
# ─────────────────────────────────────────────────────────────
y_pred = clf.predict(X_test)
y_prob = clf.predict_proba(X_test)[:, 1]   # P(class 1)

print(f"Accuracy : {accuracy_score(y_test, y_pred):.3f}")
print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall   : {recall_score(y_test, y_pred):.3f}")
print(f"F1‑score : {f1_score(y_test, y_pred):.3f}")
print(f"ROC AUC  : {roc_auc_score(y_test, y_prob):.3f}")

"""
Accuracy : 0.956
Precision: 0.963
Recall   : 0.937
F1‑score : 0.950
ROC AUC  : 0.989
"""

Модель SVM виведе метрики, які ми можемо порівняти з логістичною регресією для тієї ж задачі. Ми можемо виявити, що SVM досягає високої точності та AUC, якщо дані добре розділені за ознаками. З іншого боку, якщо набір даних містить багато шуму або перекриваючих класів, SVM може не значно перевершувати логістичну регресію. На практиці SVM може дати приріст, коли існують складні, нелінійні зв'язки між ознаками та класом — RBF-ядро може захоплювати вигнуті межі рішень, які логістична регресія пропустить. Як і з усіма моделями, необхідна ретельна настройка параметрів C (регуляризація) та ядра (наприклад, gamma для RBF), щоб збалансувати зміщення та дисперсію.

import pandas as pd
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

# 1. Load NSL-KDD data
col_names = [                       # 41 features + 2 targets
"duration","protocol_type","service","flag","src_bytes","dst_bytes","land",
"wrong_fragment","urgent","hot","num_failed_logins","logged_in",
"num_compromised","root_shell","su_attempted","num_root","num_file_creations",
"num_shells","num_access_files","num_outbound_cmds","is_host_login",
"is_guest_login","count","srv_count","serror_rate","srv_serror_rate",
"rerror_rate","srv_rerror_rate","same_srv_rate","diff_srv_rate",
"srv_diff_host_rate","dst_host_count","dst_host_srv_count",
"dst_host_same_srv_rate","dst_host_diff_srv_rate",
"dst_host_same_src_port_rate","dst_host_srv_diff_host_rate",
"dst_host_serror_rate","dst_host_srv_serror_rate","dst_host_rerror_rate",
"dst_host_srv_rerror_rate","class","difficulty_level"
]

train_url = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Train.csv"
test_url  = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Test.csv"

df_train = pd.read_csv(train_url, header=None, names=col_names)
df_test  = pd.read_csv(test_url,  header=None, names=col_names)

# 2. Preprocess (encode categorical features, prepare binary labels)
from sklearn.preprocessing import LabelEncoder
for col in ['protocol_type', 'service', 'flag']:
le = LabelEncoder()
le.fit(pd.concat([df_train[col], df_test[col]], axis=0))
df_train[col] = le.transform(df_train[col])
df_test[col]  = le.transform(df_test[col])
X_train = df_train.drop(columns=['class', 'difficulty_level'], errors='ignore')
y_train = df_train['class'].apply(lambda x: 0 if x.strip().lower() == 'normal' else 1)
X_test  = df_test.drop(columns=['class', 'difficulty_level'], errors='ignore')
y_test  = df_test['class'].apply(lambda x: 0 if x.strip().lower() == 'normal' else 1)

# 3. Train Gaussian Naive Bayes
model = GaussianNB()
model.fit(X_train, y_train)

# 4. Evaluate on test set
y_pred = model.predict(X_test)
# For ROC AUC, need probability of class 1:
y_prob = model.predict_proba(X_test)[:, 1] if hasattr(model, "predict_proba") else y_pred
print(f"Accuracy:  {accuracy_score(y_test, y_pred):.3f}")
print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall:    {recall_score(y_test, y_pred):.3f}")
print(f"F1-score:  {f1_score(y_test, y_pred):.3f}")
print(f"ROC AUC:   {roc_auc_score(y_test, y_prob):.3f}")

"""
Accuracy:  0.450
Precision: 0.937
Recall:    0.037
F1-score:  0.071
ROC AUC:   0.867
"""

Цей код навчає класифікатор Naive Bayes для виявлення атак. Naive Bayes обчислює такі речі, як P(service=http | Attack) та P(Service=http | Normal) на основі навчальних даних, припускаючи незалежність між ознаками. Потім він використовує ці ймовірності для класифікації нових з'єднань як нормальних або атакуючих на основі спостережуваних ознак. Продуктивність NB на NSL-KDD може бути не такою високою, як у більш просунутих моделей (оскільки незалежність ознак порушується), але вона часто є прийнятною і має перевагу в надзвичайній швидкості. У таких сценаріях, як фільтрація електронної пошти в реальному часі або початкова тріаж URL-адрес, модель Naive Bayes може швидко виявляти очевидно шкідливі випадки з низьким використанням ресурсів.

Ми знову використаємо NSL-KDD (бінарна класифікація). Оскільки k-NN є обчислювально важким, ми використаємо підмножину навчальних даних, щоб зберегти його керованим у цій демонстрації. Ми виберемо, скажімо, 20,000 навчальних зразків з повних 125k і використаємо k=5 сусідів. Після навчання (насправді просто зберігання даних) ми оцінимо на тестовому наборі. Ми також масштабуватимемо ознаки для обчислення відстані, щоб забезпечити, що жодна окрема ознака не домінує через масштаб.

import pandas as pd
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

# 1. Load NSL-KDD and preprocess similarly
col_names = [                       # 41 features + 2 targets
"duration","protocol_type","service","flag","src_bytes","dst_bytes","land",
"wrong_fragment","urgent","hot","num_failed_logins","logged_in",
"num_compromised","root_shell","su_attempted","num_root","num_file_creations",
"num_shells","num_access_files","num_outbound_cmds","is_host_login",
"is_guest_login","count","srv_count","serror_rate","srv_serror_rate",
"rerror_rate","srv_rerror_rate","same_srv_rate","diff_srv_rate",
"srv_diff_host_rate","dst_host_count","dst_host_srv_count",
"dst_host_same_srv_rate","dst_host_diff_srv_rate",
"dst_host_same_src_port_rate","dst_host_srv_diff_host_rate",
"dst_host_serror_rate","dst_host_srv_serror_rate","dst_host_rerror_rate",
"dst_host_srv_rerror_rate","class","difficulty_level"
]

train_url = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Train.csv"
test_url  = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Test.csv"

df_train = pd.read_csv(train_url, header=None, names=col_names)
df_test  = pd.read_csv(test_url,  header=None, names=col_names)

from sklearn.preprocessing import LabelEncoder
for col in ['protocol_type', 'service', 'flag']:
le = LabelEncoder()
le.fit(pd.concat([df_train[col], df_test[col]], axis=0))
df_train[col] = le.transform(df_train[col])
df_test[col]  = le.transform(df_test[col])
X = df_train.drop(columns=['class', 'difficulty_level'], errors='ignore')
y = df_train['class'].apply(lambda x: 0 if x.strip().lower() == 'normal' else 1)
# Use a random subset of the training data for K-NN (to reduce computation)
X_train = X.sample(n=20000, random_state=42)
y_train = y[X_train.index]
# Use the full test set for evaluation
X_test = df_test.drop(columns=['class', 'difficulty_level'], errors='ignore')
y_test = df_test['class'].apply(lambda x: 0 if x.strip().lower() == 'normal' else 1)

# 2. Feature scaling for distance-based model
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test  = scaler.transform(X_test)

# 3. Train k-NN classifier (store data)
model = KNeighborsClassifier(n_neighbors=5, n_jobs=-1)
model.fit(X_train, y_train)

# 4. Evaluate on test set
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]
print(f"Accuracy:  {accuracy_score(y_test, y_pred):.3f}")
print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall:    {recall_score(y_test, y_pred):.3f}")
print(f"F1-score:  {f1_score(y_test, y_pred):.3f}")
print(f"ROC AUC:   {roc_auc_score(y_test, y_prob):.3f}")

"""
Accuracy:  0.780
Precision: 0.972
Recall:    0.632
F1-score:  0.766
ROC AUC:   0.837
"""

Модель k-NN класифікує з'єднання, аналізуючи 5 найближчих з'єднань у підмножині навчального набору. Якщо, наприклад, 4 з цих сусідів є атаками (аномаліями), а 1 - нормальним, нове з'єднання буде класифіковане як атака. Продуктивність може бути розумною, хоча часто не такою високою, як у добре налаштованого Random Forest або SVM на тих же даних. Однак k-NN іноді може проявити себе, коли розподіли класів дуже нерегулярні та складні — ефективно використовуючи пам'яті для пошуку. У кібербезпеці k-NN (з k=1 або малим k) може бути використаний для виявлення відомих патернів атак за прикладом або як компонент у більш складних системах (наприклад, для кластеризації, а потім класифікації на основі членства в кластері).

Градієнтні підсилювальні машини (наприклад, XGBoost)

Градієнтні підсилювальні машини є одними з найпотужніших алгоритмів для структурованих даних. Градієнтне підсилення відноситься до техніки побудови ансамблю слабких навчальних моделей (часто дерев рішень) послідовно, де кожна нова модель виправляє помилки попереднього ансамблю. На відміну від бэггінгу (Random Forest), який будує дерева паралельно та усереднює їх, підсилення будує дерева одне за одним, кожне зосереджуючись більше на випадках, які попередні дерева неправильно передбачили.

Найпопулярніші реалізації в останні роки — це XGBoost, LightGBM та CatBoost, всі з яких є бібліотеками градієнтного підсилення дерев рішень (GBDT). Вони мали надзвичайний успіх у змаганнях з машинного навчання та застосуваннях, часто досягаючи найсучаснішої продуктивності на табличних наборах даних. У кібербезпеці дослідники та практики використовували градієнтно підсилені дерева для завдань, таких як виявлення шкідливого ПЗ (використовуючи ознаки, витягнуті з файлів або поведінки під час виконання) та виявлення мережевих вторгнень. Наприклад, модель градієнтного підсилення може поєднувати багато слабких правил (дерев), таких як "якщо багато SYN-пакетів і незвичайний порт -> ймовірно, сканування", в потужний композитний детектор, який враховує багато тонких патернів.

Чому підсилені дерева такі ефективні? Кожне дерево в послідовності навчається на залишкових помилках (градієнтах) прогнозів поточного ансамблю. Таким чином, модель поступово "підсилює" області, де вона слабка. Використання дерев рішень як базових навчальних моделей означає, що фінальна модель може захоплювати складні взаємодії та нелінійні зв'язки. Крім того, підсилення в основному має форму вбудованої регуляризації: додаючи багато малих дерев (і використовуючи швидкість навчання для масштабування їх внесків), воно часто добре узагальнює без великого перенавчання, за умови, що вибрані правильні параметри.

Ключові характеристики градієнтного підсилення:

• Тип проблеми: Переважно класифікація та регресія. У безпеці зазвичай класифікація (наприклад, бінарна класифікація з'єднання або файлу). Він обробляє бінарні, багатокласові (з відповідною втратою) та навіть ранжування.

• Інтерпретованість: Низька до середньої. Хоча одне підсилене дерево є малим, повна модель може мати сотні дерев, що не є зрозумілим для людини в цілому. Однак, як і Random Forest, вона може надавати оцінки важливості ознак, а інструменти, такі як SHAP (SHapley Additive exPlanations), можуть бути використані для інтерпретації окремих прогнозів до певної міри.

• Переваги: Часто є найкращим алгоритмом для структурованих/табличних даних. Може виявляти складні патерни та взаємодії. Має багато параметрів налаштування (кількість дерев, глибина дерев, швидкість навчання, терміни регуляризації), щоб налаштувати складність моделі та запобігти перенавчанню. Сучасні реалізації оптимізовані для швидкості (наприклад, XGBoost використовує інформацію другого порядку градієнта та ефективні структури даних). Як правило, краще обробляє незбалансовані дані, коли поєднується з відповідними функціями втрат або шляхом коригування ваг зразків.

• Обмеження: Складніше налаштувати, ніж простіші моделі; навчання може бути повільним, якщо дерева глибокі або кількість дерев велика (хоча все ще зазвичай швидше, ніж навчання порівнянної глибокої нейронної мережі на тих же даних). Модель може перенавчитися, якщо не налаштована (наприклад, занадто багато глибоких дерев з недостатньою регуляризацією). Через велику кількість гіперпараметрів ефективне використання градієнтного підсилення може вимагати більше експертизи або експериментів. Також, як і методи на основі дерев, він не обробляє дуже розріджені високорозмірні дані так ефективно, як лінійні моделі або Naive Bayes (хоча його все ще можна застосовувати, наприклад, у класифікації тексту, але може не бути першим вибором без інженерії ознак).

import pandas as pd
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

# 1️⃣ Load the “Phishing Websites” data directly from OpenML
data = fetch_openml(data_id=4534, as_frame=True)   # or data_name="PhishingWebsites"
df   = data.frame

# 2️⃣ Separate features/target & make sure everything is numeric
X = df.drop(columns=["Result"])
y = df["Result"].astype(int).apply(lambda v: 1 if v == 1 else 0)  # map {-1,1} → {0,1}

# (If any column is still object‑typed, coerce it to numeric.)
X = X.apply(pd.to_numeric, errors="coerce").fillna(0)

# 3️⃣ Train/test split
X_train, X_test, y_train, y_test = train_test_split(
X.values, y, test_size=0.20, random_state=42
)

# 4️⃣ Gradient Boosting model
model = GradientBoostingClassifier(
n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42
)
model.fit(X_train, y_train)

# 5️⃣ Evaluation
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]

print(f"Accuracy:  {accuracy_score(y_test, y_pred):.3f}")
print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall:    {recall_score(y_test, y_pred):.3f}")
print(f"F1‑score:  {f1_score(y_test, y_pred):.3f}")
print(f"ROC AUC:   {roc_auc_score(y_test, y_prob):.3f}")

"""
Accuracy:  0.951
Precision: 0.949
Recall:    0.965
F1‑score:  0.957
ROC AUC:   0.990
"""

Комбінування моделей: ансамблеве навчання та стекінг

Ансамблеве навчання є стратегією комбінування кількох моделей для покращення загальної продуктивності. Ми вже бачили конкретні методи ансамблів: Random Forest (ансамбль дерев через бэггінг) та Gradient Boosting (ансамбль дерев через послідовне підсилення). Але ансамблі можна створювати й іншими способами, такими як голосуючі ансамблі або стекінг (stacking). Основна ідея полягає в тому, що різні моделі можуть захоплювати різні патерни або мати різні слабкості; комбінуючи їх, ми можемо компенсувати помилки кожної моделі силами іншої.

• Голосуючий ансамбль: У простому голосуючому класифікаторі ми навчаємо кілька різноманітних моделей (скажімо, логістичну регресію, дерево рішень і SVM) і змушуємо їх голосувати за фінальне передбачення (більшість голосів для класифікації). Якщо ми зважуємо голоси (наприклад, надаємо вищу вагу більш точним моделям), це зважена схема голосування. Це зазвичай покращує продуктивність, коли окремі моделі є досить хорошими та незалежними -- ансамбль зменшує ризик помилки окремої моделі, оскільки інші можуть її виправити. Це як мати панель експертів, а не одну думку.

• Стекінг (Stacked Ensemble): Стекінг йде ще далі. Замість простого голосування він навчає мета-модель вчитися, як найкраще комбінувати прогнози базових моделей. Наприклад, ви навчаєте 3 різні класифікатори (базові навчальні моделі), а потім передаєте їх виходи (або ймовірності) як ознаки в мета-класифікатор (часто просту модель, таку як логістична регресія), яка вчиться оптимальному способу їх змішування. Мета-модель навчається на валідаційному наборі або через крос-валідацію, щоб уникнути перенавчання. Стекінг часто може перевершити просте голосування, вивчаючи які моделі більше довіряти в яких обставинах. У кібербезпеці одна модель може бути кращою в виявленні мережевих сканувань, тоді як інша краще виявляє шкідливе програмне забезпечення; модель стекінгу може навчитися покладатися на кожну відповідно.

Ансамблі, чи то через голосування, чи через стекінг, зазвичай підвищують точність і надійність. Недоліком є підвищена складність і іноді знижена інтерпретованість (хоча деякі підходи ансамблів, такі як середнє значення дерев рішень, все ще можуть надати певне уявлення, наприклад, важливість ознак). На практиці, якщо операційні обмеження дозволяють, використання ансамблю може призвести до вищих показників виявлення. Багато виграшних рішень у викликах з кібербезпеки (і в конкурсах Kaggle загалом) використовують ансамблеві техніки, щоб витиснути останню частину продуктивності.

import pandas as pd
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import StackingClassifier, RandomForestClassifier
from sklearn.metrics import (accuracy_score, precision_score,
recall_score, f1_score, roc_auc_score)

# ──────────────────────────────────────────────
# 1️⃣  LOAD DATASET (OpenML id 4534)
# ──────────────────────────────────────────────
data = fetch_openml(data_id=4534, as_frame=True)     # “PhishingWebsites”
df   = data.frame

# Target mapping:  1 → legitimate (0),   0/‑1 → phishing (1)
y = (df["Result"].astype(int) != 1).astype(int)
X = df.drop(columns=["Result"])

# Train / test split (stratified to keep class balance)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, random_state=42, stratify=y)

# ──────────────────────────────────────────────
# 2️⃣  DEFINE BASE LEARNERS
#     • LogisticRegression and k‑NN need scaling ➜ wrap them
#       in a Pipeline(StandardScaler → model) so that scaling
#       happens inside each CV fold of StackingClassifier.
# ──────────────────────────────────────────────
base_learners = [
('lr',  make_pipeline(StandardScaler(),
LogisticRegression(max_iter=1000,
solver='lbfgs',
random_state=42))),
('dt',  DecisionTreeClassifier(max_depth=5, random_state=42)),
('knn', make_pipeline(StandardScaler(),
KNeighborsClassifier(n_neighbors=5)))
]

# Meta‑learner (level‑2 model)
meta_learner = RandomForestClassifier(n_estimators=50, random_state=42)

stack_model = StackingClassifier(
estimators      = base_learners,
final_estimator = meta_learner,
cv              = 5,        # 5‑fold CV to create meta‑features
passthrough     = False     # only base learners’ predictions go to meta‑learner
)

# ──────────────────────────────────────────────
# 3️⃣  TRAIN ENSEMBLE
# ──────────────────────────────────────────────
stack_model.fit(X_train, y_train)

# ──────────────────────────────────────────────
# 4️⃣  EVALUATE
# ──────────────────────────────────────────────
y_pred = stack_model.predict(X_test)
y_prob = stack_model.predict_proba(X_test)[:, 1]   # P(phishing)

print(f"Accuracy : {accuracy_score(y_test, y_pred):.3f}")
print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall   : {recall_score(y_test, y_pred):.3f}")
print(f"F1‑score : {f1_score(y_test, y_pred):.3f}")
print(f"ROC AUC  : {roc_auc_score(y_test, y_prob):.3f}")

"""
Accuracy : 0.954
Precision: 0.951
Recall   : 0.946
F1‑score : 0.948
ROC AUC  : 0.992
"""

References

• https://madhuramiah.medium.com/logistic-regression-6e55553cc003
• https://www.geeksforgeeks.org/decision-tree-introduction-example/
• https://rjwave.org/ijedr/viewpaperforall.php?paper=IJEDR1703132
• https://www.ibm.com/think/topics/support-vector-machine
• https://en.m.wikipedia.org/wiki/Naive_Bayes_spam_filtering
• https://medium.com/@rupalipatelkvc/gbdt-demystified-how-lightgbm-xgboost-and-catboost-work-9479b7262644
• https://zvelo.com/ai-and-machine-learning-in-cybersecurity/
• https://medium.com/@chaandram/linear-regression-explained-28d5bf1934ae
• https://cybersecurity.springeropen.com/articles/10.1186/s42400-021-00103-8
• https://www.ibm.com/think/topics/knn
• https://www.ibm.com/think/topics/knn
• https://arxiv.org/pdf/2101.02552
• https://cybersecurity-magazine.com/how-deep-learning-enhances-intrusion-detection-systems/
• https://cybersecurity-magazine.com/how-deep-learning-enhances-intrusion-detection-systems/
• https://medium.com/@sarahzouinina/ensemble-learning-boosting-model-performance-by-combining-strengths-02e56165b901
• https://medium.com/@sarahzouinina/ensemble-learning-boosting-model-performance-by-combining-strengths-02e56165b901