Bir Phishing Web Siteleri Veri Seti (UCI deposundan) kullanacağız; bu veri seti, web sitelerinin çıkarılmış özelliklerini (URL'nin bir IP adresi olup olmadığı, alan adının yaşı, HTML'deki şüpheli unsurların varlığı vb.) ve sitenin phishing veya meşru olup olmadığını belirten bir etiketi içerir. Web sitelerini sınıflandırmak için bir lojistik regresyon modeli eğitiyoruz ve ardından test bölümü üzerinde doğruluğunu, kesinliğini, hatırlama oranını, F1-skorunu ve ROC AUC'yi değerlendiriyoruz.

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

Bu phishing tespiti örneğinde, lojistik regresyon her web sitesinin phishing olma olasılığını üretir. Doğruluk, kesinlik, hatırlama ve F1 değerlendirerek modelin performansını anlarız. Örneğin, yüksek bir hatırlama, çoğu phishing sitesini yakaladığı anlamına gelir (kaçırılan saldırıları en aza indirmek için güvenlik açısından önemlidir), yüksek kesinlik ise az sayıda yanlış alarm olduğu anlamına gelir (analist yorgunluğunu önlemek için önemlidir). ROC AUC (ROC Eğrisi Altındaki Alan), performansın eşik bağımsız bir ölçüsünü verir (1.0 ideal, 0.5 şansa eşit). Lojistik regresyon genellikle bu tür görevlerde iyi performans gösterir, ancak phishing ve meşru siteler arasındaki karar sınırı karmaşık ise, daha güçlü doğrusal olmayan modellere ihtiyaç duyulabilir.

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

Bu karar ağacı örneğinde, aşırı uyumdan kaçınmak için ağacın derinliğini 10 ile sınırladık (max_depth=10 parametresi). Metikler, ağacın normal ile saldırı trafiğini ne kadar iyi ayırt ettiğini gösterir. Yüksek bir geri çağırma, çoğu saldırıyı yakaladığı anlamına gelir (IDS için önemlidir), yüksek bir hassasiyet ise az sayıda yanlış alarm demektir. Karar ağaçları genellikle yapılandırılmış verilerde makul bir doğruluk elde eder, ancak tek bir ağaç en iyi performansa ulaşamayabilir. Yine de, modelin yorumlanabilirliği büyük bir artıdır -- örneğin, bir bağlantıyı kötü niyetli olarak işaretlemede en etkili olan özelliklerin (örneğin, service, src_bytes vb.) neler olduğunu görmek için ağacın bölümlerini inceleyebiliriz.

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

Rastgele orman, bu saldırı tespit görevinde genellikle güçlü sonuçlar elde eder. Tek bir karar ağacına kıyasla, özellikle geri çağırma veya hassasiyet açısından, veriye bağlı olarak F1 veya AUC gibi metriklerde bir iyileşme gözlemleyebiliriz. Bu, "Rastgele Orman (RF), bir topluluk sınıflandırıcısıdır ve saldırıların etkili sınıflandırması için diğer geleneksel sınıflandırıcılara kıyasla iyi performans gösterir." anlayışıyla uyumludur. Bir güvenlik operasyonları bağlamında, rastgele orman modeli, birçok karar kuralının ortalaması sayesinde saldırıları daha güvenilir bir şekilde işaretleyebilirken yanlış alarmları azaltabilir. Ormandan elde edilen özellik önemi, hangi ağ özelliklerinin saldırıları en iyi şekilde gösterdiğini (örneğin, belirli ağ hizmetleri veya olağandışı paket sayıları) bize söyleyebilir.

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 modeli, aynı görevde lojistik regresyon ile karşılaştırabileceğimiz metrikler üretecektir. Verilerin özellikler tarafından iyi ayrılmış olması durumunda SVM'nin yüksek bir doğruluk ve AUC elde ettiğini görebiliriz. Öte yandan, veri setinde çok fazla gürültü veya örtüşen sınıflar varsa, SVM lojistik regresyonu önemli ölçüde geçemeyebilir. Pratikte, SVM'ler, özellikler ve sınıf arasında karmaşık, doğrusal olmayan ilişkiler olduğunda bir avantaj sağlayabilir - RBF çekirdeği, lojistik regresyonun kaçıracağı eğrilen karar sınırlarını yakalayabilir. Tüm modellerde olduğu gibi, C (düzenleme) ve çekirdek parametrelerinin (RBF için gamma gibi) dikkatli bir şekilde ayarlanması, yanlılık ve varyansı dengelemek için gereklidir.

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

Bu kod, saldırıları tespit etmek için bir Naive Bayes sınıflandırıcısını eğitir. Naive Bayes, özellikler arasında bağımsızlık varsayarak, eğitim verilerine dayanarak P(service=http | Attack) ve P(Service=http | Normal) gibi şeyleri hesaplayacaktır. Ardından, gözlemlenen özelliklere dayanarak yeni bağlantıları normal veya saldırı olarak sınıflandırmak için bu olasılıkları kullanacaktır. NB'nin NSL-KDD üzerindeki performansı, daha gelişmiş modeller kadar yüksek olmayabilir (çünkü özellik bağımsızlığı ihlal edilmiştir), ancak genellikle makuldür ve aşırı hız avantajıyla birlikte gelir. Gerçek zamanlı e-posta filtreleme veya URL'lerin ilk önceliklendirilmesi gibi senaryolarda, bir Naive Bayes modeli, belirgin şekilde kötü niyetli durumları hızlı bir şekilde işaretleyebilir ve düşük kaynak kullanımı ile çalışır.

Yine NSL-KDD'yi (ikili sınıflandırma) kullanacağız. k-NN hesaplama açısından ağır olduğu için, bu gösterimde yönetilebilir tutmak için eğitim verilerinin bir alt kümesini kullanacağız. Tam 125k'dan 20,000 eğitim örneği seçeceğiz ve k=5 komşu kullanacağız. Eğitimden sonra (gerçekten sadece veriyi depolamak), test setinde değerlendirme yapacağız. Ayrıca, ölçek hesaplaması için özellikleri ölçeklendireceğiz, böylece tek bir özellik ölçek nedeniyle baskın çıkmaz.

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

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

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

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

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

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

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

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

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

k-NN modeli, bağlantıyı eğitim seti alt kümesindeki en yakın 5 bağlantıya bakarak sınıflandırır. Örneğin, bu komşulardan 4'ü saldırı (anomaliler) ve 1'i normal ise, yeni bağlantı bir saldırı olarak sınıflandırılacaktır. Performans makul olabilir, ancak genellikle aynı verilerde iyi ayarlanmış bir Random Forest veya SVM kadar yüksek değildir. Ancak, k-NN bazen sınıf dağılımları çok düzensiz ve karmaşık olduğunda parlayabilir - etkili bir şekilde bellek tabanlı bir arama kullanarak. Siber güvenlikte, k-NN (k=1 veya küçük k ile) bilinen saldırı desenlerinin tespiti için örnek olarak veya daha karmaşık sistemlerde (örneğin, kümeleme ve ardından küme üyeliğine göre sınıflandırma için) bir bileşen olarak kullanılabilir.

Gradient Boosting Machines (örneğin, XGBoost)

Gradient Boosting Machines, yapılandırılmış veriler için en güçlü algoritmalardan biridir. Gradient boosting, zayıf öğrenicilerin (genellikle karar ağaçları) ardışık bir şekilde bir topluluk oluşturma tekniğini ifade eder; burada her yeni model, önceki topluluğun hatalarını düzeltir. Ağaçları paralel olarak inşa eden ve ortalayan bagging (Random Forests) ile karşılaştırıldığında, boosting ağaçları birer birer inşa eder ve her biri önceki ağaçların yanlış tahmin ettiği örneklere daha fazla odaklanır.

Son yıllarda en popüler uygulamalar XGBoost, LightGBM ve CatBoost'tur; bunların hepsi gradient boosting karar ağaçları (GBDT) kütüphaneleridir. Makine öğrenimi yarışmalarında ve uygulamalarında son derece başarılı olmuşlardır ve genellikle tablo verilerinde en son teknoloji performansı elde etmektedirler. Siber güvenlikte, araştırmacılar ve uygulayıcılar, kötü amaçlı yazılım tespiti (dosyalardan veya çalışma zamanı davranışından çıkarılan özellikler kullanarak) ve ağ saldırı tespiti gibi görevler için gradient boosted ağaçlar kullanmışlardır. Örneğin, bir gradient boosting modeli, "birçok SYN paketi ve alışılmadık port -> muhtemel tarama" gibi birçok zayıf kuralı (ağaçları) güçlü bir bileşik dedektöre dönüştürebilir ve birçok ince deseni dikkate alır.

Neden artırılmış ağaçlar bu kadar etkilidir? Sıralamadaki her ağaç, mevcut topluluğun tahminlerinin artık hataları (gradyanlar) üzerinde eğitilir. Bu şekilde, model zayıf olduğu alanları yavaş yavaş "artırır". Karar ağaçlarının temel öğreniciler olarak kullanılması, nihai modelin karmaşık etkileşimleri ve doğrusal olmayan ilişkileri yakalayabilmesini sağlar. Ayrıca, boosting, yerleşik bir düzenleme biçimine sahiptir: birçok küçük ağaç ekleyerek (ve katkılarını ölçeklendirmek için bir öğrenme oranı kullanarak), genellikle uygun parametreler seçildiğinde büyük aşırı uyum olmadan iyi genelleme yapar.

Gradient Boosting'in Ana Özellikleri:

• Problem Türü: Öncelikle sınıflandırma ve regresyon. Güvenlikte genellikle sınıflandırma (örneğin, bir bağlantıyı veya dosyayı ikili olarak sınıflandırma). İkili, çok sınıflı (uygun kayıpla) ve hatta sıralama problemlerini ele alır.

• Yorumlanabilirlik: Düşük ila orta. Tek bir artırılmış ağaç küçük olsa da, tam bir model yüzlerce ağaç içerebilir, bu da bütünüyle insan tarafından yorumlanamaz. Ancak, Random Forest gibi, özellik önem puanları sağlayabilir ve SHAP (SHapley Additive exPlanations) gibi araçlar, bireysel tahminleri bir ölçüde yorumlamak için kullanılabilir.

• Avantajlar: Genellikle yapılandırılmış/tablo verileri için en iyi performans gösteren algoritmadır. Karmaşık desenleri ve etkileşimleri tespit edebilir. Model karmaşıklığını özelleştirmek ve aşırı uyumu önlemek için birçok ayar düğmesine (ağaç sayısı, ağaç derinliği, öğrenme oranı, düzenleme terimleri) sahiptir. Modern uygulamalar hız için optimize edilmiştir (örneğin, XGBoost ikinci dereceden gradyan bilgisi ve verimli veri yapıları kullanır). Uygun kayıp fonksiyonları ile veya örnek ağırlıklarını ayarlayarak dengesiz verileri daha iyi işleme eğilimindedir.

• Sınırlamalar: Daha basit modellere göre ayarlaması daha karmaşıktır; ağaçlar derin veya ağaç sayısı büyükse eğitim yavaş olabilir (ancak yine de genellikle aynı verilerde karşılaştırılabilir bir derin sinir ağını eğitmekten daha hızlıdır). Model ayarlanmadan aşırı uyum sağlayabilir (örneğin, yetersiz düzenleme ile çok fazla derin ağaç). Birçok hiperparametre nedeniyle, gradient boosting'i etkili bir şekilde kullanmak daha fazla uzmanlık veya deney yapmayı gerektirebilir. Ayrıca, ağaç tabanlı yöntemler gibi, çok seyrek yüksek boyutlu verileri doğrusal modeller veya Naive Bayes kadar verimli bir şekilde ele almaz (ancak yine de uygulanabilir, örneğin metin sınıflandırmasında, ancak özellik mühendisliği olmadan ilk tercih olmayabilir).

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

Modelleri Birleştirme: Ensemble Öğrenme ve Stacking

Ensemble öğrenme, genel performansı artırmak için birden fazla modeli birleştirme stratejisidir. Daha önce belirli ensemble yöntemlerini gördük: Random Forest (bagging ile ağaçların bir ensemble'ı) ve Gradient Boosting (sıralı boosting ile ağaçların bir ensemble'ı). Ancak, ensemble'lar oylama ensemble'ları veya stacked generalization (stacking) gibi diğer yollarla da oluşturulabilir. Ana fikir, farklı modellerin farklı desenleri yakalayabileceği veya farklı zayıflıkları olabileceğidir; bunları birleştirerek, her modelin hatalarını diğerinin güçlü yönleriyle telafi edebiliriz.

• Oylama Ensemble: Basit bir oylama sınıflandırıcısında, birden fazla çeşitli modeli (örneğin, bir lojistik regresyon, bir karar ağacı ve bir SVM) eğitiyoruz ve bunların son tahmin üzerinde oy kullanmalarını sağlıyoruz (sınıflandırma için çoğunluk oyu). Oylara ağırlık verirsek (örneğin, daha doğru modellere daha yüksek ağırlık), bu ağırlıklı bir oylama şemasına dönüşür. Bu genellikle bireysel modeller makul derecede iyi ve bağımsız olduğunda performansı artırır -- ensemble, bireysel bir modelin hatasının riskini azaltır çünkü diğerleri bunu düzeltebilir. Bu, tek bir görüş yerine bir uzman paneline sahip olmak gibidir.

• Stacking (Stacked Ensemble): Stacking bir adım daha ileri gider. Basit bir oy yerine, bir meta-model eğiterek temel modellerin tahminlerini en iyi şekilde nasıl birleştireceğini öğrenir. Örneğin, 3 farklı sınıflandırıcı (temel öğreniciler) eğitirsiniz, ardından çıktıları (veya olasılıkları) bir meta-sınıflandırıcıya (genellikle lojistik regresyon gibi basit bir model) özellik olarak beslersiniz; bu model, bunları harmanlamanın en iyi yolunu öğrenir. Meta-model, aşırı uyumu önlemek için bir doğrulama setinde veya çapraz doğrulama ile eğitilir. Stacking, hangi modellerin hangi durumlarda daha fazla güvenilir olduğunu öğrenerek basit oylamadan genellikle daha iyi performans gösterebilir. Siber güvenlikte, bir model ağ taramalarını yakalamada daha iyi olabilirken, diğeri kötü amaçlı yazılım sinyallerini yakalamada daha iyi olabilir; bir stacking modeli her birine uygun şekilde güvenmeyi öğrenebilir.

Oylama veya stacking ile olsun, ensemble'lar genellikle doğruluğu ve sağlamlığı artırma eğilimindedir. Dezavantajı, artan karmaşıklık ve bazen azalan yorumlanabilirliktir (ancak karar ağaçlarının ortalaması gibi bazı ensemble yaklaşımları yine de bazı içgörüler sağlayabilir, örneğin, özellik önemi). Pratikte, operasyonel kısıtlamalar izin veriyorsa, bir ensemble kullanmak daha yüksek tespit oranlarına yol açabilir. Siber güvenlik zorluklarında (ve genel olarak Kaggle yarışmalarında) birçok kazanan çözüm, son performans parçasını elde etmek için ensemble tekniklerini kullanmaktadır.

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

Referanslar

• 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