Anomalib实战：5步搞定自定义数据集训练（附Windows避坑指南）

Anomalib实战：在Windows上从零构建自定义异常检测模型

最近在帮一个做工业质检的朋友处理图像异常检测的问题，他之前尝试过一些传统方法，效果总是不太理想。我推荐他试试Anomalib这个框架，结果他在Windows上配置环境时遇到了不少坑——特别是那个恼人的num_workers=0限制，直接让训练速度慢得像蜗牛。这让我意识到，虽然Anomalib在Linux服务器上跑得风生水起，但在Windows本地开发环境中，确实有不少细节需要注意。

如果你也是Windows用户，想用Anomalib训练自己的异常检测模型，但又不想被各种环境问题折腾得焦头烂额，这篇文章就是为你准备的。我会带你一步步搭建环境、准备数据、训练模型，并分享我在Windows平台上踩过的那些坑以及解决方案。无论你是做工业质检、医疗影像分析，还是其他任何需要检测图像异常的领域，这套流程都能帮你快速上手。

1. 环境搭建：避开Windows的“特色”陷阱

在Windows上配置深度学习环境，最让人头疼的就是各种依赖冲突和平台限制。Anomalib虽然官方支持Windows，但有些默认配置需要调整才能顺利运行。

1.1 Python环境与关键依赖

首先，我强烈建议使用Anaconda或Miniconda来管理Python环境。这能有效隔离不同项目的依赖，避免版本冲突。创建一个新的conda环境：

conda create -n anomalib_env python=3.9 conda activate anomalib_env

为什么选择Python 3.9而不是最新版本？因为很多深度学习库对新版本Python的支持往往滞后，3.9是目前最稳定的选择之一。

接下来安装PyTorch。这里有个关键点：一定要去PyTorch官网生成适合你环境的安装命令。如果你的显卡是NVIDIA的，需要先确认CUDA版本：

nvidia-smi

查看右上角显示的CUDA版本，然后去PyTorch官网选择对应的安装命令。比如CUDA 11.8对应的命令可能是：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

注意：如果没GPU或者CUDA版本不匹配，直接安装CPU版本也可以，只是训练会慢很多。对于小数据集，CPU训练还是可行的。

1.2 Anomalib核心安装与Windows特殊配置

现在安装Anomalib本身：

pip install anomalib

但仅仅这样还不够。Anomalib依赖的一些库在Windows上需要特别注意：

• PyTorch Lightning：确保安装最新稳定版
• OpenCV：如果遇到导入错误，可能需要单独安装opencv-python
• 其他可能需要的库：scikit-learn,matplotlib,seaborn（用于可视化）

安装完基础包后，创建一个测试脚本验证环境：

# test_environment.py import torch import anomalib import pytorch_lightning as pl print(f"PyTorch版本: {torch.__version__}") print(f"CUDA可用: {torch.cuda.is_available()}") print(f"Anomalib版本: {anomalib.__version__}") print(f"PyTorch Lightning版本: {pl.__version__}") if torch.cuda.is_available(): print(f"GPU设备: {torch.cuda.get_device_name(0)}")

运行这个脚本，确保所有导入都没有错误。如果遇到DLL load failed之类的错误，通常是CUDA或cuDNN的问题，需要重新安装对应版本的PyTorch。

1.3 解决num_workers=0的性能瓶颈

这是Windows用户最常遇到的问题。在Linux/Mac上，我们可以设置num_workers=4或更高来并行加载数据，显著提升训练速度。但在Windows上，如果num_workers>0，经常会遇到这样的错误：

BrokenPipeError: [Errno 32] Broken pipe

或者

RuntimeError: DataLoader worker (pid XXXX) is killed by signal: X

这是因为Windows的多进程实现与Unix-like系统不同。PyTorch的DataLoader在Windows上使用spawn而不是fork来创建子进程，这会导致一些序列化问题。

临时解决方案：设置num_workers=0。这是最简单的方法，但代价是数据加载成为瓶颈，特别是当数据集很大时。

更好的解决方案：使用Windows的WSL2（Windows Subsystem for Linux）。这实际上是在Windows上运行一个Linux子系统，完美解决了多进程问题。安装WSL2后，你可以在Linux环境中获得完整的num_workers支持。

如果必须使用原生Windows，可以考虑这些优化：

1. 使用更快的存储：将数据集放在SSD而不是HDD上
2. 预加载数据：如果内存足够，可以先将整个数据集加载到内存中
3. 调整batch size：适当增大batch size，减少数据加载频率

下面这个表格对比了不同配置下的数据加载速度：

2. 数据准备：构建适合异常检测的数据集

异常检测的数据集结构与传统的分类任务不同。你需要明确区分正常样本和异常样本，而且通常正常样本远多于异常样本——这正是异常检测的特点。

2.1 数据集目录结构设计

Anomalib的Folder数据模块要求特定的目录结构。我推荐这样组织你的数据：

your_dataset/ ├── train/ │ ├── good/ # 正常样本 │ │ ├── image1.jpg │ │ ├── image2.jpg │ │ └── ... │ └── defective/ # 异常样本（可选，用于有监督或半监督） │ ├── defect1.jpg │ └── ... ├── test/ │ ├── good/ │ ├── defective/ │ └── ... └── val/ # 验证集（可选） ├── good/ └── defective/

对于工业质检场景，你可能有多种缺陷类型。这时可以进一步细分：

defective/ ├── scratch/ # 划痕 ├── dent/ # 凹陷 ├── stain/ # 污渍 └── missing_part/ # 缺件

但要注意，Anomalib默认的Folder模块只区分正常和异常两类。如果你需要多类别异常检测，可能需要自定义数据模块。

2.2 数据预处理与增强策略

异常检测对数据质量很敏感。以下是我在实际项目中总结的预处理步骤：

1. 尺寸统一：将所有图像调整到相同尺寸。Anomalib要求输入尺寸一致，通常用256x256或512x512。

2. 归一化：使用ImageNet的均值和标准差进行归一化，除非你的数据分布与ImageNet差异很大。

3. 数据增强（仅对训练集）：

   • 随机水平/垂直翻转
   • 随机旋转（小角度）
   • 颜色抖动（轻微调整亮度、对比度）
   • 高斯模糊（模拟轻微失焦）

重要提示：对异常样本的数据增强要谨慎！过度的增强可能会改变缺陷的本质特征。比如，对划痕图像进行大幅旋转，可能让模型学不到划痕的真实形态。

下面是一个完整的数据准备代码示例：

import os from pathlib import Path from PIL import Image import numpy as np def prepare_dataset(source_dir, target_dir, target_size=(256, 256)): """ 准备Anomalib兼容的数据集 参数: source_dir: 原始数据目录 target_dir: 处理后的目标目录 target_size: 目标图像尺寸 """ # 创建目录结构 splits = ['train', 'test', 'val'] classes = ['good', 'defective'] for split in splits: for cls in classes: os.makedirs(os.path.join(target_dir, split, cls), exist_ok=True) # 这里假设你的原始数据已经按类别组织 # 实际中可能需要根据你的数据格式调整 for split in ['train', 'test', 'val']: for cls in classes: src_path = Path(source_dir) / split / cls if src_path.exists(): for img_file in src_path.glob('*.jpg'): # 打开并调整尺寸 img = Image.open(img_file) img = img.resize(target_size, Image.Resampling.LANCZOS) # 保存到目标位置 dst_path = Path(target_dir) / split / cls / img_file.name img.save(dst_path) print(f"数据集准备完成，保存在: {target_dir}")

2.3 数据质量检查清单

在开始训练前，花点时间检查数据质量可以避免很多后续问题：

• [ ]类别平衡检查：正常样本数量应该远多于异常样本（通常10:1或更高）
• [ ]图像格式一致性：确保所有图像都是相同的格式（JPEG/PNG）和色彩空间（RGB）
• [ ]异常标注准确性：人工抽查异常样本，确保标注正确
• [ ]数据泄露检查：确保训练集和测试集没有重复或高度相似的图像
• [ ]内存占用估算：计算数据集总大小，确保不会超出内存限制

对于大型数据集，可以使用这个快速检查脚本：

import os from collections import Counter from PIL import Image def dataset_summary(data_root): """生成数据集统计摘要""" stats = {} for split in ['train', 'val', 'test']: split_path = os.path.join(data_root, split) if not os.path.exists(split_path): continue stats[split] = {} for cls in ['good', 'defective']: cls_path = os.path.join(split_path, cls) if os.path.exists(cls_path): # 统计数量 image_files = [f for f in os.listdir(cls_path) if f.lower().endswith(('.png', '.jpg', '.jpeg'))] stats[split][cls] = len(image_files) # 检查图像尺寸（抽样检查） if image_files: sample_img = Image.open(os.path.join(cls_path, image_files[0])) stats[split][f'{cls}_size'] = sample_img.size stats[split][f'{cls}_mode'] = sample_img.mode return stats # 使用示例 summary = dataset_summary('path/to/your/dataset') for split, split_stats in summary.items(): print(f"\n{split}:") for key, value in split_stats.items(): print(f" {key}: {value}")

3. 模型选择与配置：找到适合你任务的算法

Anomalib提供了多种异常检测算法，每种都有其特点和适用场景。选择正确的模型对项目成功至关重要。

3.1 主流模型对比与选型指南

Anomalib内置的模型主要分为几类：

基于重建的模型：

• AutoEncoder：通过学习重建正常样本，对重建误差大的样本判为异常
• VAE：变分自编码器，引入概率分布，对不确定性建模

基于特征嵌入的模型：

• PatchCore：当前最流行的工业异常检测方法之一，利用预训练特征+内存库
• CFA：通过特征对齐进行异常检测

基于分类的模型：

• STFPM：学生-教师特征金字塔匹配
• DFKDE：基于密度估计的方法

为了帮你快速选择，我整理了以下对比表格：

对于大多数工业应用，我推荐从PatchCore开始。它在MVTec AD等基准数据集上表现优异，而且训练速度快，适合快速迭代。

3.2 PatchCore深度配置解析

PatchCore的核心思想是利用预训练网络提取特征，然后构建一个正常样本的特征记忆库。推理时，计算测试样本特征与记忆库中最近邻的距离作为异常分数。

下面是一个完整的PatchCore配置示例：

from anomalib.models import Patchcore from anomalib.models.patchcore.anomaly_module import PatchcoreLightning # 基础配置 model = Patchcore( backbone="wide_resnet50_2", # 骨干网络 layers=["layer2", "layer3"], # 提取特征的层 pre_trained=True, # 使用预训练权重 coreset_sampling_ratio=0.1, # 核心集采样比例 num_neighbors=9, # KNN中的k值 ) # 更详细的配置（通过Lightning模块） patchcore_module = PatchcoreLightning( model=model, input_size=(256, 256), # 输入尺寸 threshold_method="adaptive", # 阈值方法 threshold_params={ "method": "relative", "relative_value": 0.5 # 相对阈值 } )

关键参数解析：

• backbone：预训练CNN网络。wide_resnet50_2是常用选择，平衡了性能和速度。如果追求速度，可以选resnet18；追求精度，可以选efficientnet_b5。

• layers：从哪些层提取特征。深层特征包含语义信息，浅层特征包含纹理信息。对于表面缺陷，浅层特征更重要。

• coreset_sampling_ratio：核心集采样比例。PatchCore会从所有正常样本特征中采样一个子集作为记忆库。比例越小，内存占用越小，但可能损失信息。

• num_neighbors：KNN中的k值。影响异常分数的平滑程度。

3.3 针对Windows的性能优化配置

在Windows上运行PatchCore，有几个配置技巧可以提升体验：

1. 调整核心集大小：如果遇到内存不足，降低coreset_sampling_ratio。从0.1开始，如果内存充足再逐步增加。

2. 使用更小的骨干网络：对于小数据集或简单任务，resnet18可能就足够了，而且速度更快。

3. 分批处理大图像：如果原始图像很大（如4K），可以先在数据加载阶段调整尺寸，而不是在模型中处理。

4. 启用混合精度训练：如果GPU支持，可以显著减少内存占用并加速训练：

from pytorch_lightning import Trainer trainer = Trainer( max_epochs=100, accelerator="gpu" if torch.cuda.is_available() else "cpu", devices=1, precision=16, # 混合精度训练 enable_checkpointing=True, logger=True, )

5. 监控GPU内存：在训练过程中监控GPU使用情况，避免内存溢出：

import torch # 训练前清空缓存 torch.cuda.empty_cache() # 监控函数 def monitor_gpu_memory(): if torch.cuda.is_available(): allocated = torch.cuda.memory_allocated() / 1024**3 # GB reserved = torch.cuda.memory_reserved() / 1024**3 # GB print(f"已分配: {allocated:.2f} GB, 已保留: {reserved:.2f} GB")

4. 训练流程实战：从代码到模型

现在让我们进入实际的训练环节。我会带你编写完整的训练脚本，并解释每个步骤的细节。

4.1 完整训练脚本编写

首先，导入必要的库并设置随机种子以确保可重复性：

import os import random import numpy as np import torch from anomalib.data import Folder from anomalib.models import Patchcore from anomalib.engine import Engine from pytorch_lightning import Trainer from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping # 设置随机种子 def set_seed(seed=42): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) if torch.cuda.is_available(): torch.cuda.manual_seed(seed) torch.cuda.manual_seed_all(seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False set_seed(42)

接下来配置数据模块。这里特别注意Windows上的num_workers设置：

# 数据模块配置 datamodule = Folder( name="industrial_inspection", # 数据集名称 root=r"D:\anomalib_data\metal_nuts", # 数据集根目录 normal_dir="good", # 正常样本目录（相对于root） abnormal_dir="defective", # 异常样本目录 task="segmentation", # 任务类型：classification或segmentation image_size=(256, 256), # 图像尺寸 train_batch_size=32, # 训练批次大小 eval_batch_size=32, # 评估批次大小 num_workers=0, # Windows上必须设为0，除非使用WSL2 val_split_mode="from_dir", # 验证集来源 val_split_ratio=0.2, # 验证集比例（如果从训练集划分） seed=42, # 随机种子 )

Windows特别提醒：路径中的反斜杠需要使用原始字符串（前面加r）或双反斜杠。建议使用pathlib库来处理路径，更跨平台：

from pathlib import Path data_root = Path("D:/anomalib_data/metal_nuts") # 使用正斜杠 # 或者 data_root = Path(r"D:\anomalib_data\metal_nuts") # 使用原始字符串

现在初始化模型和训练引擎：

# 初始化模型 model = Patchcore( backbone="wide_resnet50_2", layers=["layer2", "layer3"], pre_trained=True, coreset_sampling_ratio=0.1, num_neighbors=9, ) # 配置训练引擎 engine = Engine( task="segmentation", # 与数据模块一致 devices=1, # 使用1个GPU或CPU accelerator="gpu" if torch.cuda.is_available() else "cpu", max_epochs=100, check_val_every_n_epoch=5, # 每5个epoch验证一次 log_every_n_steps=10, # 每10步记录一次日志 )

4.2 回调函数与训练监控

回调函数是控制训练过程的重要工具。这里配置几个实用的回调：

# 模型检查点 - 保存最佳模型 checkpoint_callback = ModelCheckpoint( dirpath="./checkpoints", filename="patchcore-{epoch:02d}-{val_loss:.2f}", monitor="val_loss", # 监控验证损失 mode="min", # 越小越好 save_top_k=3, # 保存最好的3个模型 save_last=True, # 同时保存最后一个epoch的模型 ) # 早停 - 防止过拟合 early_stop_callback = EarlyStopping( monitor="val_loss", patience=20, # 20个epoch没有改善就停止 mode="min", verbose=True, ) # 学习率监控（如果需要的话） from pytorch_lightning.callbacks import LearningRateMonitor lr_monitor = LearningRateMonitor(logging_interval="epoch") # 将回调添加到引擎 engine.callbacks = [checkpoint_callback, early_stop_callback, lr_monitor]

4.3 开始训练与进度监控

现在可以开始训练了。我建议先在小批量数据上测试整个流程：

# 首先，确保数据模块设置正确 datamodule.setup() # 快速测试一个batch，确保没有错误 train_loader = datamodule.train_dataloader() sample_batch = next(iter(train_loader)) print(f"Batch keys: {sample_batch.keys()}") print(f"Image shape: {sample_batch['image'].shape}") print(f"Label shape: {sample_batch['label'].shape if 'label' in sample_batch else 'No label'}") # 如果一切正常，开始训练 print("开始训练...") engine.train( model=model, datamodule=datamodule, ckpt_path=None, # 从头开始训练，如果要继续训练，指定检查点路径 )

训练过程中，你可以监控这些指标：

• 训练损失：应该逐渐下降并趋于稳定
• 验证损失：监控过拟合，如果验证损失开始上升而训练损失继续下降，可能过拟合了
• GPU内存使用：确保没有内存泄漏
• 训练速度：每秒处理的样本数

如果使用TensorBoard或海王星（Neptune）等工具，可以实时可视化这些指标。Anomalib默认集成了TensorBoard支持。

4.4 常见训练问题与解决方案

在Windows上训练时，你可能会遇到这些问题：

问题1：内存不足（CUDA out of memory）

解决方案：

• 减小batch_size（从32降到16或8）
• 减小图像尺寸（从256x256降到128x128）
• 降低coreset_sampling_ratio
• 使用梯度累积模拟更大的batch size

# 梯度累积示例 trainer = Trainer( accumulate_grad_batches=4, # 每4个batch更新一次梯度 # 其他参数... )

问题2：训练速度太慢

解决方案：

• 使用WSL2并设置num_workers>0
• 将数据放在SSD上
• 使用混合精度训练（precision=16）
• 考虑使用更小的模型

问题3：验证损失波动大

解决方案：

• 增加验证集大小
• 使用更稳定的优化器（如AdamW而不是SGD）
• 添加更多的数据增强
• 检查数据是否有问题（如标注错误）

问题4：模型不收敛

解决方案：

• 检查学习率是否合适（尝试1e-3, 1e-4, 1e-5）
• 检查数据预处理是否正确
• 确保正常样本和异常样本没有混淆
• 尝试不同的模型架构

5. 模型评估与部署：从实验到生产

训练完成后，你需要评估模型性能，然后部署到实际应用中。

5.1 全面评估模型性能

首先加载最佳模型检查点进行评估：

from anomalib.deploy import Inferencer from pathlib import Path # 加载训练好的模型 ckpt_path = "./checkpoints/patchcore-epoch=50-val_loss=0.12.ckpt" inferencer = Inferencer( model=model, ckpt_path=ckpt_path, device="cuda" if torch.cuda.is_available() else "cpu", ) # 在测试集上评估 test_results = engine.test( model=model, datamodule=datamodule, ckpt_path=ckpt_path, ) print("测试结果:") for key, value in test_results[0].items(): print(f" {key}: {value:.4f}")

关键评估指标包括：

• AUROC（Area Under ROC Curve）：最常用的异常检测指标，值越接近1越好
• F1 Score：精确率和召回率的调和平均
• 精确率（Precision）：预测为异常的样本中真正异常的比例
• 召回率（Recall）：所有异常样本中被正确找出的比例

对于分割任务（像素级异常检测），还需要看：

• 像素级AUROC：每个像素点的异常检测能力
• IoU（Intersection over Union）：预测掩码与真实掩码的重合度

5.2 可视化分析：理解模型行为

数字指标很重要，但可视化能帮你更直观地理解模型：

import matplotlib.pyplot as plt from anomalib.post_processing import Visualizer # 创建可视化器 visualizer = Visualizer(mode="full", task="segmentation") # 对单个图像进行推理和可视化 image_path = "path/to/test/image.jpg" result = inferencer.predict(image_path=image_path) # 可视化结果 fig, axes = plt.subplots(1, 3, figsize=(15, 5)) # 原始图像 axes[0].imshow(result["image"]) axes[0].set_title("原始图像") axes[0].axis("off") # 异常热图 heatmap = axes[1].imshow(result["anomaly_map"], cmap="hot") axes[1].set_title("异常热图") axes[1].axis("off") plt.colorbar(heatmap, ax=axes[1]) # 分割掩码（如果有） if "pred_mask" in result: axes[2].imshow(result["pred_mask"], cmap="gray") axes[2].set_title("预测掩码") axes[2].axis("off") plt.tight_layout() plt.show()

通过可视化，你可以发现：

1. 模型关注哪些区域：热图显示模型认为异常的区域
2. 误判模式：哪些正常区域被误判为异常
3. 漏检模式：哪些异常区域没有被检测到

5.3 部署到生产环境

将训练好的模型部署到生产环境需要考虑几个方面：

方案1：使用Anomalib的Inferencer（最简单）

# 生产环境推理脚本 class AnomalyDetector: def __init__(self, model_path, device="cuda"): self.inferencer = Inferencer( model=Patchcore(), ckpt_path=model_path, device=device, ) def predict(self, image_path): """预测单张图像""" result = self.inferencer.predict(image_path=image_path) # 提取关键信息 prediction = { "is_anomalous": result["pred_score"] > 0.5, # 假设阈值为0.5 "anomaly_score": float(result["pred_score"]), "heatmap": result["anomaly_map"], } return prediction def predict_batch(self, image_paths): """批量预测""" results = [] for path in image_paths: results.append(self.predict(path)) return results # 使用示例 detector = AnomalyDetector("path/to/model.ckpt") result = detector.predict("path/to/test_image.jpg") print(f"异常分数: {result['anomaly_score']:.4f}") print(f"是否异常: {result['is_anomalous']}")

方案2：导出为ONNX格式（跨平台部署）

import torch.onnx from anomalib.models import Patchcore # 加载模型 model = Patchcore.load_from_checkpoint("path/to/model.ckpt") model.eval() # 创建示例输入 dummy_input = torch.randn(1, 3, 256, 256) # 导出为ONNX torch.onnx.export( model, dummy_input, "patchcore_model.onnx", input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}}, opset_version=11, ) print("ONNX模型导出成功")

方案3：使用TorchServe部署（高并发场景）

# 创建模型处理程序 import torch import torchvision.transforms as transforms from PIL import Image import io class AnomalyHandler: def __init__(self): self.model = None self.transform = transforms.Compose([ transforms.Resize((256, 256)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) def initialize(self, context): # 加载模型 model_path = context.system_properties["model_dir"] + "/patchcore.ckpt" self.model = Patchcore.load_from_checkpoint(model_path) self.model.eval() def preprocess(self, data): # 预处理图像数据 image = data[0].get("data") or data[0].get("body") image = Image.open(io.BytesIO(image)) image = self.transform(image).unsqueeze(0) return image def inference(self, data): with torch.no_grad(): output = self.model(data) return output def postprocess(self, data): # 后处理：计算异常分数 anomaly_score = data["pred_score"].item() return [{"anomaly_score": anomaly_score, "is_anomalous": anomaly_score > 0.5}]

5.4 性能优化与监控

在生产环境中，你还需要考虑：

性能优化：

• 使用TensorRT加速推理
• 实现批处理提高吞吐量
• 使用异步处理避免阻塞

监控与维护：

• 记录每次推理的分数和结果
• 设置阈值自动调整机制
• 定期用新数据重新训练模型（持续学习）

# 简单的监控类 class ModelMonitor: def __init__(self, window_size=1000): self.scores = [] self.predictions = [] self.window_size = window_size def update(self, score, prediction): self.scores.append(score) self.predictions.append(prediction) # 保持固定窗口大小 if len(self.scores) > self.window_size: self.scores.pop(0) self.predictions.pop(0) def get_stats(self): if not self.scores: return None avg_score = np.mean(self.scores) anomaly_rate = np.mean(self.predictions) return { "avg_anomaly_score": avg_score, "anomaly_rate": anomaly_rate, "total_predictions": len(self.scores), } def check_drift(self, threshold=0.1): """检查数据漂移""" stats = self.get_stats() if stats is None: return False # 简单示例：如果异常率突然变化超过阈值，可能发生漂移 recent_rate = np.mean(self.predictions[-100:] if len(self.predictions) >= 100 else self.predictions) overall_rate = stats["anomaly_rate"] return abs(recent_rate - overall_rate) > threshold

5.5 实际部署注意事项

在Windows生产环境中部署时，还需要考虑：

1. 环境依赖：创建requirements.txt记录所有依赖版本
2. 路径处理：使用pathlib确保跨平台兼容性
3. 错误处理：添加完善的异常捕获和日志记录
4. 资源管理：监控内存和GPU使用，避免资源泄漏
5. 安全考虑：验证输入图像，防止恶意文件

最后，记得定期备份模型和评估结果。异常检测模型可能需要随着数据分布的变化而更新，建立一套完整的模型管理流程会让后续维护轻松很多。

我在实际项目中发现，建立一个简单的模型版本管理系统非常有用。每次训练新模型时，记录以下信息：

• 训练数据统计（数量、类别分布）
• 超参数配置
• 评估指标
• 可视化示例
• 部署时间和环境信息

这样当模型性能下降时，你可以快速定位问题，是数据变了，还是需要调整超参数，或者是其他原因。