基于LeNet-AlexNet与GAP融合模型的加密流量识别实战解析

简介：基于深度学习的加密流量识别模型源码，融合LeNet、AlexNet与全局平均池化（GAP）结构，面向网络安全研究人员、算法工程师及高校相关专业学生，适用于恶意流量检测、网络态势感知等场景。项目完整提供可运行的Python工程，共29个文件、约73KB，其中20个Python源文件覆盖数据处理、模型构建、训练评估等环节，另有配置文件、说明文档与许可证文件，目录按EncryptedTrafficAnalysis、AlexNet、GAP等模块划分，结构清晰。目前已有638人学习，源码中不仅包含多套经典网络结构的实现，还包含数据集切分、预处理及指标度量等工具脚本，便于读者对照理解端到端的流量识别流程，可在本地快速复现实验，并针对具体任务调整网络层与超参数，为加密流量的智能分析与安全防护提供扎实参考。

1. 基于深度学习的加密流量识别，为什么最终要融合 LeNet、AlexNet 和 GAP

基于深度学习的加密流量识别，表面看是给流量打标签，实际上从数据准备到模型融合再到上线，每一步都有坑。流量是加密的，解不开载荷，只能从字节分布、首包结构这些表层特征推断应用类型。把一条流的前 1024 字节转成灰度图喂给卷积神经网络，是被验证过很多次的成熟思路，但单用 LeNet 或单用 AlexNet 都有短板：一个细节抓得细但视野小，一个感受野大但参数量多。这个源码把 LeNet、AlexNet 和 GAP 拼成双分支融合结构，保留两种粒度特征的同时压住参数量。适合做流量分类毕设、或想在网关设备上做应用识别的工程师照着复现、改自己的数据集。

2. 加密流量识别数据准备：从 pcap 到 32×32 与 224×224 灰度图

2.1 为什么加密流量能转成图像：字节级指纹与 CNN 的适配性

加密流量识别的基础假设是：应用虽然加密了载荷，但它留下的字节模式仍然有规律。TLS 握手里的 record 类型、版本号、长度字段、支持的 cipher suite 列表长度、SNI 长度，QUIC 首包的固定头部字段，这些都以明文形式出现在流的开头，而且不同应用因为实现方式、依赖库版本、后台 API 的差异，会让这些字节的组合在同类内保持一致的差异。把一条流的前 1024 个字节按行填充成一张 32×32 的灰度图，这些差异就变成了图像上的竖条纹和块状纹理。

CNN 在这里的核心优势是平移不变性：网络不要求精确定位某个特征出现在第几行第几列，只要这种模式出现过就能激活对应的卷积核。这对流量数据尤其重要，因为抓包环境、MTU、路由策略的变化会让同类流量的起始偏移产生小幅漂移。常见的做法是取每条流的前 512～1536 字节，我这里定成 1024：能覆盖 TLS 握手核心区，通常在前 200～400 字节，又不至于把后面大段的加密载荷噪声放进来。

数据采集阶段最容易忽略的是标签纯净性。我一般会准备一台干净的机器或虚拟机，同一时间段只跑一类应用，抓 20～30 分钟，然后手动确认该时段内没有其他后台流量混进来。做 6 分类的话，建议至少覆盖聊天、视频流、网页浏览、文件下载、语音通话五类真实业务，加一个其他兜底类。每类流的数量建议不少于 5000 条，少于这个量级，后面 GAP 再能扛过拟合也救不回来。

流量方向的处理有个选择：只取单向，还是双向合并。按五元组聚合后双向合并，把两个方向的首包字节按抓包时间穿插拼接，模型能看到完整的握手交互序列，ServerHello、证书、密钥交换都在一个上下文里。代价是方向信息被混合，对上下行行为差异很大的类别，比如 P2P、视频上行，不太友好。我一般双向合并为主，如果目标类别里有强方向差异的应用，就两个方向各存一张图，让模型自己决定用哪个。

2.2 基于 scapy 的流切分与 1024 字节定长截断脚本

切流是整条链路里最容易出错的一步。直接对每条流取前 1024 字节，会遇到三个实际问题：大 pcap 一次性读入内存会爆；五元组方向不一致导致同一会话被拆成两条流；大量纯 ACK 包没有载荷，却不能简单跳过。下面这个脚本把三个问题都处理了：

from scapy.all import PcapReader, IP, TCP, UDP, Raw def pcap_to_flows(pcap_path, max_bytes=1024): flows = {} with PcapReader(pcap_path) as reader: for pkt in reader: # 流式读取，不把整个pcap载入内存 if IP not in pkt: continue if TCP in pkt: proto, sport, dport = 6, pkt[TCP].sport, pkt[TCP].dport elif UDP in pkt: proto, sport, dport = 17, pkt[UDP].sport, pkt[UDP].dport else: continue # 双向流：五元组排序后，A->B 和 B->A 进入同一条流 a, b = (pkt[IP].src, sport), (pkt[IP].dst, dport) if a < b: key = (a[0], a[1], b[0], b[1], proto) else: key = (b[0], b[1], a[0], a[1], proto) flows.setdefault(key, b"") if Raw in pkt and len(flows[key]) < max_bytes: flows[key] += bytes(pkt[Raw].load) return flows

PcapReader 是 scapy 的流式读取接口，一个包一个包地迭代，扫描 1GB 的 pcap 内存占用也只有几百 MB，这是血泪经验——我第一次用 rdpcap 读大文件，16GB 内存的机器直接卡死。协议号写成 6 和 17 是为了后续做统计时避免字符串比较。最关键的是五元组排序那三行：元组比较按元素逐个进行，a < b 保证了同一会话两个方向都映射到同一个 key，否则一条流会被拆成两半，样本数虚高一倍，每半条流的有效信息却被稀释。纯 ACK 包没有 Raw 层，不影响最终特征，因为零填充会让它退化成一条几乎全黑的横线，对分类没有贡献。

注意：flows 字典会随着流数量增长而占用内存，扫描超大 pcap 时按时间窗口分块处理，每块处理完就落盘并清空字典。

还有一个值得调的参数：会话超时。五元组相同但间隔几小时的流量，其实已经是两次独立连接了，很多实现会加一条规则，超过 60 秒无新包就切成新流。在我的抓包场景里，应用都是一次性跑完，这个规则影响不大，但如果你抓的是长时间在线业务，建议切流时记录每个 key 的最后活跃时间，超过阈值就重开一条流。

def flow_to_padded_bytes(flows, max_bytes=1024): X = [] for key, raw in flows.items(): raw = raw[:max_bytes] # 截断超长流 if len(raw) < max_bytes: raw = raw.ljust(max_bytes, b"\x00") # 尾部补零 X.append((key, raw)) return X

截断和补零要一起讲：用 ljust 在尾部补零，保持原有字节的起始偏移不变；如果在头部补零，等于把整条流的指纹往后推了 N 字节，跟别人对比代码时结果会完全对不上。前 1024 字节这个参数不敏感，我试过 512、784、2048，F1 波动在 1 个百分点以内，选 1024 是因为它能正好 reshape 成 32×32，没有视觉上的补边干扰。

2.3 一键生成双尺度图像数据集

数据目录按类别到样本文件的层级组织，每类流量一个文件夹，这一步同时生成训练、验证、测试三份目录，切分逻辑放在后面第 5 章讲，这里只负责把每条流落盘：

import os import numpy as np def save_flow_images(flows, out_dir, size=32): os.makedirs(out_dir, exist_ok=True) for i, (key, raw) in enumerate(flows.items()): arr = np.frombuffer(raw, dtype=np.uint8).reshape(size, size) np.save(os.path.join(out_dir, f"flow_{i:06d}.npy"), arr)

这里只保存 32×32 的小图，224×224 的大图在 DataLoader 里现场用 cv2.resize 生成。两个原因：磁盘占用直接少一半以上；同一份小图可以用不同插值方式生成大图，相当于做了一次廉价的数据增强。插值方式我推荐 INTER_LINEAR，双线性会把相邻字节的像素值做平滑，梯度信号更连续；INTER_NEAREST 保留锐利块状边界，对字节边界敏感的类别更友好。我自己做的对比实验里，两者 F1 差别不大，但双线性收敛更平滑，所以默认用它。

保存成 npy 而不是 jpg 是另一个细节：JPEG 是有损压缩，会把相邻像素的微小差异抹掉，流量图里很多信息恰恰藏在这些微小差异里。npy 是原始字节的直接映射，零信息损失，训练加载速度也不慢。落盘之后别急着训练，先数一下每个类别目录下的文件数，记录成一张清单，这一步能提前暴露采集阶段漏抓、混抓的问题。

3. 融合模型内部拆解：LeNet、AlexNet 与 GAP 各自的角色

3.1 LeNet 分支：5×5 小卷积核抓局部字节关联

LeNet-5 是 1998 年 Yann LeCun 提出的卷积网络，最初的任务是手写体数字识别。它的结构非常朴素：两个 5×5 卷积层、两个 2×2 池化，再接全连接层做分类。输入是 32×32 的单通道灰度图，这个尺寸和我们 1024 字节的流量图几乎是为彼此准备的。5×5 的卷积核一次覆盖 5 个字节的横向范围，能捕捉相邻字节的组合模式——比如 TLS record 头里 type（1 字节）、version（2 字节）、length（2 字节）恰好就是 5 个字节，这种局部结构被第一层卷积核直接收入囊中。

需要强调，LeNet 在今天已经不算先进了，单独拿它做流量识别的结果一般，但它的设计思想在融合模型里依然成立：小卷积核、逐步池化、通道数从少到多。在双分支结构里，LeNet 分支的任务就是死磕细节，用 6 通道和 16 通道的小特征图，输出一个 16 维的全局描述，代表这条流里最容易区分的局部字节模式有哪些。

源码没有照搬完整的 LeNet-5，而是砍掉了后面的两层全连接，只保留卷积加池化的特征提取部分。原因是 LeNet-5 的全连接层占了绝大多数参数，对 1024 字节这么小的输入没有必要，而且加密流量数据集通常只有几万到几十万条流，参数越多越难训。这个借骨干、丢全连接的做法，在后面 AlexNet 分支上同样适用，也是整个融合模型能保持轻量的根本原因。

3.2 AlexNet 网络结构详解：11×11 大感受野与 ReLU 带来的全局结构信息

AlexNet 是 2012 年 ImageNet 竞赛的冠军模型，它给深度学习带来的三个关键改动是：11×11 的大卷积核配合 stride=4，让第一层就能看到输入的大部分区域；ReLU 激活函数解决了 sigmoid 和 tanh 在深层网络里的梯度衰减；Dropout 在训练时随机丢弃神经元抑制过拟合。在流量识别里，11×11 大核意味着一次横跨 11 个字节，配合 stride=4 的快速下采样，第一个卷积层输出的 55×55 特征图，描述的是整条流前 1024 字节里哪些块状区域存在握手指纹这种粗粒度结构，恰好弥补了 LeNet 分支只见树木不见森林的盲区。

AlexNet 原版有 5 层卷积和 3 层全连接，总参数量约 6000 万，其中绝大多数堆在最后 3 层 FC 上。公开的 AlexNet 网络结构详解，网上很多博客都给出过这个数字和逐层参数分布。我们只借用它的卷积骨干，从第 5 层卷积输出 256 通道特征图开始，就切到 GAP 和分类器，全连接层一概不要。这样参数量从几千万掉到几百万，在小数据集上的训练时间、显存占用、过拟合风险同时降下来。

顺便说一句 ReLU 在流量图上的表现：流量灰度图的像素值分布很稀疏，大量区域接近全黑，ReLU 会把负响应直接清零，让网络把注意力集中在少数有信息量的字节区，这比 tanh 的饱和特性更适合这种稀疏输入。模型里还有一个容易被忽略的位置，就是 GAP 之后的 Dropout(0.5)，它只作用于拼接后的 272 维向量上，对两个分支的卷积特征提取不产生干扰，这是刻意为之——Dropout 放在融合点之后，能让分类器学会不依赖某个单一通道的响应。

3.3 GAP 替换全连接层：降参数、抗过拟合的两个直接收益

GAP（全局平均池化）来自 2013 年的 Network in Network，操作本身一句话能讲完：对每个通道的特征图做空间平均，把 H×W 的二维响应压成一个数值，N 个通道就得到 N 维向量，然后直接接分类器。它替代的是 Flatten 加全连接那一大坨参数。

第一个收益是参数量的量级变化。拿 AlexNet 分支举例：最后一层特征图是 256×6×6，如果 Flatten 后接一个 512 维的全连接，光这一层就是 256×36×512，约 471 万参数；换成 GAP 后，特征从 9216 维压缩到 256 维，接分类器只需要 256 乘类别数。少了两个数量级，训练时过拟合的压力小很多。第二个收益是输出向量的语义：GAP 之后每个维度代表某个卷积核在整张图上的平均响应强度，是一个有统计含义的量，而不是全连接层里不可解释的加权组合。

在双分支融合里，GAP 还有一个容易被忽略的作用：把两个分支的输出统一到通道维向量这个可比较的形态。LeNet 分支压成 16 维，AlexNet 分支压成 256 维，拼接成 272 维再分类。如果不做 GAP 直接 Flatten，LeNet 分支的特征是 16×6×6=576 维，AlexNet 分支是 9216 维，拼接后细节信息会被全局信息淹没，融合就名存实亡了。GAP 让两个分支在融合时拥有大致对等的发言权，这也是为什么这个结构能同时吃到两种粒度的特征。

关于融合后的分类器还有一点：272 维向量之后只接一层 Linear。这个分类器理论上可以用任意结构替换，比如两层 MLP 加 ReLU，但实测单层 Linear 已经够用，因为前面两个分支已经完成了绝大部分特征提取，分类器只需要做一个线性决策边界。换更复杂的分类器通常只会让验证集 F1 原地踏步，训练时间倒是实打实地涨。

4. 基于 PyTorch 的融合模型源码：环境、网络定义与训练脚本

动手前先交代运行环境：PyTorch 2.x 加 CUDA 11.8 这个组合最省心，配套依赖是 scapy、opencv-python、scikit-learn 和 numpy。硬件上，一张 8GB 显存的显卡就能跑，数据集不大时 CPU 也能训，只是时间从十几分钟变成一两个小时。整个源码按功能拆成四个模块：

encrypted_flow_id/ ├── data_prep/pcap_to_flow.py # pcap 切流 ├── data_prep/flow_to_npy.py # 字节转 32×32 npy ├── models/dual_branch_net.py # 融合网络定义 ├── train.py # 训练 + 早停 + 评估 └── predict.py # 单条流/整条流推理

4.1 双分支网络结构定义

网络定义有两个需要格外注意的设计点。第一，两个分支输入尺度不同，forward 必须接收两个张量，这一点在导出 ONNX 和使用 DataLoader 时都要同步处理。第二，全连接一律由 GAP 替代，最后的分类器只有一层 Linear，参数量小到可以忽略。

import torch import torch.nn as nn class FlowDualBranchNet(nn.Module): """融合 LeNet + AlexNet 卷积骨干 + GAP 的加密流量识别模型""" def __init__(self, num_classes=6): super().__init__() # LeNet 风格分支：输入 32×32 灰度图 self.lenet_branch = nn.Sequential( nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(), nn.MaxPool2d(2), # 32×32 -> 16×16 nn.Conv2d(6, 16, kernel_size=5), # 16×16 -> 12×12 nn.ReLU(), nn.MaxPool2d(2), # 12×12 -> 6×6 ) # AlexNet 风格分支：输入 224×224 灰度图 self.alexnet_branch = nn.Sequential( nn.Conv2d(1, 64, kernel_size=11, stride=4, padding=2), nn.ReLU(), nn.MaxPool2d(3, stride=2), # 55×55 -> 27×27 nn.Conv2d(64, 192, kernel_size=5, padding=2), nn.ReLU(), nn.MaxPool2d(3, stride=2), # 27×27 -> 13×13 nn.Conv2d(192, 384, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(256, 256, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(3, stride=2), # 13×13 -> 6×6 ) # GAP 将两个分支压成通道维向量，再融合分类 self.gap = nn.AdaptiveAvgPool2d(1) self.dropout = nn.Dropout(0.5) self.classifier = nn.Linear(16 + 256, num_classes) def forward(self, x_small, x_large): feat_s = self.gap(self.lenet_branch(x_small)).flatten(1) feat_l = self.gap(self.alexnet_branch(x_large)).flatten(1) feat = torch.cat([feat_s, feat_l], dim=1) return self.classifier(self.dropout(feat))

LeNet 分支第一个卷积层的 padding=2 是为了让 32×32 输入经过 5×5 卷积后保持原尺寸，第二个卷积层故意不加 padding，让特征图从 16×16 缩到 12×12，再池化到 6×6。AlexNet 分支沿用原版的卷积核尺寸和池化参数，3 个 MaxPool2d 都是 kernel=3、stride=2，比 2×2 池化下采样更激进，能更快扩大感受野。两个分支最终都输出 6×6 的空间分辨率，这是刻意对齐的，将来如果你想在 GAP 之外并行一个 SPP 或者保留部分空间信息，两个分支的特征图可以直接拼接。

还要说明为什么不加载 ImageNet 预训练权重。AlexNet 在 ImageNet 上的预训练是在自然图像上完成的，而流量灰度图没有边缘、纹理之外任何共享语义，把 ImageNet 学到的卷积核搬过来不仅没帮助，前面几层核的响应分布还会与流量数据冲突。实测直接从头训练比加载预训练权重收敛更快。深度学习模型不是所有场景都适合迁移学习，流量图就是典型反例。

4.2 数据加载与训练超参数

数据加载的核心是同时对双输入做流水线：小图直接从 npy 读，大图现场 resize。这里有一个容易被忽略的约束：训练和推理时用的插值方式必须一致，否则输入分布就变了。

import os import cv2 import numpy as np import torch from torch.utils.data import Dataset class FlowDataset(Dataset): def __init__(self, root, small=32, large=224): self.paths, self.labels = [], [] for idx, cls_name in enumerate(sorted(os.listdir(root))): cls_dir = os.path.join(root, cls_name) for f in os.listdir(cls_dir): if f.endswith(".npy"): self.paths.append(os.path.join(cls_dir, f)) self.labels.append(idx) self.small, self.large = small, large def __len__(self): return len(self.paths) def __getitem__(self, i): arr = np.load(self.paths[i]).astype(np.float32) / 255.0 # (32,32) small = torch.from_numpy(arr).unsqueeze(0) large = cv2.resize(arr, (self.large, self.large), interpolation=cv2.INTER_LINEAR) large = torch.from_numpy(large).unsqueeze(0) return small, large, self.labels[i]

训练时损失函数用带类别权重的 CrossEntropyLoss：先统计每个类别的样本数，权重取样本数的倒数再归一化。优化器默认 Adam，学习率 1e-3，50 个 epoch，batch size 64。我一般会在主指标上做早停——验证集 macro-F1 连续 8 个 epoch 不提升就停，同时每次验证后把当前最优权重另存一份。早停和最优权重备份就是给模型留的后悔药，线下多训练几分钟，省掉线上回滚的半天。数据增强方面，流量图不要做随机裁剪，那会破坏字节偏移语义；可以做的是随机平移 1～2 个像素和少量高斯噪声，模拟抓包抖动。

类别不均衡严重时，比如最大类是最小类的 50 倍以上，光加权 loss 可能不够，可以再叠加 WeightedRandomSampler 做训练集采样，或者把损失换成 Focal Loss，gamma 取 2。这两招都只改数据加载和 loss，不动网络结构，先试它们，最后再考虑加数据。

4.3 单条流推理：与训练完全一致的数据管线

推理输入是 pcap 里实时切出来的一条流，字节处理必须和训练时完全一致：同样截断到 1024、同样尾部补零、同样 reshape、同样的插值方式。哪怕只差一个像素，结果都会对不上。

def predict_one_flow(raw_bytes, model, device, large=224): raw = raw_bytes[:1024].ljust(1024, b"\x00") arr = np.frombuffer(raw, dtype=np.uint8).astype(np.float32) / 255.0 small = torch.from_numpy(arr).unsqueeze(0).unsqueeze(0).to(device) large_arr = cv2.resize(arr, (large, large), interpolation=cv2.INTER_LINEAR) large = torch.from_numpy(large_arr).unsqueeze(0).unsqueeze(0).to(device) model.eval() with torch.no_grad(): logits = model(small, large) prob = torch.softmax(logits, dim=1) return prob.argmax(dim=1).item(), prob.max().item()

返回值是类别索引和置信度。置信度这个值在单条流预测里只是参考，但到了流级投票阶段就很重要——低于阈值（比如 0.6）的预测直接弃权，避免低质量窗口污染整条流的决策。批量推理的优化点是显存利用率：把多条流拼成一个 batch 同时过模型，吞吐能比逐条推理高一个量级，这在网关设备上做在线识别时是必须的。

提示：训练和推理的数据管线必须共用同一套预处理函数，不要在推理脚本里重写一遍 resize 和补零逻辑，两端一旦漂移，线上精度会莫名其妙地掉好几个点。

5. 加密流量识别模型实战避坑：数据泄漏、类别失衡与训练翻车排查

5.1 数据泄漏：按包切分导致测试集虚高

现象：训练准确率 98%，验证集也有 97%，模型看起来近乎完美，但部署到新抓的流量上，准确率直接掉到 70% 出头，上线当天就被打回原型。

原因：数据集是按单个样本随机切分的，同一个五元组流的前一半包进了训练集、后一半进了测试集。同一条流相邻包的前 1024 字节高度相似，模型实际是在背这半条流的字节，而不是在学习应用类别的规律。这是流量识别里最隐蔽、杀伤力最大的数据泄漏，除了换数据没有后悔药。

解决：切分前先按五元组聚合出 flow_id，用 sklearn 的 GroupShuffleSplit 按 flow_id 分组切分，保证一条流整体只出现在一个集合里：

from sklearn.model_selection import GroupShuffleSplit # flow_ids 是与样本一一对应的五元组 key 列表 gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42) train_idx, val_idx = next(gss.split(np.zeros(len(flow_ids)), groups=flow_ids))

groups=flow_ids 保证同一五元组的所有样本进入同一个集合。更进一步的做法是按采集时间排序，取前 80% 时段训练、后 20% 验证，这种时序切分能提前暴露跨时段掉点的问题，见第 5.5 条。

5.2 GAP 把位置信息全部抹平，部分类别召回率骤降

现象：把全连接层换成 GAP 后，过拟合确实减轻了，但某几个类别的召回率降了 8～10 个点，尤其是那些指纹稳定出现在流开头固定偏移的协议。

原因：GAP 把整张特征图平均成一个值，特征出现在哪里的信息全部被丢弃。对自然图像这通常是优点，物体在画面里位置无关，分类不该依赖坐标；但对流量图，TLS ClientHello 就是固定在流开头的偏移区域出现，位置本身就是强特征，GAP 把它抹平了。

解决：在 GAP 之外并行保留一条局部最强响应路径。具体做法是把某个分支最后一层特征图做 2×2 最大池化后展平，与 GAP 向量拼接；或者把纯 GAP 换成 SPP（空间金字塔池化），在不同尺度上做池化，既保留全局平均的鲁棒性，又保留响应位置的分布信息。我自己的对比里，GAP 加局部 max-pool 拼接比纯 GAP 高 1.5～2 个点，代价是分类器输入维度多出几千，对总体参数量影响不大。

5.3 reshape 方向不一致：同一份数据复现不出别人的精度

现象：同一个数据集、同一个网络结构，A 复现出 93%，B 只有 90%，两边源码对了好几遍找不出差别，最后发现是图像生成时字节填充方向不一样。

原因：np.frombuffer 默认按行优先填充，这是既成事实，但有人 reshape 后做了转置，有人先按包切再按时间穿插。两种做法在视觉上只差一个旋转，对 CNN 来说却是完全不同的输入分布，精度差几个点很正常。这类问题最容易在换人接力开发时出现，属于典型的管线对了、约定没对。

解决：在代码里固化约定——raw 直接 .reshape(32, 32)，不做 transpose、不 swapaxes，把行优先、行内从左到右对应流起始字节写进数据目录的 README。跟别人对比效果前，先取一张 npy 做像素级 diff，np.array_equal(a, b) 一行代码，能避免一整天的无效排查。这类结论经常被当成玄学，但这一条有明确的机制，值得认真对待。

5.4 类别严重不均衡：准确率虚高，小众类别 F1 几乎为零

现象：整体准确率 90% 以上，打开混淆矩阵却发现，网页和视频两个大类几乎全对，音频通话、P2P 这类小众类别的 F1 只有 0.2 左右，训练 loss 还持续震荡。

原因：真实网络的流量天然是长尾分布，HTTPS 网页和视频流占绝对大头。如果用 accuracy 做指标，模型只要把所有样本都预测成大类别就能拿高分，于是它确实就这么干了——优化目标决定了行为。

解决：主指标换成 macro-F1 或加权 F1，别再用 accuracy 自欺欺人。损失函数用带类别权重的 CrossEntropy，权重取 1 除以样本数并归一化；或者用 WeightedRandomSampler 做均衡采样，让每个 batch 里各类别大致等量出现。对小类别做复制过采样时注意倍数别超过 5 倍，否则模型会逐条背诵少数类样本，训练集 F1 接近满分，验证集立刻打回原形。

5.5 跨时段数据漂移：上午训的模型，下午就掉点

现象：上午抓的流量训练完，下午在同一网段新抓的流量上测试，准确率掉了 8～15 个点；换个办公区或者校园网段，掉得更多。

原因：应用会升级，TLS 版本和 cipher suite 的分布会变，抓包位置不同导致 MTU 行为不同，字节分布整体在漂移。随机切分的验证集测的是同分布数据，完全掩盖了时序漂移的影响，模型其实是在一个静止的切片上优化的。

解决：数据切分强制按时间顺序，前段训练后段验证，让验证集替你提前挨打。线上部署后，周期性抓一小批新流量做增量微调：学习率降到 1e-4，只训练最后分类器，或者全量微调 5～10 个 epoch。这个维护节奏比隔几个月重新训一次模型靠谱得多，也是把流量识别模型真正跑成长跑的唯一办法。

6. 验证融合模型是否真的学到了东西：混淆矩阵、Grad-CAM 与流级投票

模型训完先别急着部署，花半小时做三件事，能省下后面几天的排查时间。

第一，看混淆矩阵里哪些类别互相混淆。视频流和网页都走 HTTPS/QUIC，字节模式接近，如果它们频繁互相误判，说明仅靠前 1024 字节的图像特征到了瓶颈，该考虑把包长序列、到达间隔拼进特征向量，或者直接做流级决策，而不是继续折腾网络结构。

第二，用 Grad-CAM 把模型注意力画出来。对 AlexNet 分支最后一个卷积层的特征图做梯度加权平均，生成热力图叠加到 224×224 输入上。正常模型会把注意力集中在流开头的握手区，也就是前 100～200 字节的位置；如果热力图均匀散在整张图上，说明模型没学到有效特征，回头查数据泄漏和预处理。Grad-CAM 是打开深度学习黑匣子最直观的手段，也是汇报时解释模型看了什么最有说服力的证据。

第三，做流级投票。一条流取前 K 个包分别生成图像、分别预测，最后取多数票。单包字节噪声很大，一次预测的置信度说明不了问题，但多数票能把噪声压下去：

def predict_flow_voting(packets, model, device, k=5, conf_thr=0.6): preds = [] for i in range(min(k, len(packets))): label, conf = predict_one_flow(packets[i], model, device) if conf >= conf_thr: preds.append(label) # 低置信度样本弃权，不参与投票 if not preds: return -1, 0.0 # 全部弃权，交给上层规则兜底 winner = torch.mode(torch.tensor(preds)).values.item() return winner, preds.count(winner) / len(preds)

导出 ONNX 部署到网关时，记得给 torch.onnx.export 传两个 dummy 张量固定双输入尺寸，配合 int8 量化模型体积能压到四分之一左右，这个体量下单条流推理可以跑到毫秒级，具备实时识别的落地条件。

这两年做流量识别，我最大的教训是：调网络结构的时间投入，收益远不如花在数据切分方式、字节填充约定和类别均衡上。融合模型带来的增量是真实可靠的，但决定上限的是前面的数据管线。先把数据管明白，再回头微调网络，这个顺序不要反过来。希望帮到你。

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