企业官网建设流程全解析

简介：面向恶意软件检测入门与进阶实践的卷积神经网络项目资料包，适合具备一定Python与深度学习基础、希望把卷积网络用于二进制文件分类的安全学习者与研究人员。压缩包共8个文件、约3.62MB，包含2个Python脚本、1个H5模型文件，以及依赖清单、README说明、LICENSE和部署启动配置等；脚本侧可对应数据处理、模型训练与服务入口，H5文件便于直接加载已训练模型进行推理验证，依赖清单则帮助快速还原运行环境。已有206人学习下载。项目围绕样本预处理、卷积特征提取、训练验证、指标评估和部署更新展开，读者可借此理解恶意与良性软件的分类流程，参考components模块组织代码，结合准确率、精确率、召回率和F1分数完善实验，并借鉴迁移学习与模型优化思路，形成可复现的安全检测实践。

1. 从告警队列说起：一个把二进制变成图片的检测器

上个月帮一个做终端安全的小团队看他们的告警队列，几千条待判样本，两个人轮班看，眼睛都花了。他们的想法很朴素：把可执行文件按字节画成一张灰度图，同一家族的样本纹理往往相似，直接交给 CNN 做图像分类，先粗筛一遍再人工复核。这份 Malware-detection-using-CNN 就是这条思路的完整 Python 实现，从二进制读取、灰度图生成、数据集切分，一路到卷积网络训练和单文件推理。

它适合两类人：手上有一堆样本、想先搭个能跑的粗筛模型的安全开发；以及想找一个端到端深度学习项目练手的 Python 工程师。下面按我实际跑通的顺序拆，先说架构，再说数据怎么造，最后说怎么改。

2. 架构与技术选型：五层流水线怎么切

2.1 为什么把可执行文件当图片看

传统做法是提特征：字节 n-gram、PE 头字段、导入表、节区熵，再喂给 GBDT 或 SVM。这条路能work，但特征工程的重活全在人身上，加壳一变、编译器一换，手工特征就得重调。把字节流按固定宽度排成二维矩阵，本质上是让卷积核自己去学「哪一段字节组合长得像什么」，局部相关性由卷积的感受野负责，位置漂移由池化负责，省掉的正是最费人的那部分。

这里有个反直觉的点：图像分类模型在自然图片上学到的是边缘、纹理、部件，而字节图里根本没有语义上的「边缘」，有的是字节分布的局部模式、文件头的固定结构、填充区的大片同值区域。所以不要指望直接搬 ImageNet 预训练权重就能起飞，单通道输入、从头训、小模型，反而更稳。我一般会先把通道数压到 1，把第一个卷积的感受野做到 5×5 或 7×7，让它一开始就能看到足够宽的字节跨度。

技术栈上没什么花活：Python 做胶水，NumPy 处理字节，Pillow 做图像读写和缩放，PyTorch 建网络和训练，scikit-learn 只用来做分层切分和出分类报告。这套组合的好处是每一步都能单独跑、单独验，出问题容易定位——数据坏了不用动训练代码，模型不收敛也不用怀疑图像转换。

2.2 目录结构：五个层次各自的职责

项目按数据流切成五层，目录一眼能看出谁依赖谁。常见做法是这样：

malware-cnn/ ├── configs/ │ └── default.yaml # 路径、超参、图像尺寸集中放这里 ├── data/ │ ├── raw/ # 原始样本，按家族名分目录 │ ├── images/ # 转换后的灰度 PNG，目录结构同 raw │ └── splits/ # train.txt / val.txt / test.txt 名单 ├── src/ │ ├── bin2img.py # 转换层：字节 -> 灰度图 │ ├── dataset.py # 数据层：Dataset / DataLoader / 增强 │ ├── model.py # 模型层：网络定义 │ ├── train.py # 训练层：循环、调度、断点续训 │ ├── evaluate.py # 评估层：混淆矩阵、家族召回 │ └── predict.py # 推理层：单文件 / 批量 ├── app/ │ └── server.py # 对外接口，包一层 HTTP ├── requirements.txt └── README.md

分层的关键在于「转换」和「训练」彻底解耦。灰度图落盘一次，后面调模型、调超参、换主干网络，全都不用重新读二进制；反过来，想改宽度、改截断长度，也只影响bin2img.py和images/这一个目录，训练脚本一行不动。我见过不少同类项目在__getitem__里现场读二进制、现场 reshape，训练一个 epoch 光 IO 就耗掉大半时间，还把数据增强和字节解析耦在一起，改一处炸一片。

configs/default.yaml不是摆设。图像尺寸、每类样本上限、随机种子、batch size 这些值会同时被转换脚本和训练脚本读到，写到代码里迟早出现「训练用 224、推理用 256」这种血泪事故。配置文件里至少要有这几项：

# configs/default.yaml data: raw_dir: data/raw image_dir: data/images split_dir: data/splits image_size: 224 # 训练与推理必须一致 max_bytes: 1048576 # 每个样本只取前 1MB width: 256 # 排图宽度，None 表示自动取近似正方形 train: batch_size: 64 epochs: 30 lr: 0.001 seed: 42

2.3 环境准备：Python 依赖与 GPU 取舍

依赖不多，但装的时候要按顺序来，先装框架再装上层库，避免 pip 自己回退版本。虚拟环境是必须的，这类项目经常要在两台机器之间倒腾，环境不隔离后面全是玄学问题：

# 建环境，Python 建议 3.9 以上；代码里用了 X | None 的写法则要 3.10+ python -m venv .venv source .venv/bin/activate # Windows 用 .venv\Scripts\activate # 先装框架，具体 CUDA 版本按本机驱动去官方索引选，别硬抄别人的命令 pip install torch torchvision # 再装其余依赖，不锁死小版本，但要记录大版本 pip install numpy pillow scikit-learn pyyaml tqdm fastapi uvicorn

CUDA 那一步最容易翻车。判断标准很简单：python -c "import torch; print(torch.cuda.is_available())"输出 True 才算真的能用，输出 False 就老老实实跑 CPU，不要一边训练一边怀疑代码。这个网络的参数在两百万量级，224×224 单通道，一张卡上一百来个 epoch 也就几个小时；纯 CPU 训也不是不能跑，把batch_size降到 16、图像尺寸降到 128，先验证流程通不通，通了再上卡。

提示：样本文件本身有风险，整个流程在隔离的机器或容器里跑，data/raw不做任何形式的执行，只做只读的字节读取。

3. 数据流水线：从字节流到 224×224 灰度图

3.1 字节转矩阵：宽度、截断与填充

转换是整个项目里最容易被低估的一段。核心就三步：读字节、排成二维、缩放到固定尺寸。代码不长，但每个参数都影响最后模型看到的东西：

# src/bin2img.py import math from pathlib import Path import numpy as np from PIL import Image MAX_BYTES = 1 << 20 # 1MB，尾部多为填充与对齐数据，截掉省空间也省噪声 def read_bytes(path: Path, limit: int = MAX_BYTES) -> bytes: """只读方式读取前缀字节，绝不执行样本。""" with open(path, "rb") as f: return f.read(limit) def bytes_to_matrix(raw: bytes, width: int | None = None) -> np.ndarray: """把一维字节流排成二维 uint8 矩阵。""" if not raw: raise ValueError("empty sample") if width is None: # 自动宽度：尽量接近正方形，避免高瘦或扁平的极端长宽比 width = int(math.sqrt(len(raw))) or 1 width = max(1, width) # 末尾不足一行用 0x00 补齐，保证 reshape 不报错 pad = (-len(raw)) % width buf = raw + b"\x00" * pad # frombuffer 返回的是只读视图，后续要做运算必须 copy return np.frombuffer(buf, dtype=np.uint8).reshape(-1, width).copy() def save_image(raw: bytes, out_path: Path, width: int | None, size: int = 224) -> None: """矩阵 -> 单通道图 -> 统一尺寸，落盘为 PNG（无损，别用 JPEG）。""" mat = bytes_to_matrix(raw, width) img = Image.fromarray(mat, mode="L").resize((size, size), Image.BILINEAR) out_path.parent.mkdir(parents=True, exist_ok=True) img.save(out_path, format="PNG")

width是最关键的参数。取 256 时，1MB 的样本排出来大约 4096 行、256 列，长宽比 16:1，缩放到 224×224 会把纵向压得很扁，细粒度纹理糊成一片。取自动宽度（约 1024 列）则接近正方形，缩放损失小。两种都能用，但必须全项目统一，训练和推理用不同宽度，模型看到的就是两种分布，线上准确率会莫名其妙掉一截。

MAX_BYTES决定信息取舍。PE 文件的结构信息高度集中在前几 KB 的文件头和节表，后面大量是资源段和填充。截断到 1MB 是性能和信息的折中；如果你的样本里有超大安装包类文件，可以考虑「头部 8KB + 尾部 8KB 各出一张图」的双视图方案，代价是输入通道翻倍。

mode="L"是单通道灰度，字节值 0～255 直接对应像素亮度，不需要任何色彩映射。缩放用BILINEAR而不是NEAREST：最近邻会随机丢像素，同样的样本在不同 Pillow 版本下可能出不同结果；双线性至少是确定性的加权。

注意：填充值统一用0x00，不要一会儿 0x00 一会儿 0xFF。填充本身会形成一条横纹，用不同值等于给模型塞了一个假的判别特征。

3.2 按家族分层切分：先把泄漏堵住

这一步比模型重要得多。同一家族的样本经过不同加壳处理、或者干脆是同一个文件的不同编译产物，字节图相似度极高。如果随机打乱切分，测试集里混进训练集的近亲，准确率能报到 99%，上线直接打回原形，这就是最典型的翻车现场。正确做法是按家族分层抽样，并且在切分前做一次哈希去重：

# 生成切分名单，按家族分层，保证每个集合的家族分布一致 import hashlib from collections import Counter from pathlib import Path from sklearn.model_selection import train_test_split def collect(raw_dir: Path, min_per_family: int = 10): """遍历 raw/<family>/<file>，顺便用内容哈希去重。""" seen, items = set(), [] for fam_dir in sorted(p for p in raw_dir.iterdir() if p.is_dir()): for f in fam_dir.rglob("*"): if not f.is_file(): continue digest = hashlib.md5(f.read_bytes()[:65536]).hexdigest() # 头部哈希足够筛重复 if digest in seen: continue seen.add(digest) items.append((str(f.relative_to(raw_dir)), fam_dir.name)) # 样本太少的家族并进 unknown，避免分层抽样时直接报错 cnt = Counter(fam for _, fam in items) items = [(p, fam if cnt[fam] >= min_per_family else "unknown") for p, fam in items] return items items = collect(Path("data/raw")) labels = [fam for _, fam in items] train, rest = train_test_split(items, test_size=0.3, stratify=labels, random_state=42) val, test = train_test_split(rest, test_size=0.5, stratify=[fam for _, fam in rest], random_state=42)

stratify=labels保证每个集合里各家族的比例一致，避免某个小家族全被分到测试集。random_state=42固定住，方便复现和做对比实验——调模型的时候切分一变，指标就不可比了。min_per_family是给长尾家族兜底的阈值，一个家族只有三五个样本，分层抽样会直接抛异常，并成unknown反而更接近真实场景。

3.3 Dataset 与增强：单通道的那些细节

训练时的读取逻辑要足够薄，除了打开图片和做变换，别的什么都别干：

# src/dataset.py from pathlib import Path from PIL import Image from torch.utils.data import Dataset from torchvision import transforms train_tf = transforms.Compose([ transforms.Resize((224, 224)), transforms.RandomAffine(degrees=0, translate=(0.05, 0.05)), # 轻微平移，模拟节区偏移 transforms.ToTensor(), transforms.Normalize([0.5], [0.5]), # 单通道只给一个均值一个方差 ]) eval_tf = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]), ]) class SampleImageDataset(Dataset): def __init__(self, items, image_dir, transform): self.items = items # [(相对路径, 家族名)] self.image_dir = Path(image_dir) self.transform = transform def __len__(self): return len(self.items) def __getitem__(self, idx): rel, fam = self.items[idx] img = Image.open(self.image_dir / rel).convert("L") # 强制单通道 return self.transform(img), fam

增强要克制。水平翻转在自然图像上是免费的数据量，在这里会改变字节的排列方向，等于把「从左到右」的字节顺序打乱，语义已经变了，我一般不开。垂直翻转更没意义，那是把文件头挪到尾部。能用的是小幅平移、极轻微的高斯噪声、随机擦除一小块区域——但擦除的位置最好落在尾部大段填充区，这需要知道文件结构，实现成本高，先用平移就够了。

Normalize([0.5], [0.5])只给一个值，是因为输入是单通道。这一行写错成三通道均值是第一大坑，PyTorch 会在广播时报维度不匹配，或者更糟，安静地跑起来但数值全偏。标签的事后面再说，先记住ToTensor()已经把 0～255 归一化到 0～1，Normalize 是在此基础上再减均值除方差。

4. 模型与训练：四段卷积加全局池化

4.1 网络结构：小模型够用，别一上来就 ResNet

图像是灰度、纹理为主、类别数几十到几百，这种任务不需要深网。四段卷积、每段一个 3×3 加 BN 加池化，最后用全局平均池化收成向量，参数两百万出头，训练快、过拟合风险低、推理延迟小：

# src/model.py import torch.nn as nn class SampleCNN(nn.Module): def __init__(self, num_classes: int, in_channels: int = 1): super().__init__() def block(cin, cout): return nn.Sequential( nn.Conv2d(cin, cout, 3, padding=1, bias=False), # 有 BN 就不要 bias nn.BatchNorm2d(cout), nn.ReLU(inplace=True), nn.MaxPool2d(2), ) self.features = nn.Sequential( block(in_channels, 32), # 224 -> 112 block(32, 64), # 112 -> 56 block(64, 128), # 56 -> 28 block(128, 256), # 28 -> 14 ) self.head = nn.Sequential( nn.AdaptiveAvgPool2d(1), # 任意输入尺寸都能收成 1x1 nn.Flatten(), nn.Dropout(0.3), nn.Linear(256, num_classes), ) def forward(self, x): return self.head(self.features(x))

几个选择背后的原因：bias=False是因为后面紧跟 BN，偏置会被 BN 的减均值吸收掉，纯属浪费参数；AdaptiveAvgPool2d(1)替代摊平后接大全连接，把 256×14×14 的七万维直接压到 256 维，参数量砍掉一个数量级，同时保留了对输入尺寸的容忍度；Dropout(0.3)放在分类头前面，样本量不大的时候能明显压住过拟合。

in_channels留成参数，是为了后面做多视图改造时能直接塞三通道（头部图、整体图、熵曲线），不用改主干。

4.2 训练循环：类别不均衡是主要矛盾

恶意样本集天然不均衡，头部家族几百上千个，尾部家族十几个。不处理的话模型会学成「全预测头部类」，准确率看着有七八十，macro-F1 惨不忍睹。我一般同时上两个手段：损失函数加权、按类别采样。加权实现最简单：

import torch import torch.nn as nn def train_one_epoch(model, loader, criterion, optimizer, device, scaler=None): model.train() loss_sum, correct, total = 0.0, 0, 0 for imgs, labels in loader: imgs = imgs.to(device, non_blocking=True) labels = labels.to(device, non_blocking=True) optimizer.zero_grad(set_to_none=True) # 比 zero_grad() 省一次写内存 with torch.autocast(device_type="cuda", enabled=scaler is not None): logits = model(imgs) loss = criterion(logits, labels) if scaler is not None: # 混合精度，显存不够时救命 scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() else: loss.backward() optimizer.step() loss_sum += loss.item() * imgs.size(0) correct += (logits.argmax(1) == labels).sum().item() total += imgs.size(0) return loss_sum / total, correct / total # 按训练集类别频次构造权重，频次越低权重越高 counts = torch.bincount(train_labels_tensor, minlength=num_classes).float() weights = (counts.sum() / counts.clamp(min=1)) ** 0.5 # 开根号，避免尾部权重过猛 weights = weights / weights.mean() criterion = nn.CrossEntropyLoss(weight=weights.to(device), label_smoothing=0.05)

weights这里用了开根号，而不是直接用1/count。直接用倒数会让只有五个样本的家族权重高到离谱，模型为了它把其他类全牺牲掉。开根号是常见的折中，实测比完全不加权稳。label_smoothing=0.05顺带压一压过拟合。

学习率我用余弦退火加一点 warmup，前两个 epoch 线性升到目标值，之后缓慢下降。warmup 的目的很实在：BN 的统计量在最开始几个 batch 里还没稳，学习率太大会直接把 feature 分布打歪，之后怎么训都救不回来。早停的判据不看 loss，看验证集的 macro-F1，连续五轮不涨就停。

提示：混合精度在部分老卡上会出现 loss 变 NaN，遇到就先把scaler关掉对比一次，能复现就别用了。

4.3 评估：准确率会骗人，混淆矩阵不会

训练完第一件事不是看准确率，是把混淆矩阵打出来，看每个家族的召回，尤其看尾部家族是不是被整体吸收了：

import numpy as np from sklearn.metrics import classification_report, confusion_matrix def evaluate(model, loader, device, class_names, unknown_threshold: float = 0.6): model.eval() ys, ps, confs = [], [], [] with torch.no_grad(): for imgs, labels in loader: prob = model(imgs.to(device)).softmax(dim=1) conf, pred = prob.max(dim=1) ys.extend(labels.tolist()) ps.extend(pred.cpu().tolist()) confs.extend(conf.cpu().tolist()) print(classification_report(ys, ps, target_names=class_names, digits=4, zero_division=0)) cm = confusion_matrix(ys, ps) # 置信度低于阈值的一律不判，交给人工复核，这在告警场景里比强行分类有价值 review = sum(1 for c in confs if c < unknown_threshold) print(f"低于阈值转人工: {review}/{len(confs)} = {review / len(confs):.2%}") return cm, np.array(ys), np.array(ps)

classification_report里重点看macro avg的 f1 和每个家族的recall。头部家族召回 0.99、尾部家族召回 0.2，说明模型根本没学尾部，得回去调采样或权重。unknown_threshold这一段是给实际业务用的：模型输出的 softmax 置信度低于阈值时，不硬给结论，直接标成待复核。我见过太多项目把这一步省掉，结果把一个 55% 置信度的判断当成事实推给分析师，反而增加工作量。

阈值定多少不要拍脑袋。在验证集上扫一遍 0.3 到 0.95，画一条「转人工比例 vs 转人工里的准确率」曲线，找一个能接受的人工量对应的点。通常 0.6 左右是个不错的起点。

5. 避坑与排查：五个真金白银换来的教训

5.1 数据侧：离线指标高得离谱，八成是泄漏

现象：训练三个 epoch 验证集准确率就冲到 0.98，测试集也很高，部署到实际样本上家族识别率不到一半。第一次遇到这个现象时，我以为是模型太浅，换了两版主干，指标反而更差。

原因：随机打乱切分，同一家族的不同变体、甚至同一个文件改名后的副本，同时进了训练集和测试集。模型学的不是家族特征，是那几个具体文件的纹理。用文件内容的头部哈希一查，测试集里有将近三成样本在训练集里有同源副本。

解决：切分前做内容哈希去重，切分时按家族分层，条件允许的话按样本的时间戳切——用早期样本训练、近期样本测试，这个指标才接近上线后的真实表现。做完这两步，准确率通常从 0.98 掉到 0.85 左右，别慌，这个数才是真的。

现象：转换出来的灰度图几乎全黑，模型训起来 loss 一直在 2.3 附近晃。

原因：文件头的字节值普遍偏高、分布集中，而尾部大片的0x00填充让整体均值被拉低；再叠上双线性缩放，细节被平均成一片灰。

解决：换宽度策略，256 改成自动近似正方形；或者切分成「头部 64KB 单独一张图 + 整体一张图」双通道输入；再不行就在 Dataset 里做一次全局直方图均衡。别小看这一张图的可视化，每次改转换脚本，我都会抽十个样本存成 PNG 直接打开看，黑图、条纹图、纯色图一眼就能发现。

5.2 训练侧：OOM 和 loss 不动是两个高频问题

现象：RuntimeError: CUDA out of memory，batch size 调到 8 还是炸。

原因：224×224 看起来不大，但四段卷积的中间激活加上默认的num_workers预取，显存占用比预估高不少；如果pin_memory=True又没配好，host 到 device 的拷贝还会拖慢整体吞吐，表现出来像是卡住。

解决：先开混合精度，通常能省四成显存；再不行用梯度累积，batch_size=16累积四步等效于 64；num_workers从 4 开始往上试，别一上来就 16，worker 太多反而抢 CPU。排查顺序固定：先降 batch 确认是不是显存问题，再关增强确认是不是变换里分配了大张量。

现象：loss 从第一步就是 2.3 左右，几十轮几乎不动，输出全是同一个类。

原因：Normalize写成了三通道的[0.485, 0.456, 0.406]，单通道输入广播后数值全偏；或者学习率设成 0.1 直接训崩；也可能是类别权重给得太极端，模型索性躺平。

解决：把 Normalize 改成单值；学习率从 1e-3 起，配合 warmup；权重先关掉跑一次，确认模型至少能过拟合一个小批量（比如 32 个样本训到 loss 接近 0）。小批量过拟合测试是必备的一步，过不了就说明代码有 bug，别急着调超参。

5.3 工程侧：训练和推理的图像不一致，属于最难查的那种

现象：验证集 macro-F1 0.86，写了个推理脚本单独跑几张图，结果几乎全错。模型没换、权重没换，就是结果对不上。

原因：训练用的是transforms.Resize((224, 224))（默认双线性），推理脚本里手写了img.resize((224, 224))，Pillow 默认的插值算法在版本升级后变过；更隐蔽的一种是推理时忘了.convert("L")，三通道图进去被当成了三个不同的输入通道。

解决：把 transform 抽成一个函数放公共模块，训练和推理import同一个对象，绝不各写一份。再加一个自检脚本：从验证集里抽十条，分别走训练路径和推理路径，比对输出的 logits 差值，超过 1e-5 就是不一致。这个自检我后来加进了 CI，每次改完转换或预处理都要跑。

6. 二次开发：换目标、加视图、上量化

拿到这个项目之后，真正有价值的改造通常是三个方向，难度从低到高。

第一个方向是把「家族多分类」改成「恶意/良性二分类 + 未知拒识」。很多团队并不需要知道是哪个家族，只需要一个能挡住大部分明显样本的粗筛。改法很小：num_classes改成 2，输出层换成单 logit 加 sigmoid，损失换BCEWithLogitsLoss，评估从 macro-F1 换成 PR 曲线上的工作点选择。好处是样本标注成本骤降，坏处是丢掉了家族信息，后续溯源还得靠人。

第二个方向是加视图，对付加壳样本。单张整体灰度图在加壳之后纹理全变，这是这条路线的固有短板。常见做法是并行出三张图：文件头区域、整体区域、以及按块计算的字节熵序列（把熵值映射成 0～255 的像素），三通道拼起来喂给in_channels=3的同一个主干。改造成本主要在转换层，模型只改一个参数：

# 三视图拼接：头部图 + 整体图 + 熵图，都是 224x224 单通道 import numpy as np def entropy_view(raw: bytes, block: int = 256, size: int = 224) -> np.ndarray: """按块统计字节熵，归一化到 0-255 后拉伸成图。""" arr = np.frombuffer(raw, dtype=np.uint8) n = len(arr) // block if n == 0: return np.zeros((size, size), dtype=np.uint8) blocks = arr[: n * block].reshape(n, block) # 每块的香农熵，值域 0-8，乘 32 拉到 0-255 附近 p = np.stack([(blocks == v).mean(axis=1) for v in range(256)], axis=1) ent = -(p * np.log2(p + 1e-12)).sum(axis=1) * 32 vec = np.clip(ent, 0, 255).astype(np.uint8) # 一维熵序列铺成二维：按宽度切行，不足补零 width = max(1, int(np.ceil(np.sqrt(len(vec))))) pad = (-len(vec)) % width mat = np.pad(vec, (0, pad)).reshape(-1, width) from PIL import Image return np.array(Image.fromarray(mat, mode="L").resize((size, size), Image.BILINEAR))

第三个方向是部署。训练完导出 ONNX，做动态量化，把模型压到几 MB，塞进边缘设备或扫描服务的 sidecar：

# 导出后务必用同一批验证样本比对 onnxruntime 与 torch 的输出 python -c " import torch, torch.onnx from src.model import SampleCNN m = SampleCNN(num_classes=40).eval() torch.onnx.export(m, torch.randn(1, 1, 224, 224), 'model.onnx', input_names=['image'], output_names=['logits'], dynamic_axes={'image': {0: 'batch'}}, opset_version=12) "

量化之后一定要做一致性校验：同一批验证样本分别走 PyTorch 和 onnxruntime，比对预测标签的一致率，掉超过两个百分点就退回 FP32。改造完跑一遍完整评估脚本，看混淆矩阵有没有整体偏移，比看单个指标可靠。

从那以后我每次接这类样本分类的活，都会先把切分脚本跑一遍、把去重前后的样本数打出来、再抽十张灰度图亲眼看一遍，然后才动模型。这三步花不了半小时，能省掉后面好几天的自我怀疑。希望帮到你。

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