使用自动编码器进行半监督异常检测

前言

• 由于本人水平有限，难免出现错漏，敬请批评改正。
• 更多精彩内容，可点击进入YOLO系列专栏、自然语言处理
  专栏或我的个人主页查看
• 基于DETR的人脸伪装检测
• YOLOv7训练自己的数据集（口罩检测）
• YOLOv8训练自己的数据集（足球检测）
• YOLOv5：TensorRT加速YOLOv5模型推理
• YOLOv5：IoU、GIoU、DIoU、CIoU、EIoU
• 玩转Jetson Nano（五）：TensorRT加速YOLOv5目标检测
• YOLOv5：添加SE、CBAM、CoordAtt、ECA注意力机制
• YOLOv5：yolov5s.yaml配置文件解读、增加小目标检测层
• Python将COCO格式实例分割数据集转换为YOLO格式实例分割数据集
• YOLOv5：使用7.0版本训练自己的实例分割模型（车辆、行人、路标、车道线等实例分割）
• 使用Kaggle GPU资源免费体验Stable Diffusion开源项目

前提条件

• 熟悉Python

相关介绍

• Python是一种跨平台的计算机程序设计语言。是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。
• PyTorch 是一个深度学习框架，封装好了很多网络和深度学习相关的工具方便我们调用，而不用我们一个个去单独写了。它分为 CPU 和 GPU 版本，其他框架还有 TensorFlow、Caffe 等。PyTorch 是由 Facebook 人工智能研究院（FAIR）基于 Torch 推出的，它是一个基于 Python 的可续计算包，提供两个高级功能：1、具有强大的 GPU 加速的张量计算（如 NumPy）；2、构建深度神经网络时的自动微分机制。

Semi-supervised Anomaly Detection using AutoEncoders

• 异常检测是指从正常数据中发现异常实例的任务。在一些应用中，这些异常值或异常实例比正常实例更令人感兴趣。特别是在工业光学检测和基础设施资产管理的情况下，发现这些缺陷(异常区域)是极其重要的。
• 传统上，甚至今天，这个过程都是手工进行的。与正常纹理相比，人类依靠缺陷的显着性来检测缺陷。然而，人工检查是缓慢、乏味、主观的，容易受到人类偏见的影响。因此，缺陷检测的自动化是可取的。但对于缺陷检测来说，缺乏大量异常实例和标记数据的可用性是一个问题。
• 在本论文《Semi-supervised Anomaly Detection using AutoEncoders》中，提出了一种卷积自编码器架构，用于异常检测，仅在无缺陷(正常)实例上进行训练。对于测试图像，通过从自编码器输出中减去原始图像获得的残差掩码被阈值化，以获得缺陷分割掩码。该方法在两个数据集上进行了测试，获得了令人印象深刻的平均F1分数0.885。即使在训练过程中没有使用缺陷图像，网络也学会了检测缺陷的实际形状。
• 论文地址：https://arxiv.org/abs/2001.03674
• 官方源代码地址：https://github.com/msminhas93/anomaly-detection-using-autoencoders
• 有兴趣可查阅论文和官方源代码地址。

Python实现的自编码器网络架构，代码如下。

import torch.nn as nn
import torch.nn.functional as F
import torch


class AnomalyAE(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 48, (11, 11), stride=(1, 1), padding=5)
        self.bn1 = nn.BatchNorm2d(48)

        self.conv2 = nn.Conv2d(48, 48, (9, 9), stride=(2, 2), padding=4)
        self.bn2 = nn.BatchNorm2d(48)

        self.conv3 = nn.Conv2d(48, 48, (7, 7), stride=(2, 2), padding=3)
        self.bn3 = nn.BatchNorm2d(48)

        self.conv4 = nn.Conv2d(48, 48, (5, 5), stride=(2, 2), padding=2)
        self.bn4 = nn.BatchNorm2d(48)

        self.conv5 = nn.Conv2d(48, 48, (3, 3), stride=(2, 2), padding=1)
        self.bn5 = nn.BatchNorm2d(48)

        self.conv_tr1 = nn.ConvTranspose2d(
            48, 48, (5, 5), stride=(2, 2), padding=2, output_padding=1)
        self.bn_tr1 = nn.BatchNorm2d(48)

        self.conv_tr2 = nn.ConvTranspose2d(
            96, 48, (7, 7), stride=(2, 2), padding=3, output_padding=1)
        self.bn_tr2 = nn.BatchNorm2d(48)

        self.conv_tr3 = nn.ConvTranspose2d(
            96, 48, (9, 9), stride=(2, 2), padding=4, output_padding=1)
        self.bn_tr3 = nn.BatchNorm2d(48)

        self.conv_tr4 = nn.ConvTranspose2d(
            96, 48, (11, 11), stride=(2, 2), padding=5, output_padding=1)
        self.bn_tr4 = nn.BatchNorm2d(48)

        self.conv_output = nn.Conv2d(96, 1, (1, 1), (1, 1))
        self.bn_output = nn.BatchNorm2d(1)

    def forward(self, x):
        slope = 0.2
        # print(x.shape)
        x = F.leaky_relu((self.bn1(self.conv1(x))), slope)
        # print(x.shape)
        x1 = F.leaky_relu((self.bn2(self.conv2(x))), slope)
        # print(x1.shape)
        x2 = F.leaky_relu((self.bn3(self.conv3(x1))), slope)
        # print(x2.shape)
        x3 = F.leaky_relu((self.bn4(self.conv4(x2))), slope)
        # print(x3.shape)
        x4 = F.leaky_relu((self.bn5(self.conv5(x3))), slope)
        # print(x4.shape)

        x5 = F.leaky_relu(self.bn_tr1(self.conv_tr1(x4)), slope)
        # print(x5.shape)
        x6 = F.leaky_relu(self.bn_tr2(
            self.conv_tr2(torch.cat([x5, x3], 1))), slope)
        # print(x6.shape)
        x7 = F.leaky_relu(self.bn_tr3(
            self.conv_tr3(torch.cat([x6, x2], 1))), slope)
        # print(x7.shape)
        x8 = F.leaky_relu(self.bn_tr4(
            self.conv_tr4(torch.cat([x7, x1], 1))), slope)
        # print(x8.shape)

        output = F.leaky_relu(self.bn_output(
            self.conv_output(torch.cat([x8, x], 1))), slope)
        # print(output.shape)
        return output

if __name__ == "__main__":
    x = torch.rand([16,1,512,512])
    model = AnomalyAE()
    y = model(x)
    # print(x.shape, x.dtype)
    # print(y.shape, y.dtype)

项目结构

训练模型

python main.py --train_dir ./data/Train --val_dir ./data/Test --train_batch_size 1 --val_batch_size 1 --save_graph --epochs 25

测试模型

python test.py

参考

[1] Manpreet Singh Minhas, John Zelek. Semi-supervised Anomaly Detection using AutoEncoders. 2022
[2] https://github.com/msminhas93/anomaly-detection-using-autoencoders
[3] https://arxiv.org/abs/2001.03674

• 由于本人水平有限，难免出现错漏，敬请批评改正。
• 更多精彩内容，可点击进入YOLO系列专栏、自然语言处理
  专栏或我的个人主页查看
• 基于DETR的人脸伪装检测
• YOLOv7训练自己的数据集（口罩检测）
• YOLOv8训练自己的数据集（足球检测）
• YOLOv5：TensorRT加速YOLOv5模型推理
• YOLOv5：IoU、GIoU、DIoU、CIoU、EIoU
• 玩转Jetson Nano（五）：TensorRT加速YOLOv5目标检测
• YOLOv5：添加SE、CBAM、CoordAtt、ECA注意力机制
• YOLOv5：yolov5s.yaml配置文件解读、增加小目标检测层
• Python将COCO格式实例分割数据集转换为YOLO格式实例分割数据集
• YOLOv5：使用7.0版本训练自己的实例分割模型（车辆、行人、路标、车道线等实例分割）
• 使用Kaggle GPU资源免费体验Stable Diffusion开源项目