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

In questo esempio, il modello di regressione lineare cerca di prevedere la durata della connessione da altre caratteristiche di rete. Misuriamo le prestazioni con l'Errore Quadratico Medio (MSE) e R². Un R² vicino a 1.0 indicherebbe che il modello spiega la maggior parte della varianza in durata, mentre un R² basso o negativo indica un cattivo adattamento. (Non sorprenderti se l'R² è basso qui -- prevedere la durata potrebbe essere difficile dalle caratteristiche date, e la regressione lineare potrebbe non catturare i modelli se sono complessi.)

Utilizzeremo un Dataset di Siti Web di Phishing (dal repository UCI) che contiene caratteristiche estratte di siti web (come se l'URL ha un indirizzo IP, l'età del dominio, presenza di elementi sospetti in HTML, ecc.) e un'etichetta che indica se il sito è phishing o legittimo. Addestriamo un modello di regressione logistica per classificare i siti web e poi valutiamo la sua accuratezza, precisione, richiamo, F1-score e ROC AUC su un campione di test.

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

In questo esempio di rilevamento del phishing, la regressione logistica produce una probabilità per ciascun sito web di essere phishing. Valutando l'accuratezza, la precisione, il richiamo e l'F1, otteniamo un'idea delle prestazioni del modello. Ad esempio, un alto richiamo significherebbe che cattura la maggior parte dei siti di phishing (importante per la sicurezza per ridurre al minimo gli attacchi mancati), mentre un'alta precisione significa che ha pochi falsi allarmi (importante per evitare l'affaticamento degli analisti). L'ROC AUC (Area sotto la curva ROC) fornisce una misura delle prestazioni indipendente dalla soglia (1.0 è ideale, 0.5 non è meglio del caso). La regressione logistica spesso si comporta bene in tali compiti, ma se il confine decisionale tra siti di phishing e legittimi è complesso, potrebbero essere necessari modelli non lineari più potenti.

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

In questo esempio di albero decisionale, abbiamo limitato la profondità dell'albero a 10 per evitare un estremo overfitting (il parametro max_depth=10). Le metriche mostrano quanto bene l'albero distingue il traffico normale da quello di attacco. Un alto richiamo significherebbe che cattura la maggior parte degli attacchi (importante per un IDS), mentre un'alta precisione significa pochi falsi allarmi. Gli alberi decisionali raggiungono spesso una precisione decente su dati strutturati, ma un singolo albero potrebbe non raggiungere le migliori prestazioni possibili. Tuttavia, l'interpretabilità del modello è un grande vantaggio: potremmo esaminare le suddivisioni dell'albero per vedere, ad esempio, quali caratteristiche (ad es., service, src_bytes, ecc.) sono più influenti nel segnalare una connessione come malevola.

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

Il random forest raggiunge tipicamente risultati solidi in questo compito di rilevamento delle intrusioni. Potremmo osservare un miglioramento in metriche come F1 o AUC rispetto all'albero decisionale singolo, specialmente in richiamo o precisione, a seconda dei dati. Questo è in linea con la comprensione che "Random Forest (RF) è un classificatore ensemble e si comporta bene rispetto ad altri classificatori tradizionali per una classificazione efficace degli attacchi.". In un contesto di operazioni di sicurezza, un modello di random forest potrebbe segnalare attacchi in modo più affidabile riducendo i falsi allarmi, grazie alla media di molte regole decisionali. L'importanza delle caratteristiche dal forest potrebbe dirci quali caratteristiche di rete sono più indicative di attacchi (ad esempio, determinati servizi di rete o conteggi insoliti di pacchetti).

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

Il modello SVM restituirà metriche che possiamo confrontare con la regressione logistica sullo stesso compito. Potremmo scoprire che SVM raggiunge un'alta accuratezza e AUC se i dati sono ben separati dalle caratteristiche. D'altra parte, se il dataset avesse molto rumore o classi sovrapposte, SVM potrebbe non superare significativamente la regressione logistica. Nella pratica, gli SVM possono dare un impulso quando ci sono relazioni complesse e non lineari tra le caratteristiche e la classe -- il kernel RBF può catturare confini decisionali curvi che la regressione logistica perderebbe. Come per tutti i modelli, è necessaria una sintonizzazione attenta dei parametri C (regolarizzazione) e del kernel (come gamma per RBF) per bilanciare bias e varianza.

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

Questo codice addestra un classificatore Naive Bayes per rilevare attacchi. Naive Bayes calcolerà cose come P(service=http | Attack) e P(Service=http | Normal) basandosi sui dati di addestramento, assumendo l'indipendenza tra le caratteristiche. Utilizzerà quindi queste probabilità per classificare nuove connessioni come normali o attacchi in base alle caratteristiche osservate. Le prestazioni di NB su NSL-KDD potrebbero non essere elevate come modelli più avanzati (poiché l'indipendenza delle caratteristiche è violata), ma sono spesso decenti e offrono il vantaggio di una velocità estrema. In scenari come il filtraggio delle email in tempo reale o la triage iniziale degli URL, un modello Naive Bayes può rapidamente segnalare casi ovviamente malevoli con un basso utilizzo delle risorse.

Utilizzeremo di nuovo NSL-KDD (classificazione binaria). Poiché k-NN è computazionalmente pesante, utilizzeremo un sottoinsieme dei dati di addestramento per mantenerlo gestibile in questa dimostrazione. Sceglieremo, ad esempio, 20.000 campioni di addestramento su un totale di 125k, e utilizzeremo k=5 vicini. Dopo l'addestramento (in realtà solo memorizzando i dati), valuteremo sul set di test. Scala anche le caratteristiche per il calcolo delle distanze per garantire che nessuna singola caratteristica domini a causa della scala.

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

Il modello k-NN classificherà una connessione esaminando le 5 connessioni più vicine nel sottoinsieme del set di addestramento. Se, ad esempio, 4 di quei vicini sono attacchi (anomalie) e 1 è normale, la nuova connessione sarà classificata come un attacco. Le prestazioni potrebbero essere ragionevoli, anche se spesso non sono elevate come quelle di un Random Forest o SVM ben sintonizzati sugli stessi dati. Tuttavia, k-NN può a volte brillare quando le distribuzioni delle classi sono molto irregolari e complesse, utilizzando efficacemente una ricerca basata sulla memoria. In cybersecurity, k-NN (con k=1 o k piccolo) potrebbe essere utilizzato per la rilevazione di modelli di attacco noti per esempio, o come componente in sistemi più complessi (ad es., per il clustering e poi la classificazione basata sull'appartenenza al cluster).

Gradient Boosting Machines (ad es., XGBoost)

Le Gradient Boosting Machines sono tra gli algoritmi più potenti per i dati strutturati. Gradient boosting si riferisce alla tecnica di costruire un insieme di apprendisti deboli (spesso alberi decisionali) in modo sequenziale, dove ogni nuovo modello corregge gli errori dell'insieme precedente. A differenza del bagging (Random Forests) che costruisce alberi in parallelo e li media, il boosting costruisce alberi uno per uno, ciascuno concentrandosi di più sulle istanze che gli alberi precedenti hanno predetto male.

Le implementazioni più popolari negli ultimi anni sono XGBoost, LightGBM e CatBoost, tutte librerie di gradient boosting decision tree (GBDT). Hanno avuto un enorme successo nelle competizioni e applicazioni di machine learning, spesso raggiungendo prestazioni all'avanguardia su dataset tabulari. In cybersecurity, ricercatori e professionisti hanno utilizzato alberi potenziati per compiti come rilevamento di malware (utilizzando caratteristiche estratte da file o comportamento in tempo reale) e rilevamento di intrusioni di rete. Ad esempio, un modello di gradient boosting può combinare molte regole deboli (alberi) come "se molti pacchetti SYN e porta insolita -> probabile scansione" in un forte rilevatore composito che tiene conto di molti schemi sottili.

Perché gli alberi potenziati sono così efficaci? Ogni albero nella sequenza è addestrato sugli errori residui (gradienti) delle previsioni dell'insieme attuale. In questo modo, il modello gradualmente "potenzia" le aree in cui è debole. L'uso di alberi decisionali come apprendisti di base significa che il modello finale può catturare interazioni complesse e relazioni non lineari. Inoltre, il boosting ha intrinsecamente una forma di regolarizzazione incorporata: aggiungendo molti piccoli alberi (e utilizzando un tasso di apprendimento per scalare i loro contributi), spesso generalizza bene senza un enorme overfitting, a condizione che vengano scelti parametri appropriati.

Caratteristiche chiave del Gradient Boosting:

• Tipo di Problema: Principalmente classificazione e regressione. In sicurezza, solitamente classificazione (ad es., classificare binariamente una connessione o un file). Gestisce problemi binari, multi-classe (con perdita appropriata) e persino di ranking.

• Interpretabilità: Bassa a media. Mentre un singolo albero potenziato è piccolo, un modello completo potrebbe avere centinaia di alberi, il che non è interpretabile per l'uomo nel suo insieme. Tuttavia, come Random Forest, può fornire punteggi di importanza delle caratteristiche, e strumenti come SHAP (SHapley Additive exPlanations) possono essere utilizzati per interpretare le singole previsioni in una certa misura.

• Vantaggi: Spesso l'algoritmo con le migliori prestazioni per dati strutturati/tabulari. Può rilevare schemi e interazioni complesse. Ha molti parametri di regolazione (numero di alberi, profondità degli alberi, tasso di apprendimento, termini di regolarizzazione) per adattare la complessità del modello e prevenire l'overfitting. Le implementazioni moderne sono ottimizzate per la velocità (ad es., XGBoost utilizza informazioni sul gradiente di secondo ordine e strutture dati efficienti). Tende a gestire meglio i dati sbilanciati quando combinato con funzioni di perdita appropriate o regolando i pesi dei campioni.

• Limitazioni: Più complesso da sintonizzare rispetto a modelli più semplici; l'addestramento può essere lento se gli alberi sono profondi o il numero di alberi è grande (anche se di solito è comunque più veloce rispetto all'addestramento di una rete neurale profonda comparabile sugli stessi dati). Il modello può overfittare se non sintonizzato (ad es., troppi alberi profondi con regolarizzazione insufficiente). A causa di molti iperparametri, utilizzare il gradient boosting in modo efficace può richiedere più esperienza o sperimentazione. Inoltre, come i metodi basati su alberi, non gestisce intrinsecamente i dati ad alta dimensione molto sparsi in modo efficiente come i modelli lineari o Naive Bayes (anche se può comunque essere applicato, ad es., nella classificazione del testo, ma potrebbe non essere la prima scelta senza ingegneria delle caratteristiche).

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

Combinare Modelli: Apprendimento Ensemble e Stacking

L'apprendimento ensemble è una strategia di combinare più modelli per migliorare le prestazioni complessive. Abbiamo già visto metodi ensemble specifici: Random Forest (un ensemble di alberi tramite bagging) e Gradient Boosting (un ensemble di alberi tramite boosting sequenziale). Ma gli ensemble possono essere creati anche in altri modi, come voting ensembles o stacked generalization (stacking). L'idea principale è che modelli diversi possono catturare schemi diversi o avere debolezze diverse; combinandoli, possiamo compensare gli errori di ciascun modello con i punti di forza di un altro.

• Voting Ensemble: In un semplice classificatore di voto, alleniamo più modelli diversi (ad esempio, una regressione logistica, un albero decisionale e un SVM) e li facciamo votare sulla previsione finale (voto di maggioranza per la classificazione). Se pesiamo i voti (ad esempio, peso maggiore ai modelli più accurati), si tratta di uno schema di voto pesato. Questo migliora tipicamente le prestazioni quando i modelli individuali sono ragionevolmente buoni e indipendenti -- l'ensemble riduce il rischio di errore di un modello individuale poiché altri possono correggerlo. È come avere un pannello di esperti piuttosto che un'unica opinione.

• Stacking (Stacked Ensemble): Lo stacking va un passo oltre. Invece di un semplice voto, allena un meta-modello per imparare come combinare al meglio le previsioni dei modelli di base. Ad esempio, alleni 3 classificatori diversi (base learners), quindi fornisci le loro uscite (o probabilità) come caratteristiche a un meta-classificatore (spesso un modello semplice come la regressione logistica) che impara il modo ottimale per mescolarli. Il meta-modello è addestrato su un set di validazione o tramite cross-validation per evitare l'overfitting. Lo stacking può spesso superare il semplice voto imparando quali modelli fidarsi di più in quali circostanze. In cybersecurity, un modello potrebbe essere migliore nel catturare scansioni di rete mentre un altro è migliore nel catturare beaconing di malware; un modello di stacking potrebbe imparare a fare affidamento su ciascuno in modo appropriato.

Gli ensemble, sia tramite voto che stacking, tendono a aumentare l'accuratezza e la robustezza. Lo svantaggio è l'aumento della complessità e talvolta la riduzione dell'interpretabilità (anche se alcuni approcci ensemble come la media degli alberi decisionali possono ancora fornire alcune intuizioni, ad esempio, l'importanza delle caratteristiche). In pratica, se le restrizioni operative lo consentono, utilizzare un ensemble può portare a tassi di rilevamento più elevati. Molte soluzioni vincenti nelle sfide di cybersecurity (e nelle competizioni Kaggle in generale) utilizzano tecniche ensemble per spremere l'ultimo bit di prestazioni.

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

Riferimenti

• 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