devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

PaDiM 无监督异常检测和定位-论文和源码阅读

作者：木道寻08 | 2024-06-22 18:41:36

赞

踩

padim

目录

1. 论文

1.1 检测效果

1.2 优缺点

1.3 框架 

1.2.1 特征提取embedding extraction

1.2.2 正样本学习Learning of the normality

1.2.3 计算异常图 inference: computation of the anomaly map

2. 源码

2.1 dataset

2.2 model

2.3 提取特征

2.4 infer

1. 论文

https://arxiv.org/abs/2011.08785

思路：数据特征的分布被假定为一个多元高斯分布，异常值通常在多元高斯分布中表现为远离数据集的中心（均值向量）的数据点。协方差矩阵可以描述各个特征之间的相关性和离散程度。通过计算数据点相对于协方差矩阵的马氏距离，可以识别潜在的异常点。 

1.1 检测效果

 

SPADE精度不错，但是推理会非常慢，因为算法是基于KNN，测试的时候要访问整个训练正常数据集的embedding vectors。

PaDiM backbone是resnet18，然后随机选100个特征，和backbone是Wide ResNet-50-2 (WR50) 然后随机选550个特征，可以看到后者的精度更高。

1.2 优缺点

优点：（1）不需要训练过程，输入无缺陷数据，直接使用resnet或者efficient等预训练网络的特征提取层前三层，进行特征，拼接在一起对无缺陷数据建模，速度比起训练快了很多很多；（2）建模过程只需要无缺陷数据；

缺点：（1）由于是使用预训练网络，所以图像需要缩放到对应网络的输入尺度下，才能使用预训练权重，比如efficient和resnet官方预训练网络的输入都是224，则对于小缺陷，缩放到224会损失精度；（2）误判问题，训练的无缺陷数据需要足够多样，否则测试图像稍微和建模的数据不同则会误判（3）阈值问题，测试时会计算测试特征和建模特征之间的距离，然后设定一个阈值，超过阈值则为缺陷，但是这个阈值有时很难界定。

1.3 框架 

步骤如下： 

1.2.1 特征提取embedding extraction

将与此图像块相对应的三个激活图区域特征concat在一起，组成一个特征向量（这样向量就包含了多尺度信息）。N张图，就有N个特征向量。组成X_ij特征空间，该过程不需要训练，直接用预训练权重比如resnet18、resnet50；

(1) infer

layer1: batch infer -> (b,256,56,56) ->cat->(img_num,256,56,56)

layer2: batch infer -> (b,512,28,28) ->cat->(img_num,512,28,28)

layer3: batch infer -> (b,1024,14,14) ->cat->(img_num,1024,14,14)

全部cat在一起, 得到embedding_vectors (img_num,1792,56,56).

(2) 随机选择d个特征

embedding_vectors有56*56个特征块，每个块有1792长度的特征，随机选d（550）个特征。

embedding_vectors.shape -> (img_num,550,56,56).

1.2.2 正样本学习Learning of the normality

为了求整个正样本数据分布情况，作者假设数据是符合多元高斯分布，然后求取此分布的参数: 均值mean和协方差covariance。

（1）均值：特征均值是某一特征（或变量）在数据集中的平均值。它是所有样本中某一特征的数值之和除以样本数量。特征均值用来表示数据在这一特征上的中心趋势。

  1. B, C, H, W = embedding_vectors.size()
  2. embedding_vectors = embedding_vectors.view(B, C, H * W)  # (img_num,550,56,56) -> (img_num,550,3136). 3136块
  3. mean = torch.mean(embedding_vectors, dim=0).numpy()  # (550,3136). 整个数据集的均值

（2）协方差：协方差反映了多个变量之间的相关性以及它们与各自均值的偏离程度，如果一个变量的值在均值附近波动较大（方差大），那么它对协方差的贡献也会较大。

（3）协方差矩阵：有p个特征，协方差矩阵是一个p x p的矩阵，其中每个元素(i, j)表示特征i和特征j之间的协方差。协方差矩阵通常用Σ来表示。 协方差矩阵的对角线上的元素是各个特征的方差（方差是协方差自己和自己的情况），而非对角线上的元素是不同特征之间的协方差。协方差矩阵计算公式如下。

x_{ij}^k是第k个图像的图像块ij的特征向量（向量长度是550，所以得到的协方差矩阵大小是(550,550)）， u_{ij}是整个正样本数据集的图像块ij位置上的特征均值向量（）。\epsilon I是正常项。N是数据集中正常图像个数。每个块都有自己的协方差矩阵。

1.2.3 计算异常图 inference: computation of the anomaly map

基于前面求得的正常样本均值mean和协方差矩阵covariance的逆，再求测试图像块特征的马氏距离，此距离作为每个块的异常分数。

其中x_{ij}是测试图像块的patch embedding. μ和∑是前面正常样本求得的均值和协方差。T是转置，-1是求逆。

2. 源码

https://github.com/xiahaifeng1995/PaDiM-Anomaly-Detection-Localization-master

2.1 dataset

没有数据增强，只有个中心裁剪，因为作者提出的方法没有训练过程，直接使用预训练模型，提取激活层的特征向量。

  1. import os
  2. # import tarfile
  3. from PIL import Image
  4. from tqdm import tqdm
  5. # import urllib.request
  6.  
  7. import torch
  8. from torch.utils.data import Dataset
  9. from torchvision import transforms as T
  10.  
  11.  
  12. # URL = 'ftp://guest:GU.205dldo@ftp.softronics.ch/mvtec_anomaly_detection/mvtec_anomaly_detection.tar.xz'
  13. CLASS_NAMES = ['bottle', 'cable', 'capsule', 'carpet', 'grid',
  14.                'hazelnut', 'leather', 'metal_nut', 'pill', 'screw',
  15.                'tile', 'toothbrush', 'transistor', 'wood', 'zipper']
  16.  
  17. # CLASS_NAMES = ['len_base']
  18.  
  19.  
  20. class MVTecDataset(Dataset):
  21.     def __init__(self, dataset_path='D:/dataset/mvtec_anomaly_detection', class_name='bottle', is_train=True,
  22.                  resize=256, cropsize=224):
  23.         assert class_name in CLASS_NAMES, 'class_name: {}, should be in {}'.format(class_name, CLASS_NAMES)
  24.         self.dataset_path = dataset_path
  25.         self.class_name = class_name  # 'bottle', 'cable' or 'capsule' et al.
  26.         self.is_train = is_train  # bool.
  27.         self.resize = resize  # 256
  28.         self.cropsize = cropsize  # 224  CenterCrop
  29.  
  30.         # load dataset: x:整个数据集的图片路径，对应的label(0/1)，对应的缺陷mask图像路径（good类别使用None）。
  31.         self.x, self.y, self.mask = self.load_dataset_folder() 
  32.  
  33.         # set transforms
  34.         self.transform_x = T.Compose([T.Resize(resize, Image.ANTIALIAS),
  35.                                       T.CenterCrop(cropsize),
  36.                                       T.ToTensor(),
  37.                                       T.Normalize(mean=[0.485, 0.456, 0.406],
  38.                                                   std=[0.229, 0.224, 0.225])])
  39.         self.transform_mask = T.Compose([T.Resize(resize, Image.NEAREST),  # 注意mask
  40.                                          T.CenterCrop(cropsize),
  41.                                          T.ToTensor()])
  42.  
  43.     def __getitem__(self, idx):
  44.         x, y, mask = self.x[idx], self.y[idx], self.mask[idx]  # 获取路径
  45.  
  46.         x = Image.open(x).convert('RGB')
  47.         x = self.transform_x(x)
  48.  
  49.         if y == 0:  # good图像的mask路径是None，所以这里生成全0缺陷mask
  50.             mask = torch.zeros([1, self.cropsize, self.cropsize]) 
  51.         else:
  52.             mask = Image.open(mask)
  53.             mask = self.transform_mask(mask)
  54.  
  55.         return x, y, mask
  56.  
  57.     def __len__(self):
  58.         return len(self.x)
  59.  
  60.     def load_dataset_folder(self):
  61.         phase = 'train' if self.is_train else 'test'
  62.         x, y, mask = [], [], []  # x:整个数据集的图片路径，对应的label(0/1)，对应的缺陷mask图像路径（good类别使用None）。
  63.  
  64.         img_dir = os.path.join(self.dataset_path, self.class_name, phase)
  65.         gt_dir = os.path.join(self.dataset_path, self.class_name, 'ground_truth')
  66.  
  67.         img_types = sorted(os.listdir(img_dir))  # train文件夹下只有good文件夹
  68.         for img_type in img_types:  # 遍历不同的文件夹，比如train目录下只有good文件夹。test目录下有各种缺陷文件夹。
  69.  
  70.             # load images
  71.             img_type_dir = os.path.join(img_dir, img_type)
  72.             if not os.path.isdir(img_type_dir):
  73.                 continue
  74.             img_fpath_list = sorted([os.path.join(img_type_dir, f)
  75.                                      for f in os.listdir(img_type_dir)
  76.                                      if f.endswith('.png')])
  77.             x.extend(img_fpath_list)
  78.  
  79.             # load gt labels。二分类问题：good or not. 
  80.             if img_type == 'good':
  81.                 y.extend([0] * len(img_fpath_list))  # 如果是good类别，则当前所有图像label都0
  82.                 mask.extend([None] * len(img_fpath_list))  # good类别没有缺陷mask
  83.             else:
  84.                 y.extend([1] * len(img_fpath_list))  # 不是good，则当前所有图像label都是1
  85.                 gt_type_dir = os.path.join(gt_dir, img_type)
  86.                 img_fname_list = [os.path.splitext(os.path.basename(f))[0] for f in img_fpath_list]
  87.                 gt_fpath_list = [os.path.join(gt_type_dir, img_fname + '_mask.png')
  88.                                  for img_fname in img_fname_list]
  89.                 mask.extend(gt_fpath_list)  # 并保存对应的mask图像路径
  90.  
  91.         assert len(x) == len(y), 'number of x and y should be same'
  92.  
  93.         return list(x), list(y), list(mask)

2.2 model

  1. from torchvision.models import wide_resnet50_2, resnet18
  2.  
  3. def main():
  4.  
  5.     args = parse_args()
  6.  
  7.     # 1, load model
  8.     if args.arch == 'resnet18':
  9.         model = resnet18(pretrained=True, progress=True)
  10.         t_d = 448
  11.         d = 100
  12.     elif args.arch == 'wide_resnet50_2':
  13.         model = wide_resnet50_2(pretrained=True, progress=True)
  14.         t_d = 1792  #
  15.         d = 550
  16.     model.to(device)
  17.     model.eval()
  18.  
  19.     # 这一行将Python内置的random模块的随机种子设置为1024。设置种子可以确保在相同种子的情况下，使用该模块进行的任何随机操作都会生成相同的随机数序列。通常用于实现可重现性。
  20.     random.seed(1024)
  21.     # 这一行将PyTorch的随机数生成器的种子设置为1024。这用于确保在PyTorch内进行的任何随机操作（例如神经网络权重的初始化）在相同种子下生成相同的结果。
  22.     torch.manual_seed(1024)
  23.     if use_cuda:
  24.         # 这一行设置PyTorch的CUDA（GPU）随机数生成器的种子。这将确保在GPU上进行的随机操作在使用种子1024时也能生成可重现的结果。
  25.         torch.cuda.manual_seed_all(1024)
  26.     idx = torch.tensor(sample(range(0, t_d), d))  # 在范围[0,1792]范围内随机生成550个整数。
  27.  
  28.     # set model's intermediate outputs。 只使用中间3个layer输出，第四个layer输出没有使用
  29.     outputs = []
  30.  
  31.     # 提取layer1，layer2，layer3层输出结果。
  32.     def hook(module, input, output):
  33.         outputs.append(output)
  34.     model.layer1[-1].register_forward_hook(hook)  # 每次前向都会调用一次hook，然后output会保持到outputs中。
  35.     model.layer2[-1].register_forward_hook(hook)
  36.     model.layer3[-1].register_forward_hook(hook)

2.3 提取特征

没有训练，则不需要定义loss函数、optimizer等等。直接dataset取数据，infer模型推理，获取中间的三个layer输出结果，然后提取特征向量的均值和协方差。

  1. import random
  2. from random import sample
  3. import argparse
  4. import numpy as np
  5. import os
  6. import pickle
  7. from tqdm import tqdm
  8. from collections import OrderedDict
  9.  
  10. import matplotlib.pyplot as plt
  11. import torch
  12.  
  13. from torch.utils.data import DataLoader
  14. from torchvision.models import wide_resnet50_2, resnet18
  15. import datasets.mvtec as mvtec
  16.  
  17. # device setup
  18. from utils import embedding_concat
  19.  
  20. use_cuda = torch.cuda.is_available()
  21. device = torch.device('cuda' if use_cuda else 'cpu')
  22.  
  23.  
  24. def parse_args():
  25.     parser = argparse.ArgumentParser('PaDiM')
  26.     parser.add_argument('--data_path', type=str, default='D:/dataset/mvtec_anomaly_detection')
  27.     parser.add_argument('--save_path', type=str, default='./mvtec_result')
  28.     parser.add_argument('--arch', type=str, choices=['resnet18', 'wide_resnet50_2'], default='wide_resnet50_2')
  29.     return parser.parse_args()
  30.  
  31.  
  32. def main():
  33.     args = parse_args()
  34.  
  35.     # 1, load model
  36.     if args.arch == 'resnet18':
  37.         model = resnet18(pretrained=True, progress=True)
  38.         t_d = 448
  39.         d = 100
  40.     elif args.arch == 'wide_resnet50_2':
  41.         model = wide_resnet50_2(pretrained=True, progress=True)
  42.         t_d = 1792  # 三个feature通道数的和256+512+1024. 在范围[0,1792]范围内随机生成550个整数。
  43.         d = 550  # 随机选择550个值
  44.     model.to(device)  # to cuda
  45.     model.eval()
  46.  
  47.     # 这一行将Python内置的random模块的随机种子设置为1024。设置种子可以确保在相同种子的情况下，使用该模块进行的任何随机操作都会生成相同的随机数序列。通常用于实现可重现性。
  48.     random.seed(1024)
  49.     # 这一行将PyTorch的随机数生成器的种子设置为1024。这用于确保在PyTorch内进行的任何随机操作（例如神经网络权重的初始化）在相同种子下生成相同的结果。
  50.     torch.manual_seed(1024)
  51.     if use_cuda:
  52.         # 这一行设置PyTorch的CUDA（GPU）随机数生成器的种子。这将确保在GPU上进行的随机操作在使用种子1024时也能生成可重现的结果。
  53.         torch.cuda.manual_seed_all(1024)
  54.     idx = torch.tensor(sample(range(0, t_d), d))  # 在范围[0,1792]范围内随机生成550个整数。
  55.  
  56.     # set model's intermediate outputs。 只使用中间3个layer输出，第四个layer输出没有使用
  57.     outputs = []
  58.  
  59.     # 提取layer1，layer2，layer3层输出结果。
  60.     def hook(module, input, output):
  61.         outputs.append(output)
  62.  
  63.     model.layer1[-1].register_forward_hook(hook)  # 每次前向都会调用一次hook，然后output会保持到outputs中。
  64.     model.layer2[-1].register_forward_hook(hook)
  65.     model.layer3[-1].register_forward_hook(hook)
  66.  
  67.     # 创建特征pickle文件保存路径，其实就是存放[mean, cov]，每个数据集都有一个pickle文件。
  68.     os.makedirs(os.path.join(args.save_path, 'temp_%s' % args.arch), exist_ok=True)
  69.     fig, ax = plt.subplots(1, 2, figsize=(20, 10))  # 一行两列fig
  70.  
  71.     for class_name in mvtec.CLASS_NAMES:  # 遍历不同的数据集
  72.         # 2, dataset
  73.         train_dataset = mvtec.MVTecDataset(args.data_path, class_name=class_name, is_train=True)
  74.         train_dataloader = DataLoader(train_dataset, batch_size=32, pin_memory=True)
  75.         # layer1：所有数据集layer1输出向量，每个向量的shape是[b,256,56,56]
  76.         # layer2: 所有数据集layer2输出向量，每个向量的shape是[b,512,28,28]
  77.         # layer3: 所有数据集layer3输出向量，每个向量的shape是[b,1024,14,14]
  78.         train_outputs = OrderedDict([('layer1', []), ('layer2', []), ('layer3', [])])
  79.  
  80.         # 3, extract train set features （pickle文件保存）
  81.         train_feature_filepath = os.path.join(args.save_path, 'temp_%s' % args.arch, 'train_%s.pkl' % class_name)
  82.         if not os.path.exists(train_feature_filepath):  # 不存在此数据集的特征pickle文件，则进行特征提取
  83.             for (x, _, _) in tqdm(train_dataloader, '| feature extraction | train | %s |' % class_name):
  84.                 # model prediction
  85.                 with torch.no_grad():  # 没有训练，x(b,32,224,224) to cuda，然后直接 batch infer
  86.                     _ = model(x.to(device))  # 没有使用返回结果，因为前面定义了hook保存了中间结果到outputs
  87.                 # get intermediate layer outputs
  88.                 for k, v in zip(train_outputs.keys(), outputs):  # 保存3个cuda tensor到字典中
  89.                     train_outputs[k].append(v.cpu().detach())
  90.                 # initialize hook outputs
  91.                 outputs = []  # 置空，迭代赋值
  92.             for k, v in train_outputs.items():
  93.                 train_outputs[k] = torch.cat(v, 0)  # list of tensor(b,256,56,56). -> (img_num,256,56,56)
  94.  
  95.             # Embedding concat
  96.             embedding_vectors = train_outputs['layer1']
  97.             for layer_name in ['layer2', 'layer3']:
  98.                 embedding_vectors = embedding_concat(embedding_vectors, train_outputs[layer_name])
  99.  
  100.             # randomly select d dimension
  101.             embedding_vectors = torch.index_select(embedding_vectors, 1, idx)  # 在范围[0,1792]范围内随机生成550个整数。
  102.  
  103.             # calculate multivariate Gaussian distribution
  104.             B, C, H, W = embedding_vectors.size()
  105.             embedding_vectors = embedding_vectors.view(B, C, H * W)  # (img_num,550,56,56) -> (img_num,550,3136). 3136块
  106.             mean = torch.mean(embedding_vectors, dim=0).numpy()  # (550,3136). 整个数据集的均值
  107.             cov = torch.zeros(C, C, H * W).numpy()  # (550,550,3136)协方差矩阵
  108.             I = np.identity(n=C)  # (550,550).单位矩阵
  109.             for i in range(H * W):  # 依次求每个块的协方差矩阵(550,550)。每个块都有自己的协方差矩阵。
  110.                 # cov[:, :, i] = LedoitWolf().fit(embedding_vectors[:, :, i].numpy()).covariance_
  111.                 # np.cov: covariance matrix
  112.                 # rowvar=False: each column represents a variable(特征、变量), while the rows contain observations(观察，样本).
  113.                 cov[:, :, i] = np.cov(embedding_vectors[:, :, i].numpy(), rowvar=False) + 0.01 * I
  114.             # save learned distribution
  115.             train_outputs = [mean, cov]  # list of numpy. mean.shape=(550,3136). cov.shape=(550,550,3136)
  116.             with open(train_feature_filepath, 'wb') as f:
  117.                 print("start dump feature: %s --------" % class_name)
  118.                 pickle.dump(train_outputs, f)
  119.                 print("finish dump-----------")
  120.         else:  # 已存在，则直接载入。
  121.             print('The file already exists: %s' % train_feature_filepath)
  122.  
  123.  
  124. if __name__ == '__main__':
  125.     main()

2.4 infer

  1. import random
  2. from random import sample
  3. import argparse
  4. import numpy as np
  5. import os
  6. import pickle
  7. from tqdm import tqdm
  8. from collections import OrderedDict
  9. from sklearn.metrics import roc_auc_score
  10. from sklearn.metrics import roc_curve
  11. from sklearn.metrics import precision_recall_curve
  12. from scipy.spatial.distance import mahalanobis
  13. from scipy.ndimage import gaussian_filter
  14. import matplotlib.pyplot as plt
  15.  
  16. import torch
  17. import torch.nn.functional as F
  18. from torch.utils.data import DataLoader
  19. from torchvision.models import wide_resnet50_2, resnet18
  20. import datasets.mvtec as mvtec
  21.  
  22. # device setup
  23. from utils import embedding_concat, plot_fig
  24.  
  25. use_cuda = torch.cuda.is_available()
  26. device = torch.device('cuda' if use_cuda else 'cpu')
  27.  
  28.  
  29. def parse_args():
  30.     parser = argparse.ArgumentParser('PaDiM')
  31.     parser.add_argument('--data_path', type=str, default='D:/dataset/mvtec_anomaly_detection')
  32.     parser.add_argument('--save_path', type=str, default='./mvtec_result')
  33.     parser.add_argument('--arch', type=str, choices=['resnet18', 'wide_resnet50_2'], default='wide_resnet50_2')
  34.     return parser.parse_args()
  35.  
  36.  
  37. def main():
  38.     args = parse_args()
  39.  
  40.     # 1, load model
  41.     if args.arch == 'resnet18':
  42.         model = resnet18(pretrained=True, progress=True)
  43.         t_d = 448
  44.         d = 100
  45.     elif args.arch == 'wide_resnet50_2':
  46.         model = wide_resnet50_2(pretrained=True, progress=True)
  47.         t_d = 1792  # 三个feature通道数的和256+512+1024. 在范围[0,1792]范围内随机生成550个整数。
  48.         d = 550  # 随机选择550个值
  49.     model.to(device)  # to cuda
  50.     model.eval()
  51.  
  52.     # 这一行将Python内置的random模块的随机种子设置为1024。设置种子可以确保在相同种子的情况下，使用该模块进行的任何随机操作都会生成相同的随机数序列。通常用于实现可重现性。
  53.     random.seed(1024)
  54.     # 这一行将PyTorch的随机数生成器的种子设置为1024。这用于确保在PyTorch内进行的任何随机操作（例如神经网络权重的初始化）在相同种子下生成相同的结果。
  55.     torch.manual_seed(1024)
  56.     if use_cuda:
  57.         # 这一行设置PyTorch的CUDA（GPU）随机数生成器的种子。这将确保在GPU上进行的随机操作在使用种子1024时也能生成可重现的结果。
  58.         torch.cuda.manual_seed_all(1024)
  59.     idx = torch.tensor(sample(range(0, t_d), d))  # 在范围[0,1792]范围内随机生成550个整数。
  60.  
  61.     # set model's intermediate outputs。 只使用中间3个layer输出，第四个layer输出没有使用
  62.     outputs = []
  63.  
  64.     # 提取layer1，layer2，layer3层输出结果。
  65.     def hook(module, input, output):
  66.         outputs.append(output)
  67.  
  68.     model.layer1[-1].register_forward_hook(hook)  # 每次前向都会调用一次hook，然后output会保持到outputs中。
  69.     model.layer2[-1].register_forward_hook(hook)
  70.     model.layer3[-1].register_forward_hook(hook)
  71.  
  72.     # 创建特征pickle文件保存路径，其实就是存放[mean, cov]，每个数据集都有一个pickle文件。
  73.     os.makedirs(os.path.join(args.save_path, 'temp_%s' % args.arch), exist_ok=True)
  74.     fig, ax = plt.subplots(1, 2, figsize=(20, 10))  # 一行两列fig
  75.     fig_img_rocauc = ax[0]  # 第0列fig
  76.     fig_pixel_rocauc = ax[1]  # 第1列fig
  77.  
  78.     total_roc_auc = []  # test auc list. 不同class的auc
  79.     total_pixel_roc_auc = []  #
  80.  
  81.     for class_name in mvtec.CLASS_NAMES:  # 遍历不同的数据集
  82.         train_feature_filepath = os.path.join(args.save_path, 'temp_%s' % args.arch, 'train_%s.pkl' % class_name)
  83.         with open(train_feature_filepath, 'rb') as f:
  84.             train_outputs = pickle.load(f)
  85.  
  86.         # 2, dataset
  87.         test_dataset = mvtec.MVTecDataset(args.data_path, class_name=class_name, is_train=False)
  88.         test_dataloader = DataLoader(test_dataset, batch_size=32, pin_memory=True)
  89.         # layer1：所有数据集layer1输出向量，每个向量的shape是[b,256,56,56]
  90.         # layer2: 所有数据集layer2输出向量，每个向量的shape是[b,512,28,28]
  91.         # layer3: 所有数据集layer3输出向量，每个向量的shape是[b,1024,14,14]
  92.         test_outputs = OrderedDict([('layer1', []), ('layer2', []), ('layer3', [])])
  93.  
  94.         gt_list = []
  95.         gt_mask_list = []
  96.         test_imgs = []
  97.  
  98.         # 4, extract test set features
  99.         for (x, y, mask) in tqdm(test_dataloader, '| feature extraction | test | %s |' % class_name):
  100.             test_imgs.extend(x.cpu().detach().numpy())
  101.             gt_list.extend(y.cpu().detach().numpy())
  102.             gt_mask_list.extend(mask.cpu().detach().numpy())
  103.             # model prediction
  104.             with torch.no_grad():
  105.                 _ = model(x.to(device))  # x to cuda. x.shape=(32,3,224,224)
  106.             # get intermediate layer outputs
  107.             for k, v in zip(test_outputs.keys(), outputs):
  108.                 test_outputs[k].append(v.cpu().detach())
  109.             # initialize hook outputs
  110.             outputs = []
  111.         for k, v in test_outputs.items():
  112.             test_outputs[k] = torch.cat(v, 0)
  113.  
  114.         # Embedding concat. 将不同层的输出cat在一起
  115.         # layer1(img_num,256,56,56),layer2(img_num,512,28,28),layer3(img_num,1024,14,14)
  116.         embedding_vectors = test_outputs['layer1']
  117.         for layer_name in ['layer2', 'layer3']:
  118.             embedding_vectors = embedding_concat(embedding_vectors, test_outputs[layer_name])
  119.  
  120.         # randomly select d dimension. embedding_vectors.shape=torch.Size([img_num, 1792, 56, 56])
  121.         # 注意idx，要和前面train一样。
  122.         embedding_vectors = torch.index_select(embedding_vectors, 1, idx)  # (img_num,1792,56,56)->(img_num,550,56,56)
  123.  
  124.         # 5. calculate distance matrix
  125.         B, C, H, W = embedding_vectors.size()
  126.         embedding_vectors = embedding_vectors.view(B, C, H * W).numpy()  # (img_num,550,56,56)->(img_num,550,56*56)
  127.         dist_list = []
  128.         for i in range(H * W):  # 遍历每个patch
  129.             mean = train_outputs[0][:, i]  # train_outputs=[mean(550,3136), cov(550,550,3136)]. 第i块均值
  130.             conv_inv = np.linalg.inv(train_outputs[1][:, :, i])  # 第i块协方差矩阵的逆矩阵。(550,550)
  131.  
  132.             # embedding_vectors.shape(img_num,550,3136). sample.shape(550,3136)
  133.             # 特征块 sample[:, i].shape(550). 均值mean.shape(550). 协方差矩阵的逆矩阵conv_inv(550,550)
  134.             # dist. list of dis. len=(img_num). 每张图像的每个patch有一个距离值. scipy.spatial.distance
  135.             dist = [mahalanobis(sample[:, i], mean, conv_inv) for sample in embedding_vectors]  # 遍历测试图像，马氏距离
  136.             dist_list.append(dist)  # {0: list(img_num), 1: list(img_num), patch_idx: list(img_num)}
  137.  
  138.         dist_list = np.array(dist_list).transpose(1, 0).reshape(B, H, W)  # (patch_num,image_num)->(83,3136)->(83,56,56)
  139.  
  140.         # 6. upsample distance map.
  141.         dist_list = torch.tensor(dist_list)
  142.         score_map = F.interpolate(dist_list.unsqueeze(1), size=x.size(2), mode='bilinear',
  143.                                   align_corners=False).squeeze().numpy()  # (83,56,56)->(83,224,224)
  144.  
  145.         # 7. apply gaussian smoothing on the score map. 将patch score平滑成image score.
  146.         for i in range(score_map.shape[0]):  # each test image. scipy.ndimage
  147.             score_map[i] = gaussian_filter(score_map[i], sigma=4)  # (224,224)
  148.  
  149.         # Normalization. val->(0,1)
  150.         max_score = score_map.max()
  151.         min_score = score_map.min()
  152.         scores = (score_map - min_score) / (max_score - min_score)  # (img_num,224,224)
  153.  
  154.         # 8. calculate image-level ROC AUC score. 图像级别的异常分数
  155.         img_scores = scores.reshape(scores.shape[0], -1).max(
  156.             axis=1)  # (img_num,224,224) -> (img_num,224*224) ->(img_num)
  157.         gt_list = np.asarray(gt_list)  # (img_num,)
  158.         fpr, tpr, _ = roc_curve(gt_list, img_scores)  # sklearn.metrics. shape (img_num)
  159.         img_roc_auc = roc_auc_score(gt_list, img_scores)  # auc.
  160.         total_roc_auc.append(img_roc_auc)  # auc list
  161.         print('image ROCAUC: %.3f' % (img_roc_auc))  # 当前数据集类别(bottle)的auc
  162.         fig_img_rocauc.plot(fpr, tpr, label='%s img_ROCAUC: %.3f' % (class_name, img_roc_auc))
  163.  
  164.         # get optimal threshold：# 使用最大F值对应的那个阈值（同时考虑召回率和准确率）
  165.         gt_mask = np.asarray(gt_mask_list)  # list of tensor. -> (img_num,1,224,224). scores.shape(img_num,224,224)
  166.         # thresholds不同的阈值，返回不同的准确率和召回率
  167.         precision, recall, thresholds = precision_recall_curve(gt_mask.flatten(), scores.flatten())  # sklearn.metrics
  168.         a = 2 * precision * recall  # 不同的阈值下，求F值
  169.         b = precision + recall  # a/b
  170.         f1 = np.divide(a, b, out=np.zeros_like(a), where=b != 0)  # 防止除0操作
  171.         threshold = thresholds[np.argmax(f1)]  # 使用最大F值对应的那个阈值。
  172.  
  173.         # calculate per-pixel level ROCAUC. (img_num,1,224,224). scores.shape(img_num,224,224)
  174.         fpr, tpr, _ = roc_curve(gt_mask.flatten(), scores.flatten())
  175.         per_pixel_rocauc = roc_auc_score(gt_mask.flatten(), scores.flatten())
  176.         total_pixel_roc_auc.append(per_pixel_rocauc)
  177.         print('pixel ROCAUC: %.3f' % (per_pixel_rocauc))
  178.  
  179.         fig_pixel_rocauc.plot(fpr, tpr, label='%s ROCAUC: %.3f' % (class_name, per_pixel_rocauc))
  180.         save_dir = args.save_path + '/' + f'pictures_{args.arch}'
  181.         os.makedirs(save_dir, exist_ok=True)
  182.         # 原图list (3,224,224).
  183.         plot_fig(test_imgs, scores, gt_mask_list, threshold, save_dir, class_name)
  184.  
  185.     print('Average ROCAUC: %.3f' % np.mean(total_roc_auc))
  186.     fig_img_rocauc.title.set_text('Average image ROCAUC: %.3f' % np.mean(total_roc_auc))
  187.     fig_img_rocauc.legend(loc="lower right")
  188.  
  189.     print('Average pixel ROCUAC: %.3f' % np.mean(total_pixel_roc_auc))
  190.     fig_pixel_rocauc.title.set_text('Average pixel ROCAUC: %.3f' % np.mean(total_pixel_roc_auc))
  191.     fig_pixel_rocauc.legend(loc="lower right")
  192.  
  193.     fig.tight_layout()
  194.     fig.savefig(os.path.join(args.save_path, 'roc_curve.png'), dpi=100)
  195.  
  196.  
  197.  
  198.  
  199. if __name__ == '__main__':
  200.     main()

参考：GitHub - xiahaifeng1995/PaDiM-Anomaly-Detection-Localization-master: This is an unofficial implementation of the paper “PaDiM: a Patch Distribution Modeling Framework for Anomaly Detection and Localization”.This is an unofficial implementation of the paper “PaDiM: a Patch Distribution Modeling Framework for Anomaly Detection and Localization”. - GitHub - xiahaifeng1995/PaDiM-Anomaly-Detection-Localization-master: This is an unofficial implementation of the paper “PaDiM: a Patch Distribution Modeling Framework for Anomaly Detection and Localization”.icon-default.png?t=N7T8https://github.com/xiahaifeng1995/PaDiM-Anomaly-Detection-Localization-master

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/747333
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号