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

Dans cet exemple, le modèle de régression linéaire essaie de prédire la duration de connexion à partir d'autres caractéristiques du réseau. Nous mesurons la performance avec l'erreur quadratique moyenne (MSE) et R². Un R² proche de 1,0 indiquerait que le modèle explique la plupart de la variance dans la duration, tandis qu'un R² faible ou négatif indique un mauvais ajustement. (Ne soyez pas surpris si le R² est faible ici -- prédire la duration peut être difficile à partir des caractéristiques données, et la régression linéaire peut ne pas capturer les motifs s'ils sont complexes.)

Nous utiliserons un jeu de données de sites Web de phishing (provenant du dépôt UCI) qui contient des caractéristiques extraites de sites Web (comme si l'URL a une adresse IP, l'âge du domaine, la présence d'éléments suspects dans le HTML, etc.) et une étiquette indiquant si le site est un phishing ou légitime. Nous entraînons un modèle de régression logistique pour classer les sites Web, puis évaluons sa précision, son rappel, son score F1 et son ROC AUC sur un échantillon de 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
"""

Dans cet exemple de détection de phishing, la régression logistique produit une probabilité pour chaque site web d'être un phishing. En évaluant la précision, le rappel et le F1, nous avons une idée de la performance du modèle. Par exemple, un rappel élevé signifierait qu'il attrape la plupart des sites de phishing (important pour la sécurité afin de minimiser les attaques manquées), tandis qu'une haute précision signifie qu'il a peu de fausses alertes (important pour éviter la fatigue des analystes). L'AUC ROC (Area Under the ROC Curve) donne une mesure de performance indépendante du seuil (1.0 est idéal, 0.5 n'est pas mieux que le hasard). La régression logistique fonctionne souvent bien sur de telles tâches, mais si la frontière de décision entre les sites de phishing et légitimes est complexe, des modèles non linéaires plus puissants pourraient être nécessaires.

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

Dans cet exemple d'arbre de décision, nous avons limité la profondeur de l'arbre à 10 pour éviter un surajustement extrême (le paramètre max_depth=10). Les métriques montrent à quel point l'arbre distingue le trafic normal du trafic d'attaque. Un rappel élevé signifierait qu'il attrape la plupart des attaques (important pour un IDS), tandis qu'une haute précision signifie peu de fausses alertes. Les arbres de décision atteignent souvent une précision décente sur des données structurées, mais un seul arbre pourrait ne pas atteindre la meilleure performance possible. Néanmoins, l'interprétabilité du modèle est un grand avantage -- nous pourrions examiner les divisions de l'arbre pour voir, par exemple, quelles caractéristiques (par ex., service, src_bytes, etc.) sont les plus influentes pour signaler une connexion comme malveillante.

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

Le random forest atteint généralement de bons résultats sur cette tâche de détection d'intrusion. Nous pourrions observer une amélioration des métriques comme F1 ou AUC par rapport à l'arbre de décision unique, en particulier en ce qui concerne le rappel ou la précision, selon les données. Cela s'aligne avec la compréhension que "Random Forest (RF) est un classificateur d'ensemble et fonctionne bien par rapport à d'autres classificateurs traditionnels pour une classification efficace des attaques.". Dans un contexte d'opérations de sécurité, un modèle de random forest pourrait signaler les attaques de manière plus fiable tout en réduisant les fausses alertes, grâce à l'averaging de nombreuses règles de décision. L'importance des caractéristiques du forest pourrait nous indiquer quelles caractéristiques réseau sont les plus indicatives des attaques (par exemple, certains services réseau ou des comptes inhabituels de paquets).

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

Le modèle SVM produira des métriques que nous pouvons comparer à la régression logistique sur la même tâche. Nous pourrions constater que SVM atteint une haute précision et AUC si les données sont bien séparées par les caractéristiques. En revanche, si l'ensemble de données contenait beaucoup de bruit ou des classes qui se chevauchent, SVM pourrait ne pas surpasser significativement la régression logistique. En pratique, les SVM peuvent donner un coup de pouce lorsqu'il existe des relations complexes et non linéaires entre les caractéristiques et la classe -- le noyau RBF peut capturer des frontières de décision courbées que la régression logistique manquerait. Comme pour tous les modèles, un réglage minutieux des paramètres C (régularisation) et du noyau (comme gamma pour RBF) est nécessaire pour équilibrer biais et variance.

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

Ce code entraîne un classificateur Naive Bayes pour détecter des attaques. Naive Bayes va calculer des choses comme P(service=http | Attack) et P(Service=http | Normal) en fonction des données d'entraînement, en supposant l'indépendance entre les caractéristiques. Il utilisera ensuite ces probabilités pour classer de nouvelles connexions comme normales ou attaques en fonction des caractéristiques observées. La performance de NB sur NSL-KDD peut ne pas être aussi élevée que celle de modèles plus avancés (puisque l'indépendance des caractéristiques est violée), mais elle est souvent décente et présente l'avantage d'une vitesse extrême. Dans des scénarios comme le filtrage d'e-mails en temps réel ou le tri initial des URL, un modèle Naive Bayes peut rapidement signaler des cas manifestement malveillants avec une faible utilisation des ressources.

Nous allons à nouveau utiliser NSL-KDD (classification binaire). Comme k-NN est lourd en calcul, nous utiliserons un sous-ensemble des données d'entraînement pour le rendre gérable dans cette démonstration. Nous allons choisir, disons, 20 000 échantillons d'entraînement sur les 125k complets, et utiliser k=5 voisins. Après l'entraînement (qui consiste vraiment juste à stocker les données), nous évaluerons sur l'ensemble de test. Nous allons également mettre à l'échelle les caractéristiques pour le calcul des distances afin de garantir qu'aucune caractéristique unique ne domine en raison de l'échelle.

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

Le modèle k-NN classera une connexion en examinant les 5 connexions les plus proches dans le sous-ensemble de l'ensemble d'entraînement. Si, par exemple, 4 de ces voisins sont des attaques (anomalies) et 1 est normal, la nouvelle connexion sera classée comme une attaque. La performance peut être raisonnable, bien que souvent pas aussi élevée qu'un Random Forest ou SVM bien réglé sur les mêmes données. Cependant, k-NN peut parfois briller lorsque les distributions de classes sont très irrégulières et complexes -- utilisant effectivement une recherche basée sur la mémoire. En cybersécurité, k-NN (avec k=1 ou un petit k) pourrait être utilisé pour la détection de modèles d'attaque connus par exemple, ou comme un composant dans des systèmes plus complexes (par exemple, pour le clustering et ensuite la classification en fonction de l'appartenance au cluster).

Machines à Gradient Boosting (par exemple, XGBoost)

Les machines à gradient boosting sont parmi les algorithmes les plus puissants pour les données structurées. Le gradient boosting fait référence à la technique de construction d'un ensemble de faibles apprenants (souvent des arbres de décision) de manière séquentielle, où chaque nouveau modèle corrige les erreurs de l'ensemble précédent. Contrairement au bagging (Random Forests) qui construit des arbres en parallèle et les moyenne, le boosting construit des arbres un par un, chacun se concentrant davantage sur les instances que les arbres précédents ont mal prédites.

Les implémentations les plus populaires ces dernières années sont XGBoost, LightGBM et CatBoost, qui sont toutes des bibliothèques d'arbres de décision à gradient boosting (GBDT). Elles ont été extrêmement réussies dans les compétitions et applications d'apprentissage automatique, atteignant souvent des performances de pointe sur des ensembles de données tabulaires. En cybersécurité, les chercheurs et praticiens ont utilisé des arbres à gradient boosting pour des tâches telles que la détection de logiciels malveillants (en utilisant des caractéristiques extraites de fichiers ou du comportement d'exécution) et la détection d'intrusions réseau. Par exemple, un modèle de gradient boosting peut combiner de nombreuses règles faibles (arbres) telles que "si de nombreux paquets SYN et un port inhabituel -> probablement un scan" en un détecteur composite fort qui prend en compte de nombreux motifs subtils.

Pourquoi les arbres boostés sont-ils si efficaces ? Chaque arbre de la séquence est entraîné sur les erreurs résiduelles (gradients) des prédictions de l'ensemble actuel. De cette manière, le modèle "booste" progressivement les zones où il est faible. L'utilisation d'arbres de décision comme apprenants de base signifie que le modèle final peut capturer des interactions complexes et des relations non linéaires. De plus, le boosting a intrinsèquement une forme de régularisation intégrée : en ajoutant de nombreux petits arbres (et en utilisant un taux d'apprentissage pour ajuster leurs contributions), il généralise souvent bien sans surajustement important, à condition que des paramètres appropriés soient choisis.

Caractéristiques clés du Gradient Boosting :

• Type de problème : Principalement classification et régression. En sécurité, généralement classification (par exemple, classifier une connexion ou un fichier de manière binaire). Il gère les problèmes binaires, multi-classes (avec perte appropriée), et même les problèmes de classement.

• Interprétabilité : Faible à moyenne. Bien qu'un seul arbre boosté soit petit, un modèle complet peut avoir des centaines d'arbres, ce qui n'est pas interprétable par l'homme dans son ensemble. Cependant, comme Random Forest, il peut fournir des scores d'importance des caractéristiques, et des outils comme SHAP (SHapley Additive exPlanations) peuvent être utilisés pour interpréter les prédictions individuelles dans une certaine mesure.

• Avantages : Souvent l'algorithme le plus performant pour les données structurées/tabulaires. Peut détecter des motifs et des interactions complexes. Dispose de nombreux réglages (nombre d'arbres, profondeur des arbres, taux d'apprentissage, termes de régularisation) pour adapter la complexité du modèle et prévenir le surajustement. Les implémentations modernes sont optimisées pour la vitesse (par exemple, XGBoost utilise des informations de gradient d'ordre supérieur et des structures de données efficaces). Tends à mieux gérer les données déséquilibrées lorsqu'il est combiné avec des fonctions de perte appropriées ou en ajustant les poids d'échantillon.

• Limitations : Plus complexe à régler que des modèles plus simples ; l'entraînement peut être lent si les arbres sont profonds ou si le nombre d'arbres est important (bien que généralement plus rapide que l'entraînement d'un réseau de neurones profond comparable sur les mêmes données). Le modèle peut surajuster s'il n'est pas réglé (par exemple, trop d'arbres profonds avec une régularisation insuffisante). En raison de nombreux hyperparamètres, utiliser le gradient boosting efficacement peut nécessiter plus d'expertise ou d'expérimentation. De plus, comme les méthodes basées sur les arbres, il ne gère pas intrinsèquement les données très éparses et de haute dimension aussi efficacement que les modèles linéaires ou Naive Bayes (bien qu'il puisse encore être appliqué, par exemple, dans la classification de texte, mais pourrait ne pas être le premier choix sans ingénierie des caractéristiques).

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

Combinaison de Modèles : Apprentissage par Ensemble et Stacking

L'apprentissage par ensemble est une stratégie de combinaison de plusieurs modèles pour améliorer la performance globale. Nous avons déjà vu des méthodes d'ensemble spécifiques : Random Forest (un ensemble d'arbres via le bagging) et Gradient Boosting (un ensemble d'arbres via le boosting séquentiel). Mais des ensembles peuvent également être créés de d'autres manières, comme les ensembles de vote ou la généralisation empilée (stacking). L'idée principale est que différents modèles peuvent capturer différents motifs ou avoir différentes faiblesses ; en les combinant, nous pouvons compenser les erreurs de chaque modèle par les forces des autres.

• Ensemble de Vote : Dans un classificateur de vote simple, nous entraînons plusieurs modèles divers (par exemple, une régression logistique, un arbre de décision et un SVM) et les faisons voter sur la prédiction finale (vote majoritaire pour la classification). Si nous pondérons les votes (par exemple, un poids plus élevé pour les modèles plus précis), c'est un schéma de vote pondéré. Cela améliore généralement la performance lorsque les modèles individuels sont raisonnablement bons et indépendants -- l'ensemble réduit le risque d'erreur d'un modèle individuel puisque d'autres peuvent la corriger. C'est comme avoir un panel d'experts plutôt qu'une seule opinion.

• Stacking (Ensemble Empilé) : Le stacking va un peu plus loin. Au lieu d'un simple vote, il entraîne un méta-modèle pour apprendre comment combiner au mieux les prédictions des modèles de base. Par exemple, vous entraînez 3 classificateurs différents (apprenants de base), puis vous alimentez leurs sorties (ou probabilités) comme caractéristiques dans un méta-classificateur (souvent un modèle simple comme la régression logistique) qui apprend la manière optimale de les mélanger. Le méta-modèle est entraîné sur un ensemble de validation ou via validation croisée pour éviter le surajustement. Le stacking peut souvent surpasser le vote simple en apprenant quels modèles faire confiance dans quelles circonstances. En cybersécurité, un modèle pourrait être meilleur pour attraper les analyses de réseau tandis qu'un autre est meilleur pour attraper les signaux de malware ; un modèle de stacking pourrait apprendre à s'appuyer sur chacun de manière appropriée.

Les ensembles, que ce soit par vote ou stacking, tendent à augmenter la précision et la robustesse. L'inconvénient est une complexité accrue et parfois une interprétabilité réduite (bien que certaines approches d'ensemble comme la moyenne des arbres de décision puissent encore fournir un certain aperçu, par exemple, l'importance des caractéristiques). En pratique, si les contraintes opérationnelles le permettent, utiliser un ensemble peut conduire à des taux de détection plus élevés. De nombreuses solutions gagnantes dans les défis de cybersécurité (et les compétitions Kaggle en général) utilisent des techniques d'ensemble pour tirer le dernier bit de performance.

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

Références

• 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