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 diesem Beispiel versucht das lineare Regressionsmodell, die Verbindungsdauer (duration) aus anderen Netzwerkmerkmalen vorherzusagen. Wir messen die Leistung mit dem mittleren quadratischen Fehler (MSE) und R². Ein R² nahe 1,0 würde darauf hindeuten, dass das Modell die meiste Varianz in der duration erklärt, während ein niedriges oder negatives R² auf eine schlechte Anpassung hinweist. (Seien Sie nicht überrascht, wenn das R² hier niedrig ist – die Vorhersage der duration könnte aus den gegebenen Merkmalen schwierig sein, und die lineare Regression erfasst möglicherweise die Muster nicht, wenn sie komplex sind.)

Wir verwenden einen Phishing Websites Dataset (aus dem UCI-Repository), der extrahierte Merkmale von Websites enthält (wie ob die URL eine IP-Adresse hat, das Alter der Domain, das Vorhandensein verdächtiger Elemente im HTML usw.) und ein Label, das angibt, ob die Seite Phishing oder legitim ist. Wir trainieren ein logistische Regressionsmodell, um Websites zu klassifizieren, und bewerten dann seine Genauigkeit, Präzision, Recall, F1-Score und ROC AUC auf einem Testsplit.

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 diesem Beispiel zur Phishing-Erkennung erzeugt die logistische Regression eine Wahrscheinlichkeit dafür, dass jede Website Phishing ist. Durch die Bewertung von Genauigkeit, Präzision, Recall und F1 erhalten wir ein Gefühl für die Leistung des Modells. Ein hoher Recall würde beispielsweise bedeuten, dass die meisten Phishing-Seiten erkannt werden (wichtig für die Sicherheit, um verpasste Angriffe zu minimieren), während eine hohe Präzision bedeutet, dass es wenige Fehlalarme gibt (wichtig, um Analystenmüdigkeit zu vermeiden). Der ROC AUC (Area Under the ROC Curve) bietet ein schwellenunabhängiges Maß für die Leistung (1.0 ist ideal, 0.5 ist nicht besser als Zufall). Die logistische Regression schneidet bei solchen Aufgaben oft gut ab, aber wenn die Entscheidungsgrenze zwischen Phishing- und legitimen Seiten komplex ist, könnten leistungsfähigere nichtlineare Modelle erforderlich sein.

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 diesem Entscheidungsbaumbeispiel haben wir die Baumtiefe auf 10 begrenzt, um extremes Overfitting zu vermeiden (der Parameter max_depth=10). Die Metriken zeigen, wie gut der Baum normalen Verkehr von Angriffstraffic unterscheidet. Ein hoher Recall würde bedeuten, dass die meisten Angriffe erfasst werden (wichtig für ein IDS), während eine hohe Präzision bedeutet, dass es wenige Fehlalarme gibt. Entscheidungsbäume erreichen oft eine anständige Genauigkeit bei strukturierten Daten, aber ein einzelner Baum könnte nicht die beste mögliche Leistung erreichen. Dennoch ist die Interpretierbarkeit des Modells ein großer Vorteil – wir könnten die Splits des Baums untersuchen, um zu sehen, welche Merkmale (z. B. service, src_bytes usw.) am einflussreichsten sind, um eine Verbindung als bösartig zu kennzeichnen.

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

Der Random Forest erzielt typischerweise starke Ergebnisse bei dieser Intrusion Detection-Aufgabe. Wir könnten eine Verbesserung in Metriken wie F1 oder AUC im Vergleich zum einzelnen Entscheidungsbaum beobachten, insbesondere in Bezug auf Recall oder Precision, abhängig von den Daten. Dies steht im Einklang mit dem Verständnis, dass "Random Forest (RF) ein Ensemble-Klassifikator ist und im Vergleich zu anderen traditionellen Klassifikatoren gut für die effektive Klassifizierung von Angriffen abschneidet.". In einem Kontext der Sicherheitsoperationen könnte ein Random Forest-Modell Angriffe zuverlässiger kennzeichnen und gleichzeitig Fehlalarme reduzieren, dank der Durchschnittsbildung vieler Entscheidungsregeln. Die Feature-Wichtigkeit aus dem Wald könnte uns sagen, welche Netzwerkmerkmale am aussagekräftigsten für Angriffe sind (z. B. bestimmte Netzwerkdienste oder ungewöhnliche Paketanzahlen).

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

Das SVM-Modell gibt Metriken aus, die wir mit der logistischen Regression bei derselben Aufgabe vergleichen können. Wir könnten feststellen, dass SVM eine hohe Genauigkeit und AUC erreicht, wenn die Daten gut durch die Merkmale getrennt sind. Umgekehrt, wenn der Datensatz viel Rauschen oder überlappende Klassen hatte, könnte SVM die logistische Regression nicht signifikant übertreffen. In der Praxis können SVMs einen Schub geben, wenn es komplexe, nicht-lineare Beziehungen zwischen Merkmalen und Klassen gibt – der RBF-Kernel kann gekrümmte Entscheidungsgrenzen erfassen, die die logistische Regression übersehen würde. Wie bei allen Modellen ist eine sorgfältige Abstimmung der C (Regularisierung) und der Kernel-Parameter (wie gamma für RBF) erforderlich, um Bias und Varianz auszubalancieren.

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

Dieser Code trainiert einen Naive Bayes-Klassifikator zur Erkennung von Angriffen. Naive Bayes berechnet Dinge wie P(service=http | Attack) und P(Service=http | Normal) basierend auf den Trainingsdaten, wobei Unabhängigkeit zwischen den Merkmalen angenommen wird. Anschließend verwendet es diese Wahrscheinlichkeiten, um neue Verbindungen als normal oder Angriff basierend auf den beobachteten Merkmalen zu klassifizieren. Die Leistung von NB auf NSL-KDD ist möglicherweise nicht so hoch wie bei fortgeschritteneren Modellen (da die Unabhängigkeit der Merkmale verletzt wird), aber sie ist oft anständig und bietet den Vorteil extremer Geschwindigkeit. In Szenarien wie der Echtzeit-E-Mail-Filterung oder der ersten Triage von URLs kann ein Naive Bayes-Modell offensichtlich bösartige Fälle schnell mit geringem Ressourcenverbrauch kennzeichnen.

Wir werden erneut NSL-KDD verwenden (binäre Klassifikation). Da k-NN rechenintensiv ist, verwenden wir eine Teilmenge der Trainingsdaten, um es in dieser Demonstration handhabbar zu halten. Wir wählen beispielsweise 20.000 Trainingsproben aus den insgesamt 125k aus und verwenden k=5 Nachbarn. Nach dem Training (das wirklich nur das Speichern der Daten ist) werden wir auf dem Testset evaluieren. Wir werden auch Merkmale für die Distanzberechnung skalieren, um sicherzustellen, dass kein einzelnes Merkmal aufgrund der Skalierung dominiert.

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

Das k-NN-Modell klassifiziert eine Verbindung, indem es die 5 nächsten Verbindungen im Trainingsdatensatz betrachtet. Wenn beispielsweise 4 dieser Nachbarn Angriffe (Anomalien) und 1 normal ist, wird die neue Verbindung als Angriff klassifiziert. Die Leistung könnte angemessen sein, ist jedoch oft nicht so hoch wie bei einem gut abgestimmten Random Forest oder SVM mit denselben Daten. k-NN kann jedoch manchmal glänzen, wenn die Klassendistributionen sehr unregelmäßig und komplex sind – effektiv durch die Verwendung einer speicherbasierten Suche. In der Cybersicherheit könnte k-NN (mit k=1 oder kleinem k) zur Erkennung bekannter Angriffsmuster durch Beispiele oder als Bestandteil komplexerer Systeme (z. B. zur Clusterbildung und anschließenden Klassifizierung basierend auf der Clusterzugehörigkeit) verwendet werden.

Gradient Boosting Machines (z. B. XGBoost)

Gradient Boosting Machines gehören zu den leistungsstärksten Algorithmen für strukturierte Daten. Gradient Boosting bezieht sich auf die Technik, ein Ensemble von schwachen Lernmodellen (häufig Entscheidungsbäume) sequenziell aufzubauen, wobei jedes neue Modell die Fehler des vorherigen Ensembles korrigiert. Im Gegensatz zu Bagging (Random Forests), das Bäume parallel erstellt und diese mittelt, baut Boosting Bäume einen nach dem anderen, wobei jeder mehr auf die Instanzen fokussiert, die vorherige Bäume falsch vorhergesagt haben.

Die beliebtesten Implementierungen in den letzten Jahren sind XGBoost, LightGBM und CatBoost, die alle Bibliotheken für gradient boosting decision trees (GBDT) sind. Sie waren in Wettbewerben und Anwendungen im maschinellen Lernen äußerst erfolgreich und erreichen oft state-of-the-art Leistung auf tabellarischen Datensätzen. In der Cybersicherheit haben Forscher und Praktiker gradient boosted trees für Aufgaben wie Malware-Erkennung (unter Verwendung von Merkmalen, die aus Dateien oder dem Laufverhalten extrahiert wurden) und Netzwerk-Eindringungserkennung verwendet. Ein Gradient-Boosting-Modell kann beispielsweise viele schwache Regeln (Bäume) wie "wenn viele SYN-Pakete und ungewöhnlicher Port -> wahrscheinlich Scan" in einen starken zusammengesetzten Detektor kombinieren, der viele subtile Muster berücksichtigt.

Warum sind Boosted Trees so effektiv? Jeder Baum in der Sequenz wird auf den Residualfehlern (Gradienten) der Vorhersagen des aktuellen Ensembles trainiert. Auf diese Weise "verstärkt" das Modell allmählich die Bereiche, in denen es schwach ist. Die Verwendung von Entscheidungsbäumen als Basislerner bedeutet, dass das endgültige Modell komplexe Interaktionen und nichtlineare Beziehungen erfassen kann. Außerdem hat Boosting von Natur aus eine Form der eingebauten Regularisierung: Durch das Hinzufügen vieler kleiner Bäume (und die Verwendung einer Lernrate zur Skalierung ihrer Beiträge) generalisiert es oft gut, ohne große Überanpassung, vorausgesetzt, es werden geeignete Parameter gewählt.

Wesentliche Merkmale von Gradient Boosting:

• Art des Problems: Primär Klassifikation und Regression. In der Sicherheit normalerweise Klassifikation (z. B. binäre Klassifizierung einer Verbindung oder Datei). Es behandelt binäre, mehrklassige (mit geeigneten Verlusten) und sogar Ranking-Probleme.

• Interpretierbarkeit: Niedrig bis mittel. Während ein einzelner Boosted Tree klein ist, kann ein vollständiges Modell Hunderte von Bäumen enthalten, was als Ganzes nicht menschlich interpretierbar ist. Wie bei Random Forest kann es jedoch Merkmalswichtigkeitswerte bereitstellen, und Werkzeuge wie SHAP (SHapley Additive exPlanations) können verwendet werden, um individuelle Vorhersagen bis zu einem gewissen Grad zu interpretieren.

• Vorteile: Oft der beste Algorithmus für strukturierte/tabellarische Daten. Kann komplexe Muster und Interaktionen erkennen. Hat viele Abstimmungsparameter (Anzahl der Bäume, Tiefe der Bäume, Lernrate, Regularisierungsparameter), um die Modellkomplexität anzupassen und Überanpassung zu verhindern. Moderne Implementierungen sind auf Geschwindigkeit optimiert (z. B. verwendet XGBoost Informationen über den zweiten Grad und effiziente Datenstrukturen). Tendenziell besser im Umgang mit unausgewogenen Daten, wenn sie mit geeigneten Verlustfunktionen kombiniert oder die Stichprobengewichte angepasst werden.

• Einschränkungen: Komplexer zu optimieren als einfachere Modelle; das Training kann langsam sein, wenn die Bäume tief sind oder die Anzahl der Bäume groß ist (obwohl es in der Regel immer noch schneller ist als das Training eines vergleichbaren tiefen neuronalen Netzwerks mit denselben Daten). Das Modell kann überanpassen, wenn es nicht abgestimmt ist (z. B. zu viele tiefe Bäume mit unzureichender Regularisierung). Aufgrund der vielen Hyperparameter kann die effektive Nutzung von Gradient Boosting mehr Fachwissen oder Experimentieren erfordern. Außerdem behandelt es, wie baumbasierte Methoden, sehr spärliche hochdimensionale Daten nicht so effizient wie lineare Modelle oder Naive Bayes (obwohl es immer noch angewendet werden kann, z. B. in der Textklassifizierung, aber möglicherweise nicht die erste Wahl ohne Merkmalsengineering ist).

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

Modelle kombinieren: Ensemble-Lernen und Stacking

Ensemble-Lernen ist eine Strategie zur Kombination mehrerer Modelle, um die Gesamtleistung zu verbessern. Wir haben bereits spezifische Ensemble-Methoden gesehen: Random Forest (ein Ensemble von Bäumen über Bagging) und Gradient Boosting (ein Ensemble von Bäumen über sequenzielles Boosting). Aber Ensembles können auch auf andere Weise erstellt werden, wie z.B. Voting-Ensembles oder Stacked Generalization (Stacking). Die Hauptidee ist, dass verschiedene Modelle unterschiedliche Muster erfassen oder unterschiedliche Schwächen haben können; durch ihre Kombination können wir die Fehler jedes Modells mit den Stärken eines anderen ausgleichen.

• Voting Ensemble: In einem einfachen Abstimmungs-Klassifikator trainieren wir mehrere unterschiedliche Modelle (sagen wir, eine logistische Regression, einen Entscheidungsbaum und ein SVM) und lassen sie über die endgültige Vorhersage abstimmen (Mehrheitsabstimmung für die Klassifikation). Wenn wir die Stimmen gewichten (z.B. höhere Gewichtung für genauere Modelle), handelt es sich um ein gewichtetes Abstimmungsschema. Dies verbessert typischerweise die Leistung, wenn die einzelnen Modelle vernünftig gut und unabhängig sind -- das Ensemble verringert das Risiko eines Fehlers eines einzelnen Modells, da andere es möglicherweise korrigieren. Es ist wie ein Gremium von Experten anstelle einer einzelnen Meinung.

• Stacking (Stacked Ensemble): Stacking geht einen Schritt weiter. Anstatt einfach abzustimmen, trainiert es ein Meta-Modell, um zu lernen, wie man die Vorhersagen der Basis-Modelle am besten kombiniert. Zum Beispiel trainierst du 3 verschiedene Klassifikatoren (Basislerner) und speist deren Ausgaben (oder Wahrscheinlichkeiten) als Merkmale in einen Meta-Klassifikator (oft ein einfaches Modell wie logistische Regression) ein, der lernt, wie man sie optimal mischt. Das Meta-Modell wird auf einem Validierungsdatensatz oder durch Kreuzvalidierung trainiert, um Overfitting zu vermeiden. Stacking kann oft einfacher Abstimmungen übertreffen, indem es lernt, welchen Modellen man in welchen Umständen mehr vertrauen kann. In der Cybersicherheit könnte ein Modell besser darin sein, Netzwerkscans zu erkennen, während ein anderes besser darin ist, Malware-Beaconing zu erkennen; ein Stacking-Modell könnte lernen, sich jeweils angemessen auf jedes zu verlassen.

Ensembles, ob durch Abstimmung oder Stacking, neigen dazu, die Genauigkeit und Robustheit zu steigern. Der Nachteil ist eine erhöhte Komplexität und manchmal reduzierte Interpretierbarkeit (obwohl einige Ensemble-Ansätze wie der Durchschnitt von Entscheidungsbäumen immer noch einige Einblicke bieten können, z.B. die Wichtigkeit von Merkmalen). In der Praxis kann die Verwendung eines Ensembles, wenn operationale Einschränkungen es zulassen, zu höheren Erkennungsraten führen. Viele erfolgreiche Lösungen in Cybersicherheitsherausforderungen (und Kaggle-Wettbewerben im Allgemeinen) verwenden Ensemble-Techniken, um das letzte bisschen Leistung herauszuholen.

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

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

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

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

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

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

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

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

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

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

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

References

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