우리는 피싱 웹사이트 데이터셋(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
"""

랜덤 포레스트는 일반적으로 이 침입 탐지 작업에서 강력한 결과를 달성합니다. 우리는 단일 결정 트리에 비해 F1 또는 AUC와 같은 메트릭에서 개선을 관찰할 수 있으며, 이는 데이터에 따라 재현율 또는 정밀도에서 특히 두드러집니다. 이는 *"랜덤 포레스트(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(정규화) 및 커널 매개변수(예: RBF의 gamma)를 신중하게 조정해야 합니다.

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의 성능은 더 고급 모델만큼 높지 않을 수 있지만(특성 독립성이 위배되기 때문에), 종종 괜찮고 극도의 속도의 이점을 제공합니다. 실시간 이메일 필터링이나 URL의 초기 분류와 같은 시나리오에서는 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은 약한 학습자(종종 결정 트리)의 앙상블을 순차적으로 구축하는 기술을 의미하며, 각 새로운 모델은 이전 앙상블의 오류를 수정합니다. 나무를 병렬로 구축하고 평균화하는 bagging(Random Forests)과 달리, boosting은 나무를 하나씩 구축하며, 각 나무는 이전 나무가 잘못 예측한 인스턴스에 더 집중합니다.

최근 몇 년 동안 가장 인기 있는 구현은 XGBoost, LightGBM, CatBoost로, 모두 gradient boosting decision tree (GBDT) 라이브러리입니다. 이들은 기계 학습 대회와 응용 프로그램에서 매우 성공적이었으며, 종종 표 형식 데이터셋에서 최첨단 성능을 달성합니다. 사이버 보안에서 연구자와 실무자는 악성 코드 탐지(파일 또는 런타임 동작에서 추출한 기능 사용) 및 네트워크 침입 탐지와 같은 작업에 gradient boosted trees를 사용했습니다. 예를 들어, gradient boosting 모델은 "많은 SYN 패킷과 비정상적인 포트 -> 스캔 가능성"과 같은 많은 약한 규칙(트리)을 결합하여 많은 미세한 패턴을 고려하는 강력한 복합 탐지기로 만들 수 있습니다.

부스트된 트리가 왜 이렇게 효과적일까요? 시퀀스의 각 트리는 현재 앙상블의 예측의 잔여 오류 (기울기)에 대해 훈련됩니다. 이렇게 하면 모델이 약한 영역을 점진적으로 **"부스트"**합니다. 결정 트리를 기본 학습자로 사용하면 최종 모델이 복잡한 상호작용과 비선형 관계를 포착할 수 있습니다. 또한, boosting은 본질적으로 내장된 정규화 형태를 가지고 있습니다: 많은 작은 트리를 추가하고(기여도를 조정하기 위해 학습률을 사용하여) 일반적으로 적절한 매개변수가 선택되면 큰 과적합 없이 잘 일반화됩니다.

Gradient Boosting의 주요 특성:

• 문제 유형: 주로 분류 및 회귀. 보안에서는 일반적으로 분류(예: 연결 또는 파일을 이진 분류). 이진, 다중 클래스(적절한 손실을 사용) 및 순위 문제를 처리합니다.

• 해석 가능성: 낮음에서 중간. 단일 부스트된 트리는 작지만 전체 모델은 수백 개의 트리를 가질 수 있어 전체적으로 인간이 해석하기 어렵습니다. 그러나 Random Forest와 마찬가지로 기능 중요도 점수를 제공할 수 있으며, SHAP(SHapley Additive exPlanations)와 같은 도구를 사용하여 개별 예측을 어느 정도 해석할 수 있습니다.

• 장점: 구조화된/표 형식 데이터에 대해 종종 최고 성능 알고리즘입니다. 복잡한 패턴과 상호작용을 탐지할 수 있습니다. 모델 복잡성을 조정하고 과적합을 방지하기 위해 많은 조정 노브(트리 수, 트리 깊이, 학습률, 정규화 항)를 가지고 있습니다. 현대 구현은 속도를 최적화했습니다(예: XGBoost는 2차 기울기 정보와 효율적인 데이터 구조를 사용합니다). 적절한 손실 함수와 샘플 가중치를 조정하면 불균형 데이터를 더 잘 처리하는 경향이 있습니다.

• 제한 사항: 더 간단한 모델보다 조정이 복잡합니다; 트리가 깊거나 트리 수가 많으면 훈련이 느릴 수 있습니다(그러나 여전히 동일한 데이터에서 비교 가능한 깊은 신경망을 훈련하는 것보다 일반적으로 빠릅니다). 조정하지 않으면 모델이 과적합할 수 있습니다(예: 충분한 정규화 없이 너무 많은 깊은 트리). 많은 하이퍼파라미터로 인해 gradient boosting을 효과적으로 사용하려면 더 많은 전문 지식이나 실험이 필요할 수 있습니다. 또한, 트리 기반 방법과 마찬가지로 매우 희소한 고차원 데이터를 선형 모델이나 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
"""

모델 결합: 앙상블 학습 및 스태킹

앙상블 학습은 여러 모델을 결합하여 전체 성능을 향상시키는 전략입니다. 우리는 이미 특정 앙상블 방법을 보았습니다: 랜덤 포레스트(배깅을 통한 트리의 앙상블)와 그래디언트 부스팅(순차적 부스팅을 통한 트리의 앙상블). 그러나 앙상블은 투표 앙상블이나 **스택 일반화(스태킹)**와 같은 다른 방법으로도 생성될 수 있습니다. 주요 아이디어는 서로 다른 모델이 서로 다른 패턴을 포착하거나 서로 다른 약점을 가질 수 있다는 것입니다; 이를 결합함으로써 우리는 각 모델의 오류를 다른 모델의 강점으로 보완할 수 있습니다.

• 투표 앙상블: 간단한 투표 분류기에서는 여러 다양한 모델(예: 로지스틱 회귀, 결정 트리, 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
"""

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