import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# ── 1. Column names taken from the NSL‑KDD documentation ──────────────
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 *without* header row ─────────────────────────────────
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()
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])

# ── 4. Prepare features / target ─────────────────────────────────────
X_train = df_train.drop(columns=['class', 'difficulty_level', 'duration'])
y_train = df_train['duration']

X_test  = df_test.drop(columns=['class', 'difficulty_level', 'duration'])
y_test  = df_test['duration']

# ── 5. Train & evaluate simple Linear Regression ─────────────────────
model = LinearRegression().fit(X_train, y_train)
y_pred = model.predict(X_test)

print(f"Test MSE: {mean_squared_error(y_test, y_pred):.2f}")
print(f"Test R² : {r2_score(y_test, y_pred):.3f}")

"""
Test MSE: 3021333.56
Test R² : -0.526
"""

Σε αυτό το παράδειγμα, το μοντέλο γραμμικής παλινδρόμησης προσπαθεί να προβλέψει τη διάρκεια της σύνδεσης duration από άλλα χαρακτηριστικά δικτύου. Μετράμε την απόδοση με το Μέσο Τετραγωνικό Σφάλμα (MSE) και το R². Ένα R² κοντά στο 1.0 θα υποδείκνυε ότι το μοντέλο εξηγεί τη μεγαλύτερη διακύμανση στη duration, ενώ ένα χαμηλό ή αρνητικό R² υποδεικνύει κακή προσαρμογή. (Μην εκπλαγείτε αν το R² είναι χαμηλό εδώ -- η πρόβλεψη της duration μπορεί να είναι δύσκολη από τα δεδομένα χαρακτηριστικά, και η γραμμική παλινδρόμηση μπορεί να μην αποτυπώνει τα μοτίβα αν είναι περίπλοκα.)

Θα χρησιμοποιήσουμε ένα Σύνολο Δεδομένων Ιστοσελίδων Phishing (από το αποθετήριο UCI) το οποίο περιέχει εξαγόμενα χαρακτηριστικά ιστοσελίδων (όπως αν το URL έχει διεύθυνση IP, την ηλικία του τομέα, παρουσία ύποπτων στοιχείων στο HTML, κ.λπ.) και μια ετικέτα που υποδεικνύει αν η ιστοσελίδα είναι phishing ή νόμιμη. Εκπαιδεύουμε ένα μοντέλο λογιστικής παλινδρόμησης για να ταξινομήσουμε ιστοσελίδες και στη συνέχεια αξιολογούμε την ακρίβεια, την ακρίβεια, την ανάκληση, το F1-score και το 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
"""

Σε αυτό το παράδειγμα ανίχνευσης phishing, η λογιστική παλινδρόμηση παράγει μια πιθανότητα για κάθε ιστότοπο να είναι phishing. Αξιολογώντας την ακρίβεια, την ακρίβεια, την ανάκληση και το F1, αποκτούμε μια αίσθηση της απόδοσης του μοντέλου. Για παράδειγμα, μια υψηλή ανάκληση θα σήμαινε ότι πιάνει τους περισσότερους ιστότοπους phishing (σημαντικό για την ασφάλεια για να ελαχιστοποιηθούν οι χαμένες επιθέσεις), ενώ η υψηλή ακρίβεια σημαίνει ότι έχει λίγες ψευδείς συναγερμούς (σημαντικό για να αποφευχθεί η κόπωση των αναλυτών). Ο ROC AUC (Area Under the ROC Curve) παρέχει ένα μέτρο απόδοσης ανεξάρτητο από το κατώφλι (1.0 είναι ιδανικό, 0.5 δεν είναι καλύτερο από την τύχη). Η λογιστική παλινδρόμηση συχνά αποδίδει καλά σε τέτοιες εργασίες, αλλά αν το όριο απόφασης μεταξύ phishing και νόμιμων ιστότοπων είναι περίπλοκο, μπορεί να χρειαστούν πιο ισχυρά μη γραμμικά μοντέλα.

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 σε σύγκριση με το ενιαίο δέντρο απόφασης, ειδικά στην ανάκληση ή την ακρίβεια, ανάλογα με τα δεδομένα. Αυτό ευθυγραμμίζεται με την κατανόηση ότι "Το Τυχαίο Δάσος (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 μπορεί να μην είναι τόσο υψηλή όσο πιο προηγμένα μοντέλα (καθώς παραβιάζεται η ανεξαρτησία των χαρακτηριστικών), αλλά συχνά είναι ικανοποιητική και προσφέρει το πλεονέκτημα της εξαιρετικής ταχύτητας. Σε σενάρια όπως η φιλτράρισμα email σε πραγματικό χρόνο ή η αρχική τριχοτόμηση 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) θα μπορούσε να χρησιμοποιηθεί για την ανίχνευση γνωστών προτύπων επιθέσεων μέσω παραδείγματος, ή ως συστατικό σε πιο σύνθετα συστήματα (π.χ., για ομαδοποίηση και στη συνέχεια ταξινόμηση με βάση την ένταξη σε ομάδες).

Gradient Boosting Machines (π.χ., XGBoost)

Οι Gradient Boosting Machines είναι από τους πιο ισχυρούς αλγόριθμους για δομημένα δεδομένα. Gradient boosting αναφέρεται στην τεχνική κατασκευής ενός συνόλου αδύναμων μαθητών (συχνά δέντρα αποφάσεων) με διαδοχικό τρόπο, όπου κάθε νέο μοντέλο διορθώνει τα σφάλματα του προηγούμενου συνόλου. Σε αντίθεση με το bagging (Random Forests) που κατασκευάζει δέντρα παράλληλα και τα μέσωνε, το boosting κατασκευάζει δέντρα ένα προς ένα, το καθένα εστιάζοντας περισσότερο στις περιπτώσεις που τα προηγούμενα δέντρα προέβλεψαν λανθασμένα.

Οι πιο δημοφιλείς υλοποιήσεις τα τελευταία χρόνια είναι οι XGBoost, LightGBM και CatBoost, όλες οι οποίες είναι βιβλιοθήκες δέντρων απόφασης gradient boosting (GBDT). Έχουν σημειώσει εξαιρετική επιτυχία σε διαγωνισμούς και εφαρμογές μηχανικής μάθησης, συχνά επιτυγχάνοντας κορυφαία απόδοση σε πίνακες δεδομένων. Στην κυβερνοασφάλεια, ερευνητές και επαγγελματίες έχουν χρησιμοποιήσει δέντρα με gradient boosting για εργασίες όπως ανίχνευση κακόβουλου λογισμικού (χρησιμοποιώντας χαρακτηριστικά που εξάγονται από αρχεία ή συμπεριφορά κατά την εκτέλεση) και ανίχνευση δικτυακής εισβολής. Για παράδειγμα, ένα μοντέλο gradient boosting μπορεί να συνδυάσει πολλούς αδύναμους κανόνες (δέντρα) όπως "αν υπάρχουν πολλοί SYN πακέτα και ασυνήθιστη θύρα -> πιθανή σάρωση" σε έναν ισχυρό σύνθετο ανιχνευτή που λαμβάνει υπόψη πολλές λεπτές προσαρμογές.

Γιατί είναι τόσο αποτελεσματικά τα δέντρα που ενισχύονται; Κάθε δέντρο στη σειρά εκπαιδεύεται στα υπολειμματικά σφάλματα (γραμμές) των προβλέψεων του τρέχοντος συνόλου. Με αυτόν τον τρόπο, το μοντέλο σταδιακά "ενισχύει" τις περιοχές όπου είναι αδύναμο. Η χρήση δέντρων αποφάσεων ως βασικών μαθητών σημαίνει ότι το τελικό μοντέλο μπορεί να συλλάβει περίπλοκες αλληλεπιδράσεις και μη γραμμικές σχέσεις. Επίσης, το boosting έχει εγγενώς μια μορφή ενσωματωμένης κανονικοποίησης: προσθέτοντας πολλά μικρά δέντρα (και χρησιμοποιώντας ένα ρυθμό μάθησης για να κλιμακώσει τις συνεισφορές τους), συχνά γενικεύει καλά χωρίς υπερβολική προσαρμογή, εφόσον επιλεγούν σωστά οι παράμετροι.

Κύρια χαρακτηριστικά του Gradient Boosting:

• Τύπος Προβλήματος: Κυρίως ταξινόμηση και παλινδρόμηση. Στην ασφάλεια, συνήθως ταξινόμηση (π.χ., δυαδική ταξινόμηση μιας σύνδεσης ή αρχείου). Διαχειρίζεται δυαδικά, πολυταξινομημένα (με κατάλληλη απώλεια) και ακόμη και προβλήματα κατάταξης.

• Ερμηνευσιμότητα: Χαμηλή έως μέτρια. Ενώ ένα μόνο ενισχυμένο δέντρο είναι μικρό, ένα πλήρες μοντέλο μπορεί να έχει εκατοντάδες δέντρα, τα οποία δεν είναι κατανοητά από τον άνθρωπο ως σύνολο. Ωστόσο, όπως και το Random Forest, μπορεί να παρέχει βαθμολογίες σημασίας χαρακτηριστικών, και εργαλεία όπως το SHAP (SHapley Additive exPlanations) μπορούν να χρησιμοποιηθούν για την ερμηνεία μεμονωμένων προβλέψεων σε κάποιο βαθμό.

• Πλεονεκτήματα: Συχνά ο καλύτερα αποδοτικός αλγόριθμος για δομημένα/πίνακες δεδομένων. Μπορεί να ανιχνεύσει περίπλοκα πρότυπα και αλληλεπιδράσεις. Έχει πολλές ρυθμιστικές ρυθμίσεις (αριθμός δέντρων, βάθος δέντρων, ρυθμός μάθησης, όροι κανονικοποίησης) για να προσαρμόσει την πολυπλοκότητα του μοντέλου και να αποτρέψει την υπερβολική προσαρμογή. Οι σύγχρονες υλοποιήσεις είναι βελτιστοποιημένες για ταχύτητα (π.χ., το XGBoost χρησιμοποιεί πληροφορίες δεύτερης τάξης και αποδοτικές δομές δεδομένων). Τείνει να διαχειρίζεται καλύτερα τα ανισοκατανεμημένα δεδομένα όταν συνδυάζεται με κατάλληλες συναρτήσεις απώλειας ή προσαρμόζοντας τα βάρη δειγμάτων.

• Περιορισμοί: Πιο περίπλοκο να ρυθμιστεί από απλούστερα μοντέλα; η εκπαίδευση μπορεί να είναι αργή αν τα δέντρα είναι βαθιά ή ο αριθμός των δέντρων είναι μεγάλος (αν και συνήθως είναι πιο γρήγορη από την εκπαίδευση ενός συγκρίσιμου βαθιού νευρωνικού δικτύου στα ίδια δεδομένα). Το μοντέλο μπορεί να υπερπροσαρμοστεί αν δεν ρυθμιστεί (π.χ., πάρα πολλά βαθιά δέντρα με ανεπαρκή κανονικοποίηση). Λόγω πολλών υπερπαραμέτρων, η αποτελεσματική χρήση του gradient boosting μπορεί να απαιτεί περισσότερη εμπειρία ή πειραματισμό. Επίσης, όπως οι μέθοδοι βασισμένες σε δέντρα, δεν διαχειρίζεται εγγενώς πολύ αραιά υψηλής διάστασης δεδομένα όσο αποδοτικά όσο τα γραμμικά μοντέλα ή το 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
"""

Συνδυασμός Μοντέλων: Ensemble Learning και Stacking

Το ensemble learning είναι μια στρατηγική συνδυασμού πολλαπλών μοντέλων για τη βελτίωση της συνολικής απόδοσης. Ήδη είδαμε συγκεκριμένες μεθόδους ensemble: Random Forest (ένα σύνολο δέντρων μέσω bagging) και Gradient Boosting (ένα σύνολο δέντρων μέσω διαδοχικού boosting). Αλλά τα ensembles μπορούν να δημιουργηθούν και με άλλους τρόπους, όπως voting ensembles ή stacked generalization (stacking). Η κύρια ιδέα είναι ότι διαφορετικά μοντέλα μπορεί να συλλαμβάνουν διαφορετικά μοτίβα ή να έχουν διαφορετικές αδυναμίες. Συνδυάζοντάς τα, μπορούμε να αντισταθμίσουμε τα λάθη κάθε μοντέλου με τις δυνάμεις ενός άλλου.

• Voting Ensemble: Σε έναν απλό ψηφοφόρο ταξινομητή, εκπαιδεύουμε πολλαπλά διαφορετικά μοντέλα (ας πούμε, μια λογιστική παλινδρόμηση, ένα δέντρο απόφασης και ένα SVM) και τους κάνουμε να ψηφίσουν για την τελική πρόβλεψη (ψηφοφορία πλειοψηφίας για ταξινόμηση). Αν ζυγίσουμε τις ψήφους (π.χ., μεγαλύτερο βάρος σε πιο ακριβή μοντέλα), είναι ένα σύστημα ψηφοφορίας με βάρη. Αυτό συνήθως βελτιώνει την απόδοση όταν τα ατομικά μοντέλα είναι αρκετά καλά και ανεξάρτητα -- το ensemble μειώνει τον κίνδυνο λάθους ενός ατομικού μοντέλου, καθώς άλλα μπορεί να το διορθώσουν. Είναι σαν να έχουμε μια επιτροπή ειδικών αντί για μια μόνο γνώμη.

• Stacking (Stacked Ensemble): Το stacking προχωρά ένα βήμα παραπέρα. Αντί για μια απλή ψήφο, εκπαιδεύει ένα meta-model για να μάθει πώς να συνδυάζει καλύτερα τις προβλέψεις των βασικών μοντέλων. Για παράδειγμα, εκπαιδεύετε 3 διαφορετικούς ταξινομητές (βασικούς μαθητές), και στη συνέχεια τροφοδοτείτε τις εξόδους τους (ή πιθανότητες) ως χαρακτηριστικά σε έναν meta-classifier (συνήθως ένα απλό μοντέλο όπως η λογιστική παλινδρόμηση) που μαθαίνει τον βέλτιστο τρόπο να τα συνδυάζει. Το meta-model εκπαιδεύεται σε ένα σύνολο επικύρωσης ή μέσω διασταυρούμενης επικύρωσης για να αποφευχθεί η υπερπροσαρμογή. Το stacking μπορεί συχνά να υπερβεί την απλή ψηφοφορία μαθαίνοντας ποια μοντέλα να εμπιστεύονται περισσότερο σε ποιες περιστάσεις. Στην κυβερνοασφάλεια, ένα μοντέλο μπορεί να είναι καλύτερο στο να εντοπίζει σάρωση δικτύου ενώ ένα άλλο είναι καλύτερο στο να εντοπίζει beaconing κακόβουλου λογισμικού. Ένα μοντέλο stacking θα μπορούσε να μάθει να βασίζεται σε κάθε ένα κατάλληλα.

Τα ensembles, είτε μέσω ψηφοφορίας είτε stacking, τείνουν να ενισχύουν την ακρίβεια και την ανθεκτικότητα. Το μειονέκτημα είναι η αυξημένη πολυπλοκότητα και μερικές φορές η μειωμένη ερμηνευσιμότητα (αν και ορισμένες προσεγγίσεις ensemble όπως ο μέσος όρος δέντρων απόφασης μπορούν να παρέχουν ακόμα κάποια κατανόηση, π.χ., σημασία χαρακτηριστικών). Στην πράξη, αν οι επιχειρησιακοί περιορισμοί το επιτρέπουν, η χρήση ενός ensemble μπορεί να οδηγήσει σε υψηλότερους ρυθμούς ανίχνευσης. Πολλές νικηφόρες λύσεις σε προκλήσεις κυβερνοασφάλειας (και σε διαγωνισμούς Kaggle γενικά) χρησιμοποιούν τεχνικές ensemble για να αποσπάσουν την τελευταία σταγόνα απόδοσης.

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

Αναφορές

• 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