简介：面向毕业设计与网络安全从业者的网络流量异常检测Python项目，聚焦DeepSVDD、DeepSAD与FT-Transformer三种深度模型在CICIDS2017数据集上的异常检测对比实验，覆盖数据清洗、归一化、模型调参与性能评估全流程。包内共205个文件，以Python脚本（py）为核心，包含模型训练与评估代码；另有pyc编译文件、png结果图、h5预训练模型、xml配置、csv数据及md文档等，压缩包约58.88MB，结构清晰便于按需调用。目前已有410人学习下载。读者可由此掌握DeepSVDD的无监督超球面建模、DeepSAD的半监督异常样本利用、FT-Transformer的频率域时序特征提取等关键思路，获得可直接运行的脚本与预训练权重，为毕业设计或流量异常检测研究提供可复现的基准方案，也可作为后续改进的起点。

1. 网络流量异常检测：毕设这个方向的第一周该做什么

开题答辩前两周，一个学生拿着校园网出口的一段 pcap 找过来，说想做个网络流量异常检测分析当毕设。我给他的第一个建议是：第一周不要碰任何模型，先把数据从 pcap 变成一张带标签的表，否则后面所有算法都是黑匣子。网络流量异常检测，本质上是在流量特征里找出偏离正常行为的通信模式——端口扫描、DDoS、暴力破解、数据外泄都属于检测目标。它适合毕设，是因为公开数据集成熟、结果能画图、答辩有故事可讲；但也因为流量数据高度不平衡、时间顺序敏感，真正落地时要躲过不少坑。这篇文章面向的就是准备选这个方向、或者已经开题但还在数据阶段卡住的人：从数据来源、预处理、算法选型到踩坑，一路写到能跑出可信结果。

2. 数据准备链路：从 pcap 到可训练特征表的落地路径

先说一个常被忽略的事实：流量数据形态决定了后面整个项目的写法。很多毕设翻车不是在算法上，而是连“我到底在检测什么”都没说清。所以这一章先把数据链路打通，再谈模型。

2.1 三种数据来源怎么选：抓包、公开集与模拟流量

做网络流量异常检测，数据来源通常有三条路：自己抓包、公开数据集、模拟流量。我一般会建议先用公开数据集做主体实验（原因放到第 3 章），再用自己抓包或模拟流量做“场景验证”，两条腿走路。

自己抓包的优点是真实，校园网或本机用 Wireshark、tshark 抓一段时间就能拿到 pcap；缺点是基本没有标签，你很难知道某个时间段里是不是真的有攻击在发生。人工标注流量这件事，做过一次就再也不想做第二次，它比调模型费时得多。

公开数据集的优点是标签完整、能复现、答辩时老师可以拿去跑结果，比如 NSL-KDD 和 CICIDS2017，下一步展开讲。模拟流量则是用 scapy 发一些特定形态的包（UDP flood、SYN flood）混在正常请求里，标签自己写，干净可控，适合用来验证算法是不是真的认得出某种攻击形态。

三者不是互斥的。我的习惯是：公开集训练选型，模拟流量做单类攻击的泛化测试，自己抓的 pcap 放最后当“真实场景演示”。这个顺序写进论文就是一条完整的实验链路。

2.2 从包到流：特征体系怎么搭

原始流量数据分两种粒度。一种是 packet-based，一个 pcap 里每一行是一个包，字段包括时间戳、源目 IP、源目端口、协议、包长；另一种是 flow-based，把五元组相同的包聚合成一条流，再对这条流计算统计特征。公开数据集大多给的是 flow-based 特征，自己抓的 pcap 则是 packet-based，需要自己做聚合。

特征怎么搭，直接决定模型能不能学到东西。以自己抓包后聚合为例，我常用的特征组是这几个：

第一是长度特征：包长均值、包长方差、最大包长、最小包长。网络中 DDoS 和扫描流量的包长分布和正常网页访问差异很大，这是最值钱的指标。第二是时间特征：流持续时间、包到达间隔的均值与方差、每秒包数。扫描器通常一秒发很多短包，人工访问则间隔不规则。第三是协议特征：TCP 标志位的计数，比如 SYN 占比高，多半在扫描或握手攻击。第四是方向特征：上行与下行包的字节比例，视频、网页下载下行流量大，木马回连则相反。

把这些特征组装成一个 DataFrame，每行是一条流，列是数值特征，这才是检测模型的输入。常见误区是直接把 pcap 里所有字段原样塞进模型，后面第 5 章会说这种行为为什么翻车。

2.3 用 scapy 把 pcap 转成特征表：一个可直接运行的脚本

自己抓包拿到 pcap 之后，我一般直接用 scapy 做解析，它比手写 dpkt 直观。下面这段代码可以照抄下来当模板，它会把 pcap 读进来，按五元组聚合成流，计算全套统计特征后导出 csv。

from scapy.all import rdpcap, IP, TCP, UDP import pandas as pd import numpy as np from collections import defaultdict def pcap_to_flow_features(pcap_path): packets = rdpcap(pcap_path) flows = defaultdict(list) for pkt in packets: if IP not in pkt: continue if TCP in pkt: proto = 'TCP' sport, dport = pkt.sport, pkt.dport elif UDP in pkt: proto = 'UDP' sport, dport = pkt.sport, pkt.dport else: proto = 'OTHER' sport, dport = 0, 0 key = (pkt[IP].src, pkt[IP].dst, sport, dport, proto) flows[key].append({'len': len(pkt), 'ts': float(pkt.time)}) rows = [] for key, pkts in flows.items(): lens = [p['len'] for p in pkts] timestamps = sorted([p['ts'] for p in pkts]) intervals = np.diff(timestamps) if len(timestamps) > 1 else [0] rows.append({ 'src_ip': key[0], 'dst_ip': key[1], 'src_port': key[2], 'dst_port': key[3], 'proto': key[4], 'pkt_count': len(pkts), 'byte_sum': int(np.sum(lens)), 'len_mean': float(np.mean(lens)), 'len_std': float(np.std(lens)), 'duration': timestamps[-1] - timestamps[0], 'interval_mean': float(np.mean(intervals)), 'pps': len(pkts) / max(timestamps[-1] - timestamps[0], 1e-6), }) return pd.DataFrame(rows) if __name__ == '__main__': df = pcap_to_flow_features('capture.pcap') df.to_csv('flow_features.csv', index=False)

逻辑说明：rdpcap 把整个 pcap 加载进内存，循环里用 IP、TCP、UDP 三个判断过滤非 IP 包，并按五元组塞进一个 defaultdict；聚合阶段计算包数、总字节数、包长均值与标准差、流时长、包间隔均值和每秒包数。输出的 DataFrame 每一行就是一条流。

参数说明：scapy 的 rdpcap 对超过几百 MB 的大 pcap 很吃内存，如果抓包文件很大，建议换用 PcapReader 做流式读取或直接用 tshark 出 CSV，命令是tshark -r capture.pcap -T fields -e ip.src -e ip.dst -e tcp.srcport -e tcp.dstport -e frame.len -E separator=, > packets.csv，然后在 pandas 里 groupby 聚合。scapy 方案胜在写起来清晰，适合毕设小实验；tshark 方案胜在速度快，适合真实流量验证。

如果脚本跑完发现 flows 数量是 0，先确认 pcap 里有没有 IP 层包，scapy 在读取某些链路层封装时会读不到 IP 层。如果 len_std 全是 0，说明抓包时包长度被网卡截断了，这个特征直接报废，换一个抓包环境重抓比硬抠代码快得多。

2.4 滑动窗口聚合：把流特征变成时间序列基线

流特征是静态快照，但异常检测里另一个常用输入是时间序列。做法很直接：把时间轴切成固定窗口，统计每个窗口里新流数量、总字节数、SYN 包比例。

# 假设2.3产出的df里有时戳列，这里做窗口聚合 df['ts'] = df['duration'] # 占位，实际应从原始pcap取窗口起点 df['window'] = (df['ts'] // 60).astype(int) windowed = df.groupby('window').agg( new_flows=('pkt_count', 'count'), total_bytes=('byte_sum', 'sum'), avg_len=('len_mean', 'mean'), ).reset_index()

逻辑说明：时间戳整除以窗口大小，得到窗口编号，再按窗口做聚合。new_flows 表示这个窗口内新建了多少条流，total_bytes 是窗口内总流量，avg_len 反映包大小均值的变化。这三列就是后续统计基线模型的输入。

参数说明：窗口大小选 60 秒是经验起步值。流量大到校园网出口级别时建议缩到 10 秒或 30 秒，否则检测延迟太高；小规模实验网络可以把窗口放大到 300 秒，让曲线更平滑。判断标准很简单：一个窗口内至少要有几十条流，太少则统计噪声大，太多则异常被摊平。如果聚合出来的曲线毛刺太多，优先加大窗口，而不是上来就做平滑滤波。

3. 公开数据集选型与预处理：NSL-KDD 与 CICIDS2017 的取舍

流量数据自建标签的成本过高，绝大多数毕设会选公开数据集。选哪个数据集不是随便点一个下载，它直接影响预处理写法和最终指标的可信度。

3.1 公开数据集横向对比：从 KDD99 到 CICIDS2017

我先给一张对比表，把四个常见的选择放一起看。表格里很多细节是踩过坑才知道的，比如 KDD99 有大量重复记录，如果直接拿去做训练，模型会过拟合到重复样本上。

选型建议就一句话：主实验用 NSL-KDD，想要撑场面再加一个 CICIDS2017。NSL-KDD 的训练集约 12.5 万条、测试集约 2.2 万条，普通笔记本几分钟就能跑完一个模型，答辩时复现成本低。CICIDS2017 的 80 维双向流特征更贴近现在网络里的 DDoS、端口扫描、暴力破解，但原始文件几十 GB，即便官方 CSV 特征文件也有几百 MB，需要机器内存跟得上。

3.2 NSL-KDD 预处理：标签二元化与 One-Hot 编码

NSL-KDD 的每一行有 41 个特征加一个类别列，类别列里 normal 是正常，其余全是攻击类型。做异常检测课题时我一般先把它转成二分类：正常是 0，异常是 1，这样模型只需要回答“是不是可疑”。

import pandas as pd from sklearn.model_selection import train_test_split df = pd.read_csv('NSL_KDD_Train.csv') df['binary_label'] = (df['class'] != 'normal').astype(int) X = df.drop(['class', 'binary_label'], axis=1) X = pd.get_dummies(X, columns=['protocol_type', 'service', 'flag']) y = df['binary_label'] X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42, stratify=y ) print(y_train.value_counts(normalize=True))

逻辑说明：get_dummies 把 protocol_type、service、flag 这三列字符串转换成 One-Hot 编码。这三列里的 service 字段比较特殊，取值几十种，One-Hot 之后特征维度会从 41 扩到一百多，这是正常的。stratify=y 让训练和测试里正常与异常的占比保持一致，避免随机切分把比例弄偏。

参数说明：random_state 设成 42 只是一个可复现种子，论文里记得写死并公开，后面所有实验都用同一个值。test_size 取 0.2 是常规值，数据规模不大时也可以改成 0.3，差别不大。注意这里用的是随机切分，只适用于样本独立性较强的场景；如果样本本身是连续采集的流量，第 5 章会讲为什么要用时间切分替换它。

3.3 CICIDS2017 读取注意：大文件、时间戳与类别文本

CICIDS2017 的特征文件每一行是一条双向流，类别有 BENIGN 加多种攻击名。读它容易在内存上翻车，我建议用 usecols 只取需要的列，不要一次把 80 列全部载入。

import pandas as pd # 只读指定列，Label是类别，Flow Duration等是典型特征列 cols = [' Flow Duration', ' Total Fwd Packets', ' Total Backward Packets', 'Total Length of Fwd Packets', ' Flow Bytes/s', ' Flow Packets/s', ' Label'] df = pd.read_csv('MachineLearningCSV.csv', usecols=cols) # CICIDS2017的列名前后常有空格，先清洗 df.columns = [c.strip() for c in df.columns] df['Label'] = df['Label'].str.strip() # 清洗无穷值和空值 df = df.replace([float('inf'), -float('inf')], 0).dropna() valid_labels = {'BENIGN', 'DDoS', 'PortScan', 'Brute Force', 'Web Attack'} df = df[df['Label'].isin(valid_labels)] df['binary_label'] = (df['Label'] != 'BENIGN').astype(int) print(df['binary_label'].value_counts())

逻辑说明：usecols 只加载指定列减少内存。列名清洗是因为官方 CSV 里列名前后混着空格，不去掉会找不到列。把 inf 和 NaN 一并处理是这类数据集的常见坑，否则 StandardScaler 会直接报错或产出 NaN。Label 里有很多低频攻击类，我用一个集合把常见类筛选出来，其余丢弃，避免类别太碎。

参数说明：DDoS 和 PortScan 在 CICIDS2017 里样本量最大，这两个类加 BENIGN 已经足够撑起一个二元检测实验。如果机器内存足够，可以把全部 80 维特征读进来做完整实验；内存不足时就按我上面这个精简列方案，效果一样能出，因为那些网络统计列本身就是强特征。

3.4 归一化与不平衡处理：SMOTE 怎么用才安全

流量特征的量纲差异巨大：Flow Duration 是微秒级，包数是个位数，Bytes/s 可能上亿。不做归一化，树模型还好说，神经网络和距离类模型会直接被大数值列带偏。标准写法是 StandardScaler 只 fit 训练集，再 transform 测试集，这步的顺序不能反。

from sklearn.preprocessing import StandardScaler from imblearn.over_sampling import SMOTE scaler = StandardScaler() X_train_s = scaler.fit_transform(X_train) X_test_s = scaler.transform(X_test) print(f'train shape={X_train_s.shape}, test shape={X_test_s.shape}') # 如果异常类占比过低，再用SMOTE，不是必须 smote = SMOTE(random_state=42, sampling_strategy=0.3) X_tr_res, y_tr_res = smote.fit_resample(X_train_s, y_train) print('after smote:', pd.Series(y_tr_res).value_counts().to_dict())

逻辑说明：fit_transform 是“拟合均值和标准差再把训练集转换掉”，test 侧只用 transform，绝不能在测试集上重新 fit。这行顺序写错，第 5 章的第一个坑就来了。SMOTE 在异常类极稀疏时能起平衡作用，但 sampling_strategy 不要设成 1.0，1:1 的平衡会让检测器误认为正常流量和攻击流量一样常见，实际部署时误报爆炸。

参数说明：sampling_strategy=0.3 表示把少数类扩充到多数类的 30%，这是我在异常检测里常用的保守值，既能缓解类别倾斜，又不过度改变原始分布。如果用了 SMOTE，后面评估时必须用原始测试集，测试集不做任何过采样，这一条经常被忘。

4. 检测算法落地：统计基线、孤立森林与自编码器的三条路线

数据准备好了，接下来是核心决策：异常检测算法选哪条路线。我给毕设的建议是不要只做一个模型，而是做一个“基线对照+主力模型+进阶方案”的三角结构，答辩时工作量清楚，性能对比也有得写。

4.1 统计阈值法：10 行代码的 z-score 基线

异常检测最朴素的版本是统计阈值法。对每个特征列计算均值和标准差，z-score 的绝对值大于某个阈值就认为是异常。它的难点不在实现，而在让老师相信它的价值：它是一切复杂模型的“下界参照”。

import numpy as np from scipy.stats import zscore def detect_by_zscore(X, threshold=3.0): zs = np.abs(zscore(X, axis=0)) # 对每一列独立算z-score anomalies = np.any(zs > threshold, axis=1) # 任一特征越界即算异常 return anomalies, zs X_demo = np.random.randn(1000, 5) anoms, zs = detect_by_zscore(X_demo) print(f'anomaly rate: {anoms.mean():.3f}')

逻辑说明：zscore 的 axis=0 表示按列计算，每一列一个均值、一个标准差。np.any 是在做“或”逻辑：任一维度的 z-score 超过阈值就把这个样本标成异常。这个策略偏向高召回，会带来一定误报，但异常检测场景里宁可多报一些，让运营去看。

参数说明：threshold=3.0 对应约 0.3% 的单侧误判率，是正态分布下的理论值。流量数据很少严格正态，我一般会在 2.5 到 3.5 之间扫一遍，用验证集 F1 定。这个扫描技巧放到第 6 章展开。注意 z-score 对不同特征列的尺度天然免疫，所以放在归一化前后结果都一样，这也是我把它当“稳定基线”的原因。

4.2 孤立森林：无监督异常检测的默认起手式

如果不想准备标签，又想比统计基线强，孤立森林（IsolationForest）是性价比最高的选择。它的原理是随机切割特征空间，异常点因为离群，通常只需要很少的切割次数就能被单独切出来，所以“被切得更早”的样本就是异常。sklearn 里直接可用。

from sklearn.ensemble import IsolationForest clf = IsolationForest( n_estimators=300, max_samples=256, contamination=0.05, random_state=42, ) clf.fit(X_train_s) y_pred = clf.predict(X_test_s) # 正常=1，异常=-1 y_pred_binary = (y_pred == -1).astype(int) print(np.unique(y_pred, return_counts=True))

逻辑说明：fit 阶段不需要传入标签，模型在正常数据里学习“什么是孤立点”。predict 的返回值是 1 和 -1，和常见的 0/1 风格不一样，所以要手工映射成 y_pred_binary 再算指标，这一步很容易写漏。

参数说明：contamination 是训练集里异常占比的先验估计，设成 0.05 意味着模型认为大约 5% 的样本是异常。这个值不要靠猜，先用第 5 章提的分数量化方法在验证集上扫。n_estimators=300 是树的数量，一般 200 到 500 之间够用，超过 500 收益递减；max_samples=256 限制每棵树的采样量，数据量大时改得更小能大幅加速。random_state 固定后才能复现对比实验。

4.3 AutoEncoder：用重构误差识别“没见过”的攻击

流量攻击的形态一直在变，监督模型对没训练过的攻击类型识别很差，AutoEncoder 是解决这个问题的常见提法。它只拿正常样本训练，学会用低维编码重建正常的流特征；攻击样本的特征分布和正常差异大，重建误差（MSE）会明显偏高，阈值一卡就能判定异常。

import torch import torch.nn as nn class AutoEncoder(nn.Module): def __init__(self, n_features, hidden=(32, 8)): super().__init__() self.encoder = nn.Sequential( nn.Linear(n_features, hidden[0]), nn.ReLU(), nn.Linear(hidden[0], hidden[1]), nn.ReLU(), ) self.decoder = nn.Sequential( nn.Linear(hidden[1], hidden[0]), nn.ReLU(), nn.Linear(hidden[0], n_features), ) def forward(self, x): return self.decoder(self.encoder(x)) model = AutoEncoder(n_features=X_train_s.shape[1]) optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) loss_fn = nn.MSELoss() # 只用正常样本训练，攻击样本不进训练过程 X_normal = X_train_s[y_train == 0] X_normal_t = torch.tensor(X_normal, dtype=torch.float32) for epoch in range(30): model.train() recon = model(X_normal_t) loss = loss_fn(recon, X_normal_t) optimizer.zero_grad() loss.backward() optimizer.step() if (epoch + 1) % 10 == 0: print(f'epoch {epoch + 1:02d}, loss={loss.item():.4f}')

逻辑说明：模型的瓶颈是 hidden 里最小的 8 维，正常样本的信息必须压缩到这 8 维再解压回来，重建误差就是“这 8 个维度丢了多少信息”的度量。推理时对测试集每个样本计算一次 MSE，MSE 大的判为异常。训练时只喂正常样本，这一步是 AutoEncoder 能识别未知攻击形态的关键，放进异常样本训练会让模型学着去重建攻击，前功尽弃。

参数说明：hidden=(32, 8) 是经验结构，80 维输入用 (64, 16) 更稳，特征少时 (16, 4) 也行。lr=1e-3 是 Adam 的常用起点，loss 不降就降到 1e-4 再试。epoch 先跑 30 轮看 loss 曲线，正常样本量大时可以加 EarlyStopping。batch size 在小数据集上直接用全量也可以，样本多再包 DataLoader 分 batch。

推理阈值部分，实际使用时这样写：

model.eval() X_test_t = torch.tensor(X_test_s, dtype=torch.float32) with torch.no_grad(): recon = model(X_test_t) mse = ((recon - X_test_t) ** 2).mean(dim=1) # 每个样本的重建误差 threshold = torch.quantile(mse, 0.95) # 95%分位数作阈值 anomaly = (mse > threshold).numpy().astype(int) print(f'threshold={threshold:.4f}, anomaly rate={anomaly.mean():.3f}')

逻辑说明：torch.quantile 按分位数选阈值，0.95 表示默认允许 5% 的样本被判异常，这样不依赖对异常比例的强假设。推理时要包在 torch.no_grad() 里，既省显存又避免把梯度计算图存下来。

参数说明：0.95 这个分位同样是起步值，要和统计基线一样在验证集上扫。它的物理意义是“宁可错杀 5%，也不放过潜在攻击”，安全场景的常规取舍。

4.4 三条路线怎么选：对照表与实验顺序

三条路线的定位差异比较明显，我给个直观的对照。

我的实验安排是这样：统计基线先跑通，产出第一个检测率和误报率；孤立森林做主力，调参后作为最终指标；AutoEncoder 作为对未知攻击的补充实验，配合重构误差分布图写进论文。三个方案共享同一套特征和同一份划分，指标之间才可比。

5. 流量异常检测避坑手册：五个让结果翻车的常见问题

5.1 数据泄露：归一化用了全量数据，验证集 AUC 虚高到 0.99

现象：测试集 AUC 高达 0.99，换成真实流量后指标立刻崩盘，准确率跌到六成以下。

原因：最常见的写法是先把完整数据集做成 DataFrame，然后 fit_transform 整份数据再切分，StandardScaler 在计算均值方差时偷偷“看”了测试集的信息。测试集的分布被平移到了训练集附近，模型等于提前知道了考试答案，这就是数据泄露。

解决：先切分、后 fit，让归一化参数只学到训练集。更稳妥的做法是把整个流程包进 Pipeline，切分和缩放都在同一个对象里完成，不会漏步。

from sklearn.pipeline import make_pipeline from sklearn.ensemble import IsolationForest pipe = make_pipeline(StandardScaler(), IsolationForest(random_state=42, contamination=0.05)) pipe.fit(X_train) # 内部先缩放再训练 y_pred = pipe.predict(X_test)

逻辑说明：make_pipeline 把缩放器嵌入管道，fit 时只接触训练数据，测试数据只在 predict 时经过已经学好的转换。这个写法把数据泄露的概率降到最低，我现在的实验脚本统一用这招。

5.2 类别不平衡：正常流量占 99%，模型全猜正常也有 97% 准确率

现象：打印 accuracy 是 0.97，看起来很好，但查看混淆矩阵，攻击样本的召回率只有 0.02，所有攻击几乎全漏了。

原因：流量数据天然是极度不平衡的，正常流量占比常超过 95%。准确率这个指标在高度不平衡场景下没有意义，模型的“高准确率”来自把所有样本都判成正常。

解决：不要用 accuracy 做主要指标，看 Precision、Recall、F1，再看 PR-AUC。sklearn 一条命令就能出全：

from sklearn.metrics import classification_report # y_pred_binary是模型输出的0/1，y_test是真实标签 print(classification_report(y_test, y_pred_binary, target_names=['normal', 'attack']))

逻辑说明：classification_report 同时输出精确率（报出来的有多少是攻击）、召回率（真攻击里抓到了多少）和 F1，这三项才能反映检测器的真实水平。安全场景一般更多看召回率，宁可多报也不放过。

5.3 时序泄漏：随机切分把同一段攻击拆进了训练集和测试集

现象：模型在测试集上表现不错，但把模型换到另一天抓的流量上几乎完全失效，连重复出现过的攻击类型都认不出来。

原因：流量样本不是孤立的，同一时刻的扫描或 DDoS 会产生成百上千条相似样本。用 train_test_split 随机切分时，这些相似样本会同时落进训练集和测试集，模型相当于“见过”测试集。它不是学到了一般规律，而是记住了特定 IP 和端口组合。

解决：改用时间顺序切分。先按时间戳排序，前 80% 做训练，后 20% 做测试，或者用 GroupKFold 按会话分组切分。

# 假设特征表里有ts列（流开始时间） df_sorted = df.sort_values('ts').reset_index(drop=True) split_idx = int(len(df_sorted) * 0.8) train = df_sorted.iloc[:split_idx].copy() test = df_sorted.iloc[split_idx:].copy() print(f'train time span: {train["ts"].min()} ~ {train["ts"].max()}') print(f'test time span: {test["ts"].min()} ~ {test["ts"].max()}')

逻辑说明：时间切分的核心是确保训练集的时间范围完全在测试集之前。打印出两段的时间跨度，是判断是否切错了的最快方式。注意顺序一定是先排时间再切分，直接给 DataFrame 排序后随手取前 80% 行是不对的。

5.4 特征陷阱：源 IP、目的 IP、端口直接当特征喂给模型

现象：训练集 AUC 是 1.0，但把攻击工具的源 IP 从 192.168.1.10 换成 10.0.0.5，模型立刻把所有攻击都漏了。

原因：IP 地址和端口是离散标识符，模型完全不理解它们之间的语义关系，只能死记硬背“哪个 IP 对应攻击”。流量分析落地的第一课就是不能把标识符当特征。很多同学觉得加这些列能提高准确率，其实是在让模型背答案。

解决：把这些列去掉，或者把标识符转成聚合统计量。比如窗口内某个 IP 出现的次数、某个目的端口被访问过的不同源 IP 数量，这类统计特征表达的是“行为”而不是“身份”。

5.5 阈值拍脑袋：contamination 设成 0.1，每天误报几千条

现象：孤立森林设定异常占比 0.1 后，测试集上误报率接近 10%，安全运营告警刷屏，没人愿意看。

原因：contamination 应该是对真实异常比例的估计，而不是随便填的默认值。真实流量里异常比例可能只有 0.01，模型按 10% 去切，全是在抓正常流量的“边缘分子”。

解决：用模型输出分数来定阈值，而不是直接定比例。孤立森林的 decision_function 输出的分数本身就代表异常程度，在验证集上按分数排序，选 F1 或误报率最合理的那个切点。

# 孤立森林的异常分数，越低越异常 scores = clf.decision_function(X_test_s) threshold = np.percentile(scores, 5) # 取分数最低的5%为异常 y_pred_binary = (scores < threshold).astype(int) print(f'score range: {scores.min():.3f} ~ {scores.max():.3f}, threshold={threshold:.3f}')

逻辑说明：decision_function 的分数表征样本偏离正常分布的强度，分数越低越异常，所以阈值取低分位的 5%。percentile 的参数可以跟在验证集上扫出来的结果调整。这个方法把“先验的比例”变成一个“可调参数”，对流量这种分布变化快的数据更稳。

6. 从能跑到能用：分数分布可视化与阈值校准

不管选哪条算法路线，模型输出到最后都是一列分数。分数是连续值，它浓缩了“这个样本有多异常”的全部信息，也是选阈值时唯一能依靠的证据。所以我的习惯是：任何检测器训练完，第一件事不是打印指标，而是画出分数的分布直方图，肉眼确认有没有区分度。

import matplotlib.pyplot as plt # scores来自孤立森林或AutoEncoder的重建误差 plt.figure(figsize=(8, 4)) plt.hist(scores[y_test == 0], bins=50, alpha=0.6, label='normal') plt.hist(scores[y_test == 1], bins=50, alpha=0.6, label='attack') plt.axvline(threshold, color='red', linestyle='--', label=f'threshold={threshold:.3f}') plt.xlabel('anomaly score') plt.ylabel('count') plt.legend() plt.tight_layout() plt.savefig('score_distribution.png', dpi=150)

这段代码里，我把正常样本和攻击样本的分数分两组画在一张图上，再补上当前阈值线。如果两个分布有明显分开，说明特征有区分度，阈值线卡在谷底是最理想的；如果两个分布几乎重叠，说明特征没选好，再调模型结构的收益也不大，回到第 2 章改特征才是正路。

实际跑下来最常见的状态是：正常样本的分数集中在低区，攻击样本拖了一条长尾到高区。这时候阈值线的位置就是取舍的位置，往左移漏报多，往右移误报多。我一般在验证集上从左往右扫百分位，每次记录 F1，取最高点作为最终阈值，这个数直接用在测试集上，测试集绝不参与调阈值。

回想我自己做这类项目的经历，最亏的一段就是把时间全耗在 SMOTE 参数和三层网络结构上，后来发现把分数分布图挂在屏幕边、按图调阈值，比瞎试快得多。这个项目真正难的不是写出模型，而是让你的模型在另一个时段、另一批主机上还能站得住。把数据链路做扎实，把阈值选得有据可依，结果自然能说服人。希望帮到你。

本文还有配套的精品资源，点击获取