हम एक फ़िशिंग वेबसाइट्स डेटासेट (UCI रिपॉजिटरी से) का उपयोग करेंगे जिसमें वेबसाइटों की निकाली गई विशेषताएँ (जैसे कि क्या URL में एक IP पता है, डोमेन की उम्र, HTML में संदिग्ध तत्वों की उपस्थिति, आदि) और एक लेबल है जो यह दर्शाता है कि साइट फ़िशिंग है या वैध। हम वेबसाइटों को वर्गीकृत करने के लिए एक लॉजिस्टिक रिग्रेशन मॉडल प्रशिक्षित करते हैं और फिर इसकी सटीकता, प्रिसिजन, रिकॉल, F1-स्कोर, और ROC AUC का परीक्षण विभाजन पर मूल्यांकन करते हैं।

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

इस फ़िशिंग पहचान उदाहरण में, लॉजिस्टिक रिग्रेशन प्रत्येक वेबसाइट के फ़िशिंग होने की संभावना उत्पन्न करता है। सटीकता, प्रिसिजन, रिकॉल, और F1 का मूल्यांकन करके, हम मॉडल के प्रदर्शन का आभास प्राप्त करते हैं। उदाहरण के लिए, उच्च रिकॉल का मतलब होगा कि यह अधिकांश फ़िशिंग साइटों को पकड़ता है (सुरक्षा के लिए महत्वपूर्ण है ताकि छूटे हुए हमलों को कम किया जा सके), जबकि उच्च प्रिसिजन का मतलब है कि इसमें कुछ झूठे अलार्म होते हैं (विश्लेषक की थकान से बचने के लिए महत्वपूर्ण)। ROC AUC (ROC कर्व के नीचे का क्षेत्र) प्रदर्शन का एक थ्रेशोल्ड-स्वतंत्र माप देता है (1.0 आदर्श है, 0.5 मौका से बेहतर नहीं है)। लॉजिस्टिक रिग्रेशन अक्सर ऐसे कार्यों पर अच्छा प्रदर्शन करता है, लेकिन यदि फ़िशिंग और वैध साइटों के बीच का निर्णय सीमा जटिल है, तो अधिक शक्तिशाली गैर-रेखीय मॉडल की आवश्यकता हो सकती है।

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

इस निर्णय वृक्ष उदाहरण में, हमने वृक्ष की गहराई को 10 तक सीमित किया है ताकि अत्यधिक ओवरफिटिंग से बचा जा सके ( max_depth=10 पैरामीटर)। मेट्रिक्स दिखाते हैं कि वृक्ष सामान्य बनाम हमले के ट्रैफ़िक को कितनी अच्छी तरह से अलग करता है। उच्च पुनःकाल का मतलब होगा कि यह अधिकांश हमलों को पकड़ता है (IDS के लिए महत्वपूर्ण), जबकि उच्च सटीकता का मतलब है कि झूठे अलार्म कम हैं। निर्णय वृक्ष अक्सर संरचित डेटा पर उचित सटीकता प्राप्त करते हैं, लेकिन एकल वृक्ष संभवतः सर्वोत्तम प्रदर्शन नहीं कर सकता। फिर भी, मॉडल की व्याख्यात्मकता एक बड़ा प्लस है - हम वृक्ष के विभाजनों की जांच कर सकते हैं यह देखने के लिए, उदाहरण के लिए, कौन से विशेषताएँ (जैसे, service, src_bytes, आदि) एक कनेक्शन को दुर्भावनापूर्ण के रूप में चिह्नित करने में सबसे प्रभावशाली हैं।

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

The random forest आमतौर पर इस घुसपैठ पहचान कार्य पर मजबूत परिणाम प्राप्त करता है। हम एकल निर्णय वृक्ष की तुलना में F1 या AUC जैसे मेट्रिक्स में सुधार देख सकते हैं, विशेष रूप से पुनःकाल या सटीकता में, डेटा के आधार पर। यह इस समझ के साथ मेल खाता है कि "Random Forest (RF) एक एंसेंबल क्लासिफायर है और हमलों की प्रभावी वर्गीकरण के लिए अन्य पारंपरिक क्लासिफायर की तुलना में अच्छा प्रदर्शन करता है।" सुरक्षा संचालन के संदर्भ में, एक रैंडम फॉरेस्ट मॉडल हमलों को अधिक विश्वसनीयता से चिह्नित कर सकता है जबकि झूठे अलार्म को कम करता है, कई निर्णय नियमों के औसत के कारण। जंगल से विशेषता महत्व हमें बता सकता है कि कौन से नेटवर्क विशेषताएँ हमलों के लिए सबसे अधिक संकेतक हैं (जैसे, कुछ नेटवर्क सेवाएँ या पैकेट की असामान्य गिनती)।

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 मॉडल ऐसे मैट्रिक्स आउटपुट करेगा जिन्हें हम एक ही कार्य पर लॉजिस्टिक रिग्रेशन से तुलना कर सकते हैं। हमें यह मिल सकता है कि यदि डेटा विशेषताओं द्वारा अच्छी तरह से अलग किया गया है, तो SVM उच्च सटीकता और AUC प्राप्त करता है। दूसरी ओर, यदि डेटासेट में बहुत अधिक शोर या ओवरलैपिंग क्लासेस हैं, तो SVM लॉजिस्टिक रिग्रेशन से महत्वपूर्ण रूप से बेहतर प्रदर्शन नहीं कर सकता है। प्रैक्टिस में, SVM तब एक बढ़ावा दे सकता है जब विशेषताओं और क्लास के बीच जटिल, गैर-रेखीय संबंध होते हैं - RBF कर्नेल उन घुमावदार निर्णय सीमाओं को पकड़ सकता है जिन्हें लॉजिस्टिक रिग्रेशन चूक सकता है। सभी मॉडलों की तरह, पूर्वाग्रह और विविधता को संतुलित करने के लिए C (नियमितकरण) और कर्नेल पैरामीटर (जैसे gamma RBF के लिए) का सावधानीपूर्वक ट्यूनिंग आवश्यक है।

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

यह कोड हमलों का पता लगाने के लिए एक Naive Bayes वर्गीकरणकर्ता को प्रशिक्षित करता है। Naive Bayes प्रशिक्षण डेटा के आधार पर P(service=http | Attack) और P(Service=http | Normal) जैसे चीजों की गणना करेगा, यह मानते हुए कि विशेषताओं के बीच स्वतंत्रता है। फिर यह इन संभावनाओं का उपयोग नए कनेक्शनों को सामान्य या हमले के रूप में वर्गीकृत करने के लिए करेगा, जो देखी गई विशेषताओं के आधार पर है। NSL-KDD पर NB का प्रदर्शन अधिक उन्नत मॉडलों की तुलना में उतना उच्च नहीं हो सकता (क्योंकि विशेषता स्वतंत्रता का उल्लंघन होता है), लेकिन यह अक्सर अच्छा होता है और अत्यधिक गति का लाभ प्रदान करता है। वास्तविक समय के ईमेल फ़िल्टरिंग या URLs के प्रारंभिक ट्रायेज जैसे परिदृश्यों में, एक Naive Bayes मॉडल स्पष्ट रूप से दुर्भावनापूर्ण मामलों को कम संसाधन उपयोग के साथ जल्दी से चिह्नित कर सकता है।

हम फिर से NSL-KDD का उपयोग करेंगे (बाइनरी वर्गीकरण)। चूंकि k-NN गणनात्मक रूप से भारी है, हम इस प्रदर्शन में इसे व्यवहार्य रखने के लिए प्रशिक्षण डेटा के एक उपसमुच्चय का उपयोग करेंगे। हम, कहें, 125k में से 20,000 प्रशिक्षण नमूने चुनेंगे, और k=5 पड़ोसियों का उपयोग करेंगे। प्रशिक्षण के बाद (वास्तव में केवल डेटा को संग्रहीत करना), हम परीक्षण सेट पर मूल्यांकन करेंगे। हम दूरी की गणना के लिए विशेषताओं को भी स्केल करेंगे ताकि यह सुनिश्चित हो सके कि कोई एकल विशेषता स्केल के कारण हावी न हो।

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 मॉडल एक कनेक्शन को प्रशिक्षण सेट उपसमुच्चय में 5 निकटतम कनेक्शनों को देखकर वर्गीकृत करेगा। यदि, उदाहरण के लिए, उन पड़ोसियों में से 4 हमले (विसंगतियाँ) हैं और 1 सामान्य है, तो नया कनेक्शन एक हमले के रूप में वर्गीकृत किया जाएगा। प्रदर्शन उचित हो सकता है, हालांकि अक्सर एक अच्छी तरह से ट्यून किए गए Random Forest या SVM की तुलना में उतना उच्च नहीं होता। हालाँकि, k-NN कभी-कभी चमक सकता है जब वर्ग वितरण बहुत असामान्य और जटिल होते हैं - प्रभावी रूप से एक मेमोरी-आधारित लुकअप का उपयोग करते हुए। साइबर सुरक्षा में, k-NN (k=1 या छोटे k के साथ) ज्ञात हमले के पैटर्न की पहचान के लिए उदाहरण के रूप में या अधिक जटिल प्रणालियों में एक घटक के रूप में उपयोग किया जा सकता है (जैसे, क्लस्टरिंग के लिए और फिर क्लस्टर सदस्यता के आधार पर वर्गीकृत करना)।

Gradient Boosting Machines (जैसे, XGBoost)

Gradient Boosting Machines संरचित डेटा के लिए सबसे शक्तिशाली एल्गोरिदम में से एक हैं। Gradient boosting एक कमजोर शिक्षकों (अक्सर निर्णय वृक्षों) के समूह को अनुक्रमिक तरीके से बनाने की तकनीक को संदर्भित करता है, जहाँ प्रत्येक नया मॉडल पिछले समूह की त्रुटियों को सुधारता है। बैगिंग (Random Forests) के विपरीत, जो वृक्षों को समानांतर में बनाते हैं और उनका औसत निकालते हैं, बूस्टिंग वृक्षों को एक-एक करके बनाता है, प्रत्येक पिछले वृक्षों द्वारा गलत भविष्यवाणी किए गए उदाहरणों पर अधिक ध्यान केंद्रित करता है।

हाल के वर्षों में सबसे लोकप्रिय कार्यान्वयन XGBoost, LightGBM, और CatBoost हैं, जो सभी ग्रेडिएंट बूस्टिंग निर्णय वृक्ष (GBDT) पुस्तकालय हैं। ये मशीन लर्निंग प्रतियोगिताओं और अनुप्रयोगों में अत्यधिक सफल रहे हैं, अक्सर तालिका डेटा सेट पर अत्याधुनिक प्रदर्शन प्राप्त करते हैं। साइबर सुरक्षा में, शोधकर्ताओं और प्रैक्टिशनरों ने मैलवेयर पहचान (फाइलों या रनटाइम व्यवहार से निकाले गए विशेषताओं का उपयोग करके) और नेटवर्क घुसपैठ पहचान जैसे कार्यों के लिए ग्रेडिएंट बूस्टेड वृक्षों का उपयोग किया है। उदाहरण के लिए, एक ग्रेडिएंट बूस्टिंग मॉडल कई कमजोर नियमों (वृक्षों) को जोड़ सकता है जैसे "यदि कई SYN पैकेट और असामान्य पोर्ट -> संभावित स्कैन" को एक मजबूत समग्र पहचानकर्ता में जो कई सूक्ष्म पैटर्नों का ध्यान रखता है।

बूस्टेड वृक्ष इतने प्रभावी क्यों हैं? अनुक्रम में प्रत्येक वृक्ष वर्तमान समूह की भविष्यवाणियों की अवशिष्ट त्रुटियों (ग्रेडिएंट) पर प्रशिक्षित होता है। इस तरह, मॉडल धीरे-धीरे "बूस्ट" करता है उन क्षेत्रों को जहाँ यह कमजोर है। निर्णय वृक्षों का उपयोग आधार शिक्षकों के रूप में अंतिम मॉडल को जटिल इंटरैक्शन और गैर-रेखीय संबंधों को पकड़ने की अनुमति देता है। इसके अलावा, बूस्टिंग स्वाभाविक रूप से एक प्रकार की अंतर्निहित नियमितीकरण है: कई छोटे वृक्षों को जोड़कर (और उनके योगदान को स्केल करने के लिए एक लर्निंग रेट का उपयोग करके), यह अक्सर उचित पैरामीटर चुने जाने पर बिना बड़े ओवरफिटिंग के अच्छी तरह से सामान्यीकृत करता है।

Gradient Boosting की प्रमुख विशेषताएँ:

• समस्या का प्रकार: मुख्य रूप से वर्गीकरण और प्रतिगमन। सुरक्षा में, आमतौर पर वर्गीकरण (जैसे, एक कनेक्शन या फ़ाइल को बाइनरी वर्गीकृत करना)। यह बाइनरी, मल्टी-क्लास (उचित हानि के साथ), और यहां तक कि रैंकिंग समस्याओं को संभालता है।

• व्याख्यात्मकता: कम से मध्यम। जबकि एक एकल बूस्टेड वृक्ष छोटा होता है, एक पूर्ण मॉडल में सैकड़ों वृक्ष हो सकते हैं, जो समग्र रूप से मानव-व्याख्यायित नहीं होते। हालाँकि, Random Forest की तरह, यह विशेषता महत्व स्कोर प्रदान कर सकता है, और SHAP (SHapley Additive exPlanations) जैसे उपकरणों का उपयोग करके व्यक्तिगत भविष्यवाणियों की व्याख्या की जा सकती है।

• लाभ: अक्सर संरचित/तालिका डेटा के लिए सर्वश्रेष्ठ प्रदर्शन करने वाला एल्गोरिदम। जटिल पैटर्न और इंटरैक्शन का पता लगा सकता है। मॉडल की जटिलता को अनुकूलित करने और ओवरफिटिंग को रोकने के लिए कई ट्यूनिंग नॉब्स (वृक्षों की संख्या, वृक्षों की गहराई, लर्निंग रेट, नियमितीकरण शर्तें) हैं। आधुनिक कार्यान्वयन गति के लिए अनुकूलित हैं (जैसे, XGBoost द्वितीयक क्रम के ग्रेडिएंट जानकारी और कुशल डेटा संरचनाओं का उपयोग करता है)। उचित हानि कार्यों के साथ या नमूना वजन को समायोजित करके असंतुलित डेटा को बेहतर तरीके से संभालने की प्रवृत्ति होती है।

• सीमाएँ: सरल मॉडलों की तुलना में ट्यून करना अधिक जटिल; यदि वृक्ष गहरे हैं या वृक्षों की संख्या बड़ी है तो प्रशिक्षण धीमा हो सकता है (हालांकि फिर भी आमतौर पर समान डेटा पर एक तुलनीय गहरे न्यूरल नेटवर्क के प्रशिक्षण की तुलना में तेज होता है)। यदि ट्यून नहीं किया गया तो मॉडल ओवरफिट कर सकता है (जैसे, अपर्याप्त नियमितीकरण के साथ बहुत अधिक गहरे वृक्ष)। कई हाइपरपैरामीटर के कारण, प्रभावी ढंग से ग्रेडिएंट बूस्टिंग का उपयोग करने के लिए अधिक विशेषज्ञता या प्रयोग की आवश्यकता हो सकती है। इसके अलावा, वृक्ष-आधारित विधियों की तरह, यह स्वाभाविक रूप से बहुत विरल उच्च-आयामी डेटा को रेखीय मॉडलों या Naive Bayes की तरह कुशलता से नहीं संभालता है (हालांकि इसे अभी भी लागू किया जा सकता है, जैसे, पाठ वर्गीकरण में, लेकिन विशेषता इंजीनियरिंग के बिना पहले विकल्प के रूप में नहीं हो सकता)।

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

Combining Models: Ensemble Learning and Stacking

Ensemble learning एक रणनीति है कई मॉडलों को मिलाने के लिए ताकि समग्र प्रदर्शन में सुधार हो सके। हमने पहले ही कुछ विशेष एंसेंबल विधियों को देखा: Random Forest (बैगिंग के माध्यम से पेड़ों का एक एंसेंबल) और Gradient Boosting (क्रमिक बूस्टिंग के माध्यम से पेड़ों का एक एंसेंबल)। लेकिन एंसेंबल अन्य तरीकों से भी बनाए जा सकते हैं, जैसे वोटिंग एंसेंबल या स्टैक्ड जनरलाइजेशन (स्टैकिंग)। मुख्य विचार यह है कि विभिन्न मॉडल विभिन्न पैटर्न को पकड़ सकते हैं या उनकी विभिन्न कमजोरियाँ हो सकती हैं; उन्हें मिलाकर, हम प्रत्येक मॉडल की गलतियों को दूसरे की ताकत से संतुलित कर सकते हैं।

• वोटिंग एंसेंबल: एक साधारण वोटिंग क्लासिफायर में, हम कई विविध मॉडलों (मान लीजिए, एक लॉजिस्टिक रिग्रेशन, एक निर्णय वृक्ष, और एक SVM) को प्रशिक्षित करते हैं और उन्हें अंतिम भविष्यवाणी पर वोट करने देते हैं (वर्गीकरण के लिए बहुमत वोट)। यदि हम वोटों को वजन देते हैं (जैसे, अधिक सटीक मॉडलों को अधिक वजन), तो यह एक भारित वोटिंग योजना है। जब व्यक्तिगत मॉडल उचित रूप से अच्छे और स्वतंत्र होते हैं, तो यह आमतौर पर प्रदर्शन में सुधार करता है -- एंसेंबल एक व्यक्तिगत मॉडल की गलती के जोखिम को कम करता है क्योंकि अन्य इसे सही कर सकते हैं। यह एकल राय के बजाय विशेषज्ञों के पैनल की तरह है।

• स्टैकिंग (स्टैक्ड एंसेंबल): स्टैकिंग एक कदम आगे बढ़ता है। एक साधारण वोट के बजाय, यह एक मेटा-मॉडल को प्रशिक्षित करता है ताकि बेस मॉडलों की भविष्यवाणियों को सबसे अच्छे तरीके से मिलाने का तरीका सीखा जा सके। उदाहरण के लिए, आप 3 विभिन्न क्लासिफायर (बेस लर्नर्स) को प्रशिक्षित करते हैं, फिर उनके आउटपुट (या संभावनाओं) को एक मेटा-क्लासिफायर (अक्सर एक साधारण मॉडल जैसे लॉजिस्टिक रिग्रेशन) में विशेषताओं के रूप में फीड करते हैं जो उन्हें मिलाने का सबसे अच्छा तरीका सीखता है। मेटा-मॉडल को ओवरफिटिंग से बचने के लिए एक वैलिडेशन सेट पर या क्रॉस-वैलिडेशन के माध्यम से प्रशिक्षित किया जाता है। स्टैकिंग अक्सर साधारण वोटिंग से बेहतर प्रदर्शन कर सकता है क्योंकि यह कौन से मॉडलों पर किस परिस्थितियों में अधिक भरोसा करना है सीखता है। साइबर सुरक्षा में, एक मॉडल नेटवर्क स्कैन को पकड़ने में बेहतर हो सकता है जबकि दूसरा मैलवेयर बीकनिंग को पकड़ने में बेहतर हो सकता है; एक स्टैकिंग मॉडल प्रत्येक पर उचित रूप से भरोसा करना सीख सकता है।

एंसेंबल, चाहे वोटिंग द्वारा हो या स्टैकिंग द्वारा, सटीकता और मजबूती को बढ़ाने की प्रवृत्ति रखते हैं। नकारात्मक पक्ष यह है कि जटिलता बढ़ जाती है और कभी-कभी व्याख्या में कमी आती है (हालांकि कुछ एंसेंबल दृष्टिकोण जैसे निर्णय वृक्षों का औसत अभी भी कुछ अंतर्दृष्टि प्रदान कर सकता है, जैसे कि विशेषता महत्व)। व्यावहारिक रूप से, यदि संचालन संबंधी बाधाएँ अनुमति देती हैं, तो एंसेंबल का उपयोग करने से उच्च पहचान दर प्राप्त हो सकती है। साइबर सुरक्षा चुनौतियों (और सामान्य रूप से Kaggle प्रतियोगिताओं) में कई विजेता समाधान एंसेंबल तकनीकों का उपयोग करते हैं ताकि प्रदर्शन का अंतिम हिस्सा निकाला जा सके।

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

संदर्भ

• 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