File size: 7,149 Bytes
aefa98b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
"""STEP 06: how well can the SOURCE dataset be predicted from the features? (RQ1) + definition of feature set C.

Population: rows that are first occurrences of their B-hash (is_first_B), for ALL feature sets (stricter, identical sample for A/B/C).
Sample: equal number of flows per source (cap N_PER_SOURCE), deterministic by hash(row_id, SEED); random 70/30 split (stratified by source).
Probes (LightGBM, 4-class source identification):
  1. overall, feature sets A / B / C
  2. within one class only: Benign (4 sources), DoS (3), DDoS (2): same label, different source
Feature set C rule (stated before looking at results): drop every B feature whose SINGLE-feature decision tree identifies the source with
balanced accuracy >= C_THRESHOLD (0.90). Chance = 1/#sources.
Outputs (artifacts/step06/): probe_results.csv, univariate.csv, feature_set_C.json, importance_B.csv, confusion_B.csv
"""
import csv
import numpy as np, pandas as pd
import lightgbm as lgb
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, f1_score, confusion_matrix
from .common import *

NAME = "step06"
N_PER_SOURCE = 150_000
C_THRESHOLD = 0.90
KEYS = os.path.join(DATA, "dedup_keys.parquet")
S = f"read_parquet('{PARQUET_SRC}')"
K = f"read_parquet('{KEYS}')"


def sample(con, cols, per_source, where="TRUE"):
    q = f"""SELECT * FROM (
        SELECT s.source, s.Attack, {feat_select(cols, 's.')}, row_number() OVER (PARTITION BY s.source ORDER BY hash(s.row_id, {SEED})) rk
        FROM {S} s JOIN {K} k USING (row_id) WHERE k.is_first_B AND {where}) WHERE rk <= {per_source}"""
    return con.execute(q).df()                      # keeps rk (rank within source, deterministic by hash)


def prep(df, cols):
    X = df[cols].astype("float32").replace([np.inf, -np.inf], np.nan)
    return X


def probe(con, name, cols, where, per_source, results, feats):
    df = sample(con, feats, per_source, where)
    counts = df.source.value_counts()
    n = int(counts.min())                         # equalise sources: keep the first n ranks of every source
    df = df[df.rk <= n].reset_index(drop=True)
    y = df.source.map({s: i for i, s in enumerate(SOURCES)}).values
    rng = np.random.RandomState(SEED); idx = rng.permutation(len(df)); cut = int(0.7 * len(df))
    tr, te = idx[:cut], idx[cut:]
    present = sorted(set(y)); remap = {v: i for i, v in enumerate(present)}; yy = np.array([remap[v] for v in y])
    out = {}
    for fs_name, fs in cols.items():
        X = prep(df, fs)
        m = lgb.LGBMClassifier(n_estimators=300, learning_rate=0.1, num_leaves=63, n_jobs=THREADS, verbose=-1, random_state=SEED,
                               objective="multiclass" if len(present) > 2 else "binary")
        m.fit(X.iloc[tr], yy[tr])
        p = m.predict(X.iloc[te])
        acc, f1 = accuracy_score(yy[te], p), f1_score(yy[te], p, average="macro")
        results.append([name, fs_name, len(fs), len(present), n, len(df), round(1 / len(present), 3), round(acc, 4), round(f1, 4)])
        print(f"  {name:10s} {fs_name}: n_feat={len(fs)} sources={len(present)} per_src={n} acc={acc:.4f} macroF1={f1:.4f}", flush=True)
        out[fs_name] = (m, X.iloc[te], yy[te], p, present)
    return out


def run(force=False):
    out = step_dir(NAME); con = connect()
    A, B = features_A(con), features_B(con)
    results = []
    # --- univariate scan on B (balanced sample) to define C
    df = sample(con, B, N_PER_SOURCE)
    n = int(df.source.value_counts().min())
    df = df[df.rk <= n].reset_index(drop=True)
    y = df.source.map({s: i for i, s in enumerate(SOURCES)}).values
    rng = np.random.RandomState(SEED); idx = rng.permutation(len(df)); cut = int(0.7 * len(df)); tr, te = idx[:cut], idx[cut:]
    uni = []
    for c in B:
        x = df[[c]].astype("float32").replace([np.inf, -np.inf], np.nan).fillna(-1e9).values
        t = DecisionTreeClassifier(max_leaf_nodes=64, random_state=SEED).fit(x[tr], y[tr])
        uni.append((c, accuracy_score(y[te], t.predict(x[te]))))
    uni.sort(key=lambda r: -r[1])
    with open(os.path.join(out, "univariate.csv"), "w", newline="") as f:
        w = csv.writer(f); w.writerow(["feature", "single_feature_source_accuracy"]); w.writerows([(c, round(a, 4)) for c, a in uni])
    dropped = [c for c, a in uni if a >= C_THRESHOLD]
    C = [c for c in B if c not in dropped]
    save_json({"rule": f"drop B features with single-feature source accuracy >= {C_THRESHOLD}", "threshold": C_THRESHOLD, "chance": 0.25,
               "dropped": dropped, "n_features_C": len(C), "features_C": C}, os.path.join(out, "feature_set_C.json"))
    print("feature set C drops:", dropped)
    sets = {"A": A, "B": B, "C": C}
    # --- overall and within-class probes
    probes = [("overall", "TRUE", N_PER_SOURCE), ("Benign", "s.Attack='Benign'", 50_000), ("DoS", "s.Attack='DoS'", 50_000), ("DDoS", "s.Attack='DDoS'", 50_000)]
    detail = None
    for name, where, per in probes:
        with timed(f"probe {name}"):
            r = probe(con, name, sets, where, per, results, A)
        if name == "overall": detail = r
    with open(os.path.join(out, "probe_results.csv"), "w", newline="") as f:
        w = csv.writer(f); w.writerow(["probe", "feature_set", "n_features", "n_sources", "per_source_n", "total_n", "chance", "accuracy", "macro_f1"]); w.writerows(results)
    m, Xte, yte, p, present = detail["B"]
    imp = sorted(zip(B, m.booster_.feature_importance("gain")), key=lambda r: -r[1])
    with open(os.path.join(out, "importance_B.csv"), "w", newline="") as f:
        w = csv.writer(f); w.writerow(["feature", "gain"]); w.writerows([(c, round(float(g), 1)) for c, g in imp])
    # ablation: remove the k most source-informative B features (by gain in the overall B model), retrain, re-measure
    order = [c for c, _ in imp]
    dfa = sample(con, B, N_PER_SOURCE); na = int(dfa.source.value_counts().min()); dfa = dfa[dfa.rk <= na].reset_index(drop=True)
    ya = dfa.source.map({s_: i for i, s_ in enumerate(SOURCES)}).values
    idx = np.random.RandomState(SEED).permutation(len(dfa)); cut = int(0.7 * len(dfa)); tr, te = idx[:cut], idx[cut:]
    abl = []
    for k in [0, 1, 2, 3, 5, 8, 12, 16, 20, 25, 30, 35, 40]:
        keep = order[k:]
        if len(keep) < 2: break
        X = prep(dfa, keep)
        mm = lgb.LGBMClassifier(n_estimators=200, learning_rate=0.1, num_leaves=63, n_jobs=THREADS, verbose=-1, random_state=SEED).fit(X.iloc[tr], ya[tr])
        pa = mm.predict(X.iloc[te]); abl.append((k, len(keep), round(accuracy_score(ya[te], pa), 4), round(f1_score(ya[te], pa, average="macro"), 4)))
        print(f"  ablation remove top-{k}: {len(keep)} features left, source accuracy {abl[-1][2]}", flush=True)
    with open(os.path.join(out, "ablation_source_identifiability.csv"), "w", newline="") as f:
        w = csv.writer(f); w.writerow(["removed_top_k", "n_features_left", "accuracy", "macro_f1"]); w.writerows(abl)
    cm = confusion_matrix(yte, p)
    pd.DataFrame(cm, index=[SOURCES[i] for i in present], columns=[SOURCES[i] for i in present]).to_csv(os.path.join(out, "confusion_B.csv"))
    print(open(os.path.join(out, "probe_results.csv")).read())