Użyjemy Zestawu Danych Stron Phishingowych (z repozytorium UCI), który zawiera wyodrębnione cechy stron internetowych (takie jak to, czy URL ma adres IP, wiek domeny, obecność podejrzanych elementów w HTML, itp.) oraz etykietę wskazującą, czy strona jest phishingowa, czy legalna. Trenujemy model regresji logistycznej do klasyfikacji stron internetowych, a następnie oceniamy jego dokładność, precyzję, czułość, F1-score i ROC AUC na zbiorze testowym.

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

W tym przykładzie wykrywania phishingu, regresja logistyczna produkuje prawdopodobieństwo dla każdej strony internetowej, że jest phishingowa. Oceniając dokładność, precyzję, czułość i F1, uzyskujemy poczucie wydajności modelu. Na przykład, wysoka czułość oznacza, że wychwytuje większość stron phishingowych (ważne dla bezpieczeństwa, aby zminimalizować pominięte ataki), podczas gdy wysoka precyzja oznacza, że ma niewiele fałszywych alarmów (ważne, aby uniknąć zmęczenia analityków). ROC AUC (Area Under the ROC Curve) daje miarę wydajności niezależną od progu (1.0 jest idealne, 0.5 nie lepsze niż przypadek). Regresja logistyczna często dobrze sprawdza się w takich zadaniach, ale jeśli granica decyzyjna między stronami phishingowymi a legalnymi jest złożona, mogą być potrzebne bardziej zaawansowane modele nieliniowe.

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

W tym przykładzie drzewa decyzyjnego ograniczyliśmy głębokość drzewa do 10, aby uniknąć ekstremalnego przeuczenia (parametr max_depth=10). Metryki pokazują, jak dobrze drzewo rozróżnia ruch normalny od ataków. Wysoki recall oznacza, że wychwytuje większość ataków (ważne dla IDS), podczas gdy wysoka precyzja oznacza niewiele fałszywych alarmów. Drzewa decyzyjne często osiągają przyzwoitą dokładność na danych strukturalnych, ale pojedyncze drzewo może nie osiągnąć najlepszej możliwej wydajności. Niemniej jednak, interpretowalność modelu to duży plus - możemy zbadać podziały drzewa, aby zobaczyć, które cechy (np. service, src_bytes itd.) mają największy wpływ na oznaczanie połączenia jako złośliwego.

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

Las random forest zazwyczaj osiąga silne wyniki w tym zadaniu wykrywania intruzji. Możemy zaobserwować poprawę w metrykach takich jak F1 lub AUC w porównaniu do pojedynczego drzewa decyzyjnego, szczególnie w zakresie recall lub precision, w zależności od danych. To jest zgodne z rozumieniem, że "Random Forest (RF) jest klasyfikatorem zespołowym i wypada dobrze w porównaniu do innych tradycyjnych klasyfikatorów w skutecznej klasyfikacji ataków.". W kontekście operacji bezpieczeństwa model random forest może bardziej niezawodnie oznaczać ataki, jednocześnie redukując fałszywe alarmy, dzięki uśrednianiu wielu reguł decyzyjnych. Ważność cech z lasu może powiedzieć nam, które cechy sieciowe są najbardziej wskazujące na ataki (np. pewne usługi sieciowe lub nietypowe liczby pakietów).

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

Model SVM wygeneruje metryki, które możemy porównać z regresją logistyczną w tym samym zadaniu. Możemy stwierdzić, że SVM osiąga wysoką dokładność i AUC, jeśli dane są dobrze oddzielone przez cechy. Z drugiej strony, jeśli zbiór danych zawiera dużo szumów lub nakładające się klasy, SVM może nieznacznie przewyższać regresję logistyczną. W praktyce, SVM mogą dać impuls, gdy istnieją złożone, nieliniowe relacje między cechami a klasą – jądro RBF może uchwycić zakrzywione granice decyzyjne, które regresja logistyczna by przeoczyła. Jak w przypadku wszystkich modeli, konieczne jest staranne dostrojenie parametrów C (regularyzacja) i parametrów jądra (jak gamma dla RBF), aby zrównoważyć bias i wariancję.

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

Ten kod trenuje klasyfikator Naive Bayes do wykrywania ataków. Naive Bayes obliczy takie rzeczy jak P(service=http | Attack) i P(Service=http | Normal) na podstawie danych treningowych, zakładając niezależność między cechami. Następnie wykorzysta te prawdopodobieństwa do klasyfikacji nowych połączeń jako normalne lub atak na podstawie zaobserwowanych cech. Wydajność NB na NSL-KDD może nie być tak wysoka jak w przypadku bardziej zaawansowanych modeli (ponieważ niezależność cech jest naruszona), ale często jest przyzwoita i charakteryzuje się ekstremalną szybkością. W scenariuszach takich jak filtrowanie e-maili w czasie rzeczywistym lub wstępna triage URL-i, model Naive Bayes może szybko oznaczyć oczywiście złośliwe przypadki przy niskim zużyciu zasobów.

Ponownie użyjemy NSL-KDD (klasyfikacja binarna). Ponieważ k-NN jest obliczeniowo intensywny, użyjemy podzbioru danych treningowych, aby utrzymać to w zasięgu w tej demonstracji. Wybierzemy, powiedzmy, 20 000 próbek treningowych z pełnych 125k i użyjemy k=5 sąsiadów. Po treningu (naprawdę tylko przechowywaniu danych) ocenimy na zbiorze testowym. Również skalujemy cechy do obliczeń odległości, aby zapewnić, że żadna pojedyncza cecha nie dominuje z powodu skali.

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

Model k-NN sklasyfikuje połączenie, analizując 5 najbliższych połączeń w podzbiorze zbioru treningowego. Jeśli na przykład 4 z tych sąsiadów to ataki (anomalia), a 1 jest normalne, nowe połączenie zostanie sklasyfikowane jako atak. Wydajność może być rozsądna, chociaż często nie tak wysoka jak w przypadku dobrze dostrojonego Random Forest lub SVM na tych samych danych. Jednak k-NN może czasami błyszczeć, gdy rozkłady klas są bardzo nieregularne i złożone - skutecznie wykorzystując wyszukiwanie oparte na pamięci. W cyberbezpieczeństwie k-NN (z k=1 lub małym k) może być używane do wykrywania znanych wzorców ataków na podstawie przykładów lub jako komponent w bardziej złożonych systemach (np. do klasteryzacji, a następnie klasyfikacji na podstawie przynależności do klastra).

Gradient Boosting Machines (np. XGBoost)

Gradient Boosting Machines należą do najpotężniejszych algorytmów dla danych strukturalnych. Gradient boosting odnosi się do techniki budowania zespołu słabych uczniów (często drzew decyzyjnych) w sposób sekwencyjny, gdzie każdy nowy model koryguje błędy poprzedniego zespołu. W przeciwieństwie do baggingu (Random Forest), który buduje drzewa równolegle i je uśrednia, boosting buduje drzewa jedno po drugim, każde koncentrując się bardziej na instancjach, które poprzednie drzewa źle przewidziały.

Najpopularniejsze implementacje w ostatnich latach to XGBoost, LightGBM i CatBoost, które są bibliotekami drzew decyzyjnych z gradientowym boostingiem (GBDT). Odniosły one ogromny sukces w konkursach i zastosowaniach uczenia maszynowego, często osiągając wyniki na poziomie stanu techniki na zbiorach danych tabelarycznych. W cyberbezpieczeństwie badacze i praktycy używali drzew z gradientowym boostingiem do zadań takich jak wykrywanie złośliwego oprogramowania (używając cech wyodrębnionych z plików lub zachowania w czasie rzeczywistym) oraz wykrywanie intruzji w sieci. Na przykład model gradient boosting może łączyć wiele słabych reguł (drzew) takich jak "jeśli wiele pakietów SYN i nietypowy port -> prawdopodobnie skanowanie" w silny detektor kompozytowy, który uwzględnia wiele subtelnych wzorców.

Dlaczego drzewa z boostingiem są tak skuteczne? Każde drzewo w sekwencji jest trenowane na resztkowych błędach (gradientach) prognoz obecnego zespołu. W ten sposób model stopniowo "wzmacnia" obszary, w których jest słaby. Użycie drzew decyzyjnych jako podstawowych uczniów oznacza, że końcowy model może uchwycić złożone interakcje i nieliniowe relacje. Ponadto boosting ma wbudowaną formę regularizacji: dodając wiele małych drzew (i używając współczynnika uczenia do skalowania ich wkładów), często dobrze generalizuje bez dużego przeuczenia, pod warunkiem, że wybrane są odpowiednie parametry.

Kluczowe cechy Gradient Boosting:

• Typ problemu: Głównie klasyfikacja i regresja. W bezpieczeństwie zazwyczaj klasyfikacja (np. binarna klasyfikacja połączenia lub pliku). Obsługuje problemy binarne, wieloklasowe (z odpowiednią stratą) i nawet problemy rankingowe.

• Interpretowalność: Niska do średniej. Chociaż pojedyncze drzewo z boostingiem jest małe, pełny model może mieć setki drzew, co nie jest interpretowalne dla ludzi jako całość. Jednak, podobnie jak Random Forest, może dostarczać oceny ważności cech, a narzędzia takie jak SHAP (SHapley Additive exPlanations) mogą być używane do interpretacji indywidualnych prognoz w pewnym zakresie.

• Zalety: Często najlepiej działający algorytm dla danych strukturalnych/tabelarycznych. Może wykrywać złożone wzorce i interakcje. Ma wiele pokręteł do strojenia (liczba drzew, głębokość drzew, współczynnik uczenia, terminy regularizacji), aby dostosować złożoność modelu i zapobiec przeuczeniu. Nowoczesne implementacje są zoptymalizowane pod kątem szybkości (np. XGBoost używa informacji o gradientach drugiego rzędu i efektywnych struktur danych). Zwykle lepiej radzi sobie z niezrównoważonymi danymi, gdy jest połączony z odpowiednimi funkcjami straty lub przez dostosowanie wag próbek.

• Ograniczenia: Bardziej skomplikowane do strojenia niż prostsze modele; trening może być wolny, jeśli drzewa są głębokie lub liczba drzew jest duża (choć nadal zazwyczaj szybszy niż trening porównywalnej głębokiej sieci neuronowej na tych samych danych). Model może przeuczyć się, jeśli nie jest dostrojony (np. zbyt wiele głębokich drzew przy niewystarczającej regularizacji). Z powodu wielu hiperparametrów, skuteczne użycie gradient boosting może wymagać większej wiedzy lub eksperymentowania. Ponadto, podobnie jak metody oparte na drzewach, nie radzi sobie z bardzo rzadkimi danymi o wysokiej wymiarowości tak efektywnie jak modele liniowe lub Naive Bayes (choć nadal może być stosowane, np. w klasyfikacji tekstu, ale może nie być pierwszym wyborem bez inżynierii cech).

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

Łączenie modeli: Uczenie zespołowe i Stacking

Uczenie zespołowe to strategia łączenia wielu modeli w celu poprawy ogólnej wydajności. Już widzieliśmy konkretne metody zespołowe: Random Forest (zespół drzew za pomocą baggingu) i Gradient Boosting (zespół drzew za pomocą sekwencyjnego boosting). Ale zespoły można tworzyć także w inny sposób, na przykład zespoły głosujące lub stacked generalization (stacking). Główna idea polega na tym, że różne modele mogą uchwycić różne wzorce lub mieć różne słabości; łącząc je, możemy zrekompensować błędy każdego modelu mocnymi stronami innych.

• Zespół głosujący: W prostym klasyfikatorze głosującym trenujemy wiele różnorodnych modeli (powiedzmy, regresję logistyczną, drzewo decyzyjne i SVM) i pozwalamy im głosować na ostateczną prognozę (głos większościowy dla klasyfikacji). Jeśli ważymy głosy (np. wyższa waga dla dokładniejszych modeli), to jest to ważony schemat głosowania. Zazwyczaj poprawia to wydajność, gdy poszczególne modele są wystarczająco dobre i niezależne -- zespół zmniejsza ryzyko błędu pojedynczego modelu, ponieważ inne mogą go skorygować. To jak posiadanie panelu ekspertów zamiast jednej opinii.

• Stacking (Zespół Stacked): Stacking idzie o krok dalej. Zamiast prostego głosowania, trenuje meta-model, aby nauczyć się, jak najlepiej łączyć prognozy modeli bazowych. Na przykład, trenujesz 3 różne klasyfikatory (uczniowie bazowi), a następnie przekazujesz ich wyniki (lub prawdopodobieństwa) jako cechy do meta-klasyfikatora (często prostego modelu, takiego jak regresja logistyczna), który uczy się optymalnego sposobu ich mieszania. Meta-model jest trenowany na zbiorze walidacyjnym lub za pomocą walidacji krzyżowej, aby uniknąć nadmiernego dopasowania. Stacking często może przewyższyć proste głosowanie, ucząc się które modele bardziej ufać w jakich okolicznościach. W cyberbezpieczeństwie jeden model może być lepszy w wychwytywaniu skanów sieciowych, podczas gdy inny lepiej wychwytuje sygnalizację złośliwego oprogramowania; model stacking mógłby nauczyć się polegać na każdym z nich w odpowiedni sposób.

Zespoły, niezależnie od tego, czy przez głosowanie, czy stacking, mają tendencję do zwiększania dokładności i odporności. Wadą jest zwiększona złożoność i czasami zmniejszona interpretowalność (choć niektóre podejścia zespołowe, takie jak średnia drzew decyzyjnych, mogą nadal dostarczać pewnych informacji, np. o ważności cech). W praktyce, jeśli ograniczenia operacyjne na to pozwalają, użycie zespołu może prowadzić do wyższych wskaźników wykrywania. Wiele zwycięskich rozwiązań w wyzwaniach związanych z cyberbezpieczeństwem (i ogólnie w konkursach Kaggle) wykorzystuje techniki zespołowe, aby wydobyć ostatni kawałek wydajności.

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