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

U ovom primeru, model linearne regresije pokušava da predvidi trajanje veze na osnovu drugih mrežnih karakteristika. Merenje performansi vršimo pomoću Srednje Kvadratne Greške (MSE) i R². R² blizu 1.0 bi ukazivao na to da model objašnjava većinu varijanse u trajanju, dok nizak ili negativan R² ukazuje na loše prilagođavanje. (Ne iznenađujte se ako je R² ovde nizak -- predviđanje trajanja može biti teško na osnovu datih karakteristika, a linearna regresija možda neće uhvatiti obrasce ako su složeni.)

Koristićemo Dataset veb sajtova za phishing (iz UCI repozitorijuma) koji sadrži ekstraktovane karakteristike veb sajtova (kao što su da li URL ima IP adresu, starost domena, prisustvo sumnjivih elemenata u HTML-u, itd.) i oznaku koja ukazuje da li je sajt phishing ili legitimni. Obučavamo model logističke regresije da klasifikuje veb sajtove i zatim procenjujemo njegovu tačnost, preciznost, odziv, F1-score i ROC AUC na testnom skupu.

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

U ovom primeru detekcije phishing-a, logistička regresija proizvodi verovatnoću za svaku veb stranicu da bude phishing. Evaluacijom tačnosti, preciznosti, odziva i F1, dobijamo osećaj o performansama modela. Na primer, visok odziv bi značio da hvata većinu phishing sajtova (važan za bezbednost kako bi se minimizirali propušteni napadi), dok visoka preciznost znači da ima malo lažnih alarma (važan za izbegavanje umora analitičara). ROC AUC (Površina ispod ROC krive) daje meru performansi koja nije zavisna od praga (1.0 je idealno, 0.5 nije bolje od slučajnosti). Logistička regresija često dobro funkcioniše na takvim zadacima, ali ako je granica odluke između phishing i legitimnih sajtova složena, možda će biti potrebni moćniji nelinearni modeli.

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

U ovom primeru odlučivanja, ograničili smo dubinu stabla na 10 kako bismo izbegli ekstremno prekomerno prilagođavanje (parametar max_depth=10). Metrički podaci pokazuju koliko dobro stablo razlikuje normalan i napadni saobraćaj. Visok odziv bi značio da hvata većinu napada (važan za IDS), dok visoka preciznost znači malo lažnih alarma. Odlučujuća stabla često postižu pristojnu tačnost na strukturiranim podacima, ali jedno stablo možda neće dostići najbolju moguću performansu. Ipak, interpretabilnost modela je velika prednost -- mogli bismo ispitati delove stabla da vidimo, na primer, koje karakteristike (npr., service, src_bytes, itd.) su najuticajnije u označavanju veze kao maliciozne.

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

Random forest obično postiže snažne rezultate na ovom zadatku detekcije upada. Možda ćemo primetiti poboljšanje u metrima kao što su F1 ili AUC u poređenju sa pojedinačnim odlučujućim stablom, posebno u preciznosti ili podsećanju, u zavisnosti od podataka. To je u skladu sa razumevanjem da "Random Forest (RF) je ansambl klasifikator i dobro se ponaša u poređenju sa drugim tradicionalnim klasifikatorima za efikasnu klasifikaciju napada.". U kontekstu bezbednosnih operacija, model random forest može pouzdanije označiti napade dok smanjuje lažne alarme, zahvaljujući proseku mnogih odlučujućih pravila. Važnost karakteristika iz šume može nam reći koje mrežne karakteristike su najindikativnije za napade (npr. određene mrežne usluge ili neobični brojevi paketa).

import pandas as pd
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import (accuracy_score, precision_score,
recall_score, f1_score, roc_auc_score)

# ─────────────────────────────────────────────────────────────
# 1️⃣  LOAD DATASET   (OpenML id 4534: “PhishingWebsites”)
#     • as_frame=True  ➜  returns a pandas DataFrame
# ─────────────────────────────────────────────────────────────
data = fetch_openml(data_id=4534, as_frame=True)   # or data_name="PhishingWebsites"
df   = data.frame
print(df.head())          # quick sanity‑check

# ─────────────────────────────────────────────────────────────
# 2️⃣  TARGET: 0 = legitimate, 1 = phishing
#     The raw column has values {1, 0, -1}:
#       1  → legitimate   → 0
#       0  &  -1          → phishing    → 1
# ─────────────────────────────────────────────────────────────
y = (df["Result"].astype(int) != 1).astype(int)
X = df.drop(columns=["Result"])

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

# ─────────────────────────────────────────────────────────────
# 3️⃣  PRE‑PROCESS: Standardize features (mean‑0 / std‑1)
# ─────────────────────────────────────────────────────────────
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test  = scaler.transform(X_test)

# ─────────────────────────────────────────────────────────────
# 4️⃣  MODEL: RBF‑kernel SVM
#     • C=1.0         (regularization strength)
#     • gamma='scale' (1 / [n_features × var(X)])
#     • probability=True  → enable predict_proba for ROC‑AUC
# ─────────────────────────────────────────────────────────────
clf = SVC(kernel="rbf", C=1.0, gamma="scale",
probability=True, random_state=42)
clf.fit(X_train, y_train)

# ─────────────────────────────────────────────────────────────
# 5️⃣  EVALUATION
# ─────────────────────────────────────────────────────────────
y_pred = clf.predict(X_test)
y_prob = clf.predict_proba(X_test)[:, 1]   # P(class 1)

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

"""
Accuracy : 0.956
Precision: 0.963
Recall   : 0.937
F1‑score : 0.950
ROC AUC  : 0.989
"""

SVM model će izbaciti metrike koje možemo uporediti sa logističkom regresijom na istom zadatku. Možda ćemo otkriti da SVM postiže visoku tačnost i AUC ako su podaci dobro razdvojeni karakteristikama. S druge strane, ako je skup podataka imao puno šuma ili preklapajućih klasa, SVM možda neće značajno nadmašiti logističku regresiju. U praksi, SVM-ovi mogu dati podsticaj kada postoje složene, nelinearne veze između karakteristika i klase -- RBF kernel može uhvatiti zakrivljene granice odluke koje bi logistička regresija propustila. Kao i kod svih modela, pažljivo podešavanje C (regularizacija) i parametara kernela (kao što je gamma za RBF) je potrebno da bi se izbalansirali pristrasnost i varijansa.

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

Ovaj kod obučava Naive Bayes klasifikator za otkrivanje napada. Naive Bayes će izračunati stvari poput P(service=http | Attack) i P(Service=http | Normal) na osnovu podataka za obuku, pretpostavljajući nezavisnost među karakteristikama. Zatim će koristiti ove verovatnoće da klasifikuje nove veze kao normalne ili napad na osnovu posmatranih karakteristika. Performanse NB na NSL-KDD možda neće biti tako visoke kao kod naprednijih modela (pošto je nezavisnost karakteristika prekršena), ali često su zadovoljavajuće i dolaze sa prednošću ekstremne brzine. U scenarijima poput filtriranja e-pošte u realnom vremenu ili inicijalne triage URL-ova, Naive Bayes model može brzo označiti očigledno zlonamerne slučajeve uz nisku potrošnju resursa.

Ponovo ćemo koristiti NSL-KDD (binarna klasifikacija). Pošto je k-NN računski zahtevan, koristićemo podskup podataka za obuku kako bismo ga održali izvodljivim u ovoj demonstraciji. Izabraćemo, recimo, 20.000 uzoraka obuke od ukupno 125k, i koristiti k=5 suseda. Nakon obuke (zaista samo skladištenje podataka), procenićemo na testnom skupu. Takođe ćemo skalirati karakteristike za izračunavanje udaljenosti kako bismo osigurali da nijedna pojedinačna karakteristika ne dominira zbog skale.

import pandas as pd
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

# 1. Load NSL-KDD and preprocess similarly
col_names = [                       # 41 features + 2 targets
"duration","protocol_type","service","flag","src_bytes","dst_bytes","land",
"wrong_fragment","urgent","hot","num_failed_logins","logged_in",
"num_compromised","root_shell","su_attempted","num_root","num_file_creations",
"num_shells","num_access_files","num_outbound_cmds","is_host_login",
"is_guest_login","count","srv_count","serror_rate","srv_serror_rate",
"rerror_rate","srv_rerror_rate","same_srv_rate","diff_srv_rate",
"srv_diff_host_rate","dst_host_count","dst_host_srv_count",
"dst_host_same_srv_rate","dst_host_diff_srv_rate",
"dst_host_same_src_port_rate","dst_host_srv_diff_host_rate",
"dst_host_serror_rate","dst_host_srv_serror_rate","dst_host_rerror_rate",
"dst_host_srv_rerror_rate","class","difficulty_level"
]

train_url = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Train.csv"
test_url  = "https://raw.githubusercontent.com/Mamcose/NSL-KDD-Network-Intrusion-Detection/master/NSL_KDD_Test.csv"

df_train = pd.read_csv(train_url, header=None, names=col_names)
df_test  = pd.read_csv(test_url,  header=None, names=col_names)

from sklearn.preprocessing import LabelEncoder
for col in ['protocol_type', 'service', 'flag']:
le = LabelEncoder()
le.fit(pd.concat([df_train[col], df_test[col]], axis=0))
df_train[col] = le.transform(df_train[col])
df_test[col]  = le.transform(df_test[col])
X = df_train.drop(columns=['class', 'difficulty_level'], errors='ignore')
y = df_train['class'].apply(lambda x: 0 if x.strip().lower() == 'normal' else 1)
# Use a random subset of the training data for K-NN (to reduce computation)
X_train = X.sample(n=20000, random_state=42)
y_train = y[X_train.index]
# Use the full test set for evaluation
X_test = df_test.drop(columns=['class', 'difficulty_level'], errors='ignore')
y_test = df_test['class'].apply(lambda x: 0 if x.strip().lower() == 'normal' else 1)

# 2. Feature scaling for distance-based model
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test  = scaler.transform(X_test)

# 3. Train k-NN classifier (store data)
model = KNeighborsClassifier(n_neighbors=5, n_jobs=-1)
model.fit(X_train, y_train)

# 4. Evaluate on test set
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]
print(f"Accuracy:  {accuracy_score(y_test, y_pred):.3f}")
print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall:    {recall_score(y_test, y_pred):.3f}")
print(f"F1-score:  {f1_score(y_test, y_pred):.3f}")
print(f"ROC AUC:   {roc_auc_score(y_test, y_prob):.3f}")

"""
Accuracy:  0.780
Precision: 0.972
Recall:    0.632
F1-score:  0.766
ROC AUC:   0.837
"""

Model k-NN će klasifikovati vezu gledajući na 5 najbližih veza u podskupu skupa za obuku. Ako, na primer, 4 od tih suseda predstavljaju napade (anomalije), a 1 je normalan, nova veza će biti klasifikovana kao napad. Performanse mogu biti razmerne, iako često nisu tako visoke kao kod dobro podešenih Random Forest ili SVM na istim podacima. Međutim, k-NN ponekad može biti izuzetno efikasan kada su raspodele klasa veoma nepravilne i kompleksne -- efikasno koristeći pretragu zasnovanu na memoriji. U sajber bezbednosti, k-NN (sa k=1 ili malim k) može se koristiti za detekciju poznatih obrazaca napada po uzoru, ili kao komponenta u složenijim sistemima (npr., za klasterizaciju i zatim klasifikaciju na osnovu članstva u klasteru).

Gradient Boosting Machines (npr., XGBoost)

Gradient Boosting Machines su među najmoćnijim algoritmima za strukturirane podatke. Gradient boosting se odnosi na tehniku izgradnje ansambla slabih učenika (često odlučujućih stabala) na sekvencijalan način, gde svaki novi model ispravlja greške prethodnog ansambla. Za razliku od bagging-a (Random Forests) koji gradi stabla paralelno i prosečno ih, boosting gradi stabla jedno po jedno, svako se fokusira više na instance koje su prethodna stabla pogrešno predvidela.

Najpopularnije implementacije u poslednjim godinama su XGBoost, LightGBM, i CatBoost, koje su sve biblioteke za odlučujuća stabla sa gradient boosting-om (GBDT). One su bile izuzetno uspešne na takmičenjima u mašinskom učenju i aplikacijama, često postižuci vrhunske performanse na tabelarnim skupovima podataka. U sajber bezbednosti, istraživači i praktičari su koristili stabla sa gradient boosting-om za zadatke kao što su detekcija malvera (koristeći karakteristike izvučene iz fajlova ili ponašanja u toku rada) i detekcija mrežnih upada. Na primer, model sa gradient boosting-om može kombinovati mnoge slabe pravila (stabla) kao što su "ako ima mnogo SYN paketa i neobičan port -> verovatno skeniranje" u jakog kompozitnog detektora koji uzima u obzir mnoge suptilne obrasce.

Zašto su pojačana stabla tako efikasna? Svako stablo u sekvenci se obučava na rezidualnim greškama (gradijentima) predikcija trenutnog ansambla. Na taj način, model postepeno "pojačava" oblasti gde je slab. Korišćenje odlučujućih stabala kao osnovnih učenika znači da konačni model može uhvatiti kompleksne interakcije i nelinearne odnose. Takođe, boosting inherentno ima oblik ugrađene regularizacije: dodavanjem mnogih malih stabala (i korišćenjem stope učenja za skaliranje njihovih doprinosa), često dobro generalizuje bez velikog prekomernog prilagođavanja, pod uslovom da su izabrani odgovarajući parametri.

Ključne karakteristike Gradient Boosting-a:

• Tip problema: Pretežno klasifikacija i regresija. U bezbednosti, obično klasifikacija (npr., binarna klasifikacija veze ili fajla). Rukuje binarnim, višeklasnim (uz odgovarajući gubitak), pa čak i problemima rangiranja.

• Interpretabilnost: Niska do srednja. Dok je jedno pojačano stablo malo, ceo model može imati stotine stabala, što nije lako za ljudsko tumačenje kao celina. Međutim, kao i Random Forest, može pružiti ocene važnosti karakteristika, a alati poput SHAP (SHapley Additive exPlanations) mogu se koristiti za tumačenje pojedinačnih predikcija do određene mere.

• Prednosti: Često najbolje performanse algoritma za strukturirane/tabelarne podatke. Može detektovati kompleksne obrasce i interakcije. Ima mnogo podešavanja (broj stabala, dubina stabala, stopa učenja, regularizacione stavke) za prilagođavanje složenosti modela i sprečavanje prekomernog prilagođavanja. Moderne implementacije su optimizovane za brzinu (npr., XGBoost koristi informacije o drugom redu gradijenta i efikasne strukture podataka). Obično bolje rukuje neuravnoteženim podacima kada se kombinuje sa odgovarajućim funkcijama gubitka ili podešavanjem težina uzoraka.

• Ograničenja: Složenije je za podešavanje od jednostavnijih modela; obuka može biti spora ako su stabla duboka ili je broj stabala veliki (iako je obično brža od obuke uporedivih dubokih neuronskih mreža na istim podacima). Model može prekomerno da se prilagodi ako nije podešen (npr., previše dubokih stabala sa nedovoljnom regularizacijom). Zbog mnogih hiperparametara, efikasno korišćenje gradient boosting-a može zahtevati više stručnosti ili eksperimentisanja. Takođe, kao i metode zasnovane na stablima, ne rukuje inherentno veoma retkim visokodimenzionalnim podacima tako efikasno kao linearni modeli ili Naive Bayes (iako se može primeniti, npr., u klasifikaciji teksta, ali možda neće biti prvi izbor bez inženjeringa karakteristika).

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

Kombinovanje modela: Ensemble učenje i Stacking

Ensemble učenje je strategija kombinovanja više modela kako bi se poboljšale ukupne performanse. Već smo videli specifične ensemble metode: Random Forest (ensemble drveća putem bagging-a) i Gradient Boosting (ensemble drveća putem sekvencijalnog boosting-a). Ali ensemble se mogu kreirati i na druge načine, kao što su voting ensemble ili stacked generalization (stacking). Glavna ideja je da različiti modeli mogu hvatanje različitih obrazaca ili imati različite slabosti; kombinovanjem možemo kompenzovati greške svakog modela snagama drugog.

• Voting Ensemble: U jednostavnom voting klasifikatoru, obučavamo više različitih modela (recimo, logističku regresiju, stablo odlučivanja i SVM) i omogućavamo im da glasaju o konačnoj predikciji (većina glasova za klasifikaciju). Ako težimo glasove (npr., veću težinu preciznijim modelima), to je težinski voting sistem. Ovo obično poboljšava performanse kada su pojedinačni modeli razmerno dobri i nezavisni -- ensemble smanjuje rizik od greške pojedinačnog modela jer drugi mogu ispraviti. To je kao imati panel stručnjaka umesto jednog mišljenja.

• Stacking (Stacked Ensemble): Stacking ide korak dalje. Umesto jednostavnog glasanja, obučava meta-model da nauči kako najbolje kombinovati predikcije osnovnih modela. Na primer, obučite 3 različita klasifikatora (osnovne učenike), a zatim njihove izlaze (ili verovatnoće) koristite kao karakteristike u meta-klasifikatoru (često jednostavnom modelu poput logističke regresije) koji uči optimalan način da ih pomeša. Meta-model se obučava na validacionom skupu ili putem unakrsne validacije kako bi se izbeglo prekomerno prilagođavanje. Stacking često može nadmašiti jednostavno glasanje učenjem koje modele više verovati u kojim okolnostima. U sajber bezbednosti, jedan model može biti bolji u hvatanju mrežnih skeniranja dok je drugi bolji u hvatanju malware beaconinga; stacking model bi mogao naučiti da se oslanja na svaki odgovarajuće.

Ensemble, bilo putem glasanja ili stackinga, obično povećavaju tačnost i robusnost. Nedostatak je povećana složenost i ponekad smanjena interpretabilnost (iako neki ensemble pristupi poput proseka stabala odlučivanja i dalje mogu pružiti uvid, npr., važnost karakteristika). U praksi, ako operativna ograničenja dozvoljavaju, korišćenje ensemble može dovesti do viših stopa detekcije. Mnoge pobedničke rešenja u izazovima sajber bezbednosti (i Kaggle takmičenjima uopšte) koriste ensemble tehnike kako bi izvukli poslednji deo performansi.

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