如何使用C#实现Padim算法的训练和推理

目录

说明

项目背景

算法实现

预处理模块——图像预处理

主要模块——训练：Resnet层信息提取

主要模块——信息处理，计算Anomaly Map

主要模块——评估

主要模块——评估：门限值的确定

主要模块——推理

写在最后

项目下载链接

说明

作者：来瓶霸王防脱发

项目地址：

https://github.com/IntptrMax/PadimSharp

原文地址：

https://blog.csdn.net/qq_30270773/article/details/143029865

项目背景

缺陷检测(Anomaly Detection)算法是一个区分正常类别与异常类别的二分类问题，但在工业场景中大多数数据都为良品，不良数据难以获取，更难枚举，所以训练一个全监督的模型是不切实际的。因此，异常检测模型通常以单类别学习的模式。Padim算法是一种十分优秀的缺陷检测算法，直接上图可以看一下这个算法的效果。

良品图片

图片

不良品图片

图片

检测效果

图片

C#是一种十分受欢迎的编程语言，这种编程语言在工业场景下使用也是十分广泛的。在一些AI领域，会在Python下将模型转化为onnx形式，通过onnxruntime加载使用，进行推理。但是在onnx形式下进行训练十分困难。很多C#开发者不太熟悉Python环境，或者某些条件下希望在纯粹的C#环境下进行深度学习的训练和使用。这个还是有一定的困难的。

目前搜索了Github和CSDN排名靠前的几十条数据，还没有Padim算法在除Python平台下的训练+推理的相关项目或资料。本文就是在C#平台实现了Padim的训练+推理过程，应该在相关领域也算是独一份了。

算法实现

Padim算法的“训练”过程其实并没有涉及到真正的训练，而是使用Resnet18算法提取关键信息加以处理，在推理时再次使用，因此“训练”过程速度非常快，这也是这个算法的优点之一。Padim算法的具体实现还请参考相关论文：PaDiM: a Patch Distribution Modeling Framework for Anomaly Detection and Localization

https://arxiv.org/abs/2011.08785

如果论文看起来困难，还有一些大佬对该算法在Python平台下的解读，也可以参考：PaDiM 原理与代码解析

https://blog.csdn.net/ooooocj/article/details/127601035

预处理模块——图像预处理

图像预处理使用的方法比较常规，使用了缩放等方式，此处并没有使用LetterBox，也可以达到预期效果：

  1. var transformers = torchvision.transforms.Compose([
  2.     torchvision.transforms.Resize(resizeHeight,resizeWidth),
  3. torchvision.transforms.CenterCrop(cropHeight,cropWidth),
  4. torchvision.transforms.Normalize(means, stdevs)]);
  5.

主要模块——训练：Resnet层信息提取

使用Resnet模型进行推理，并提取Layer1、Layer2、Layer3层的信息，并进行了拼接(EmbeddingConcat)。注意：这里提取时使用了钩子，钩子在使用时会有资源释放，因此这里使用了比较迂回的方式记录结果

实现代码如下：

  1. public List<(string, Tensor)> Forward(Tensor input)
  2. {
  3.  List<(string, Tensor)> outputs = new List<(string, Tensor)>();
  4.  List<TempTensor> tempTensors = new List<TempTensor>();
  5.  foreach (var named_module in model.named_children())
  6.  {
  7.   string name = named_module.name;
  8.   if (name == "layer1" || name == "layer2" || name == "layer3")
  9.   {
  10.    ((Sequential)named_module.module).register_forward_hook((Module, input, output) =>
  11.    {
  12.     tempTensors.Add(new TempTensor
  13.     {
  14.      Data = output.data<float>().ToArray(),
  15.      Name = name,
  16.      Shape = output.shape,
  17.     });
  18.     return null;
  19.    });
  20.   }
  21.  }
  22.  model.forward(input);
  23.  
  24.  var layer1output = tempTensors.Find(a => a.Name == "layer1");
  25.  var layer2output = tempTensors.Find(a => a.Name == "layer2");
  26.  var layer3output = tempTensors.Find(a => a.Name == "layer3");
  27.  
  28.  Tensor l1 = torch.tensor(layer1output.Data, layer1output.Shape, device: input.device);
  29.  Tensor l2 = torch.tensor(layer2output.Data, layer2output.Shape, device: input.device);
  30.  Tensor l3 = torch.tensor(layer3output.Data, layer3output.Shape, device: input.device);
  31.  outputs.Add(new("layer1", l1));
  32.  outputs.Add(new("layer2", l2));
  33.  outputs.Add(new("layer3", l3));
  34.  GC.Collect();
  35.  return outputs;
  36. }
  37.  
  1. private Tensor EmbeddingConcat(Tensor[] features)
  2. {
  3.  var embeddings = features[0];
  4.  
  5.  for (int i = 1; i < features.Length; i++)
  6.  {
  7.   var layerEmbedding = features[i];
  8.   layerEmbedding = torch.nn.functional.interpolate(layerEmbedding, size: [embeddings.shape[2], embeddings.shape[2]], mode: InterpolationMode.Nearest);
  9.   embeddings = torch.cat([embeddings, layerEmbedding], 1);
  10.  }
  11.  return embeddings;
  12. }
  13.

主要模块——信息处理，计算Anomaly Map

这一块主要对信息进行处理，获取矩阵的mean和cov(协方差矩阵)，代码如下：

  1. public Tensor ComputeAnomalyMapInternal(Tensor embedding, Tensor mean, Tensor covariance)
  2. {
  3.  var scoreMap = ComputeDistance(embedding, mean, covariance);
  4.  var upSampledScoreMap = UpSample(scoreMap);
  5.  var smoothedAnomalyMap = SmoothAnomalyMap(upSampledScoreMap);
  6.  return smoothedAnomalyMap;
  7. }
  8.  
  9. public Tensor ComputeAnomalyMap(List<(string, Tensor)> outputs, Tensor mean, Tensor covariance, Tensor idx)
  10. {
  11.  Tensor embedding = GetEmbedding(outputs);
  12.  var embeddingVectors = torch.index_select(embedding, 1, idx);
  13.  return ComputeAnomalyMapInternal(embeddingVectors, mean, covariance);
  14. }
  15.

主要模块——评估

与训练过程开始部分相似，也是获取图像的Embeddings，然后利用之前获取的Cov和mean计算马氏距离，以此评估图像的异常情况。马氏距离的计算方法如下：

  1. private Tensor ComputeDistance(Tensor embedding, Tensor mean, Tensor covariance)
  2. {
  3.  long batch = embedding.shape[0];
  4.  long channel = embedding.shape[1];
  5.  long height = embedding.shape[2];
  6.  long width = embedding.shape[3];
  7.  
  8.  Tensor inv_covariance = covariance.permute(2, 0, 1).inverse();
  9.  var embedding_reshaped = embedding.reshape(batch, channel, height * width);
  10.  var delta = (embedding_reshaped - mean).permute(2, 0, 1);
  11.  var distances = (torch.matmul(delta, inv_covariance) * delta).sum(2).permute(1, 0);
  12.  distances = distances.reshape(batch, 1, height, width);
  13.  distances = distances.clamp(0).sqrt();
  14.  return distances;
  15. }
  16.

主要模块——评估：门限值的确定

这里需要确定图像的评估门限和像素值的评估门限。如果在评估时有负向样本，这个值会更准确，如果只有正向样本也是可以的。在Python下有个precision_recall_curve包，可以计算相关参数，但是在C#下时没有的，因此在此处仍旧只能造轮子，代码如下：

  1. private (float[] precisions, float[] recalls, float[] thresholds) _precision_recall_curve_compute_single_class(Tensor yTrue, Tensor yScores, int pos_label = 1)
  2. {
  3.  var (fps, tps, thresholds) = BinaryClfCurve(yScores, yTrue, pos_label);
  4.  var precision = tps / (tps + fps);
  5.  var recall = tps / tps[-1];
  6.  
  7.  var lastInd = torch.where(tps == tps[-1])[0][0].ToInt32();
  8.  int[] sl = new int[lastInd + 1];
  9.  for (int i = 0; i < sl.Length; i++)
  10.  {
  11.   sl[i] = i;
  12.  }
  13.  var reversedPrecision = precision[sl].flip(0);
  14.  var reversedRecall = recall[sl].flip(0);
  15.  var reversedThresholds = thresholds[sl].flip(0);
  16.  
  17.  precision = torch.cat(new Tensor[] { reversedPrecision, torch.ones(1, dtype: precision.dtype, device: precision.device) });
  18.  recall = torch.cat(new Tensor[] { reversedRecall, torch.zeros(1, dtype: recall.dtype, device: recall.device) });
  19.  
  20.  return (precision.data<float>().ToArray(), recall.data<float>().ToArray(), reversedThresholds.data<float>().ToArray());
  21. }
  22.  
  23. private (Tensor fps, Tensor tps, Tensor thresholds) BinaryClfCurve(Tensor preds, Tensor target, int posLabel = 1)
  24. {
  25.  using (torch.no_grad())
  26.  {
  27.   if (preds.ndim > target.ndim)
  28.   {
  29.    preds = preds[TensorIndex.Ellipsis, 0];
  30.   }
  31.  
  32.   var descScoreIndices = torch.argsort(preds, descending: true);
  33.   preds = preds[descScoreIndices];
  34.   target = target[descScoreIndices];
  35.  
  36.   Tensor weight = torch.tensor(1.0f);
  37.  
  38.   var distinctValueIndices = torch.nonzero(preds[1..] - preds[..^1]).squeeze();
  39.   var thresholdIdxs = torch.cat(new Tensor[] { distinctValueIndices, torch.tensor(new long[] { target.shape[0] - 1 }, device: preds.device) });
  40.  
  41.   target = (target == posLabel).to_type(ScalarType.Int64);
  42.  
  43.   var tps = torch.cumsum(target * weight, dim: 0)[thresholdIdxs];
  44.  
  45.   Tensor fps = 1 + thresholdIdxs - tps;
  46.   return (fps, tps, preds[thresholdIdxs]);
  47.  }
  48. }
  49.

主要模块——推理

这个过程与上面过程也十分相似，正向计算出图像的Anomaly Map后，取出这个张量中最大的值，与图像的门限值进行比较，即可评估图像是否是良品。然后对这个张量中每个元素与像素门限值做对比，即可得到按像素的异常区域，以便绘制Mask和热力图。

  1. Tensor orgImg = tensors["orgImage"].clone().to(device);
  2. Tensor t = anomaly_map > pixel_threshold;
  3. anomaly_map = (anomaly_map * t).squeeze(0);
  4. anomaly_map = torchvision.transforms.functional.resize(anomaly_map, (int)orgImg.size(2), (int)orgImg.size(1));
  5. Tensor heatmapNormalized = (anomaly_map - anomaly_map.min()) / (anomaly_map.max() - anomaly_map.min());
  6. Tensor coloredHeatmap = torch.zeros([3, (int)orgImg.size(2), (int)orgImg.size(1)],device:anomaly_map.device);
  7.  
  8. coloredHeatmap[0] = heatmapNormalized.squeeze(0);
  9.  
  10. float alpha = 0.3f;
  11. Tensor blendedImage = (1 - alpha) * (orgImg / 255.0f) + alpha * coloredHeatmap;
  12. var imageTensor = blendedImage.clamp(0, 1).mul(255).to(ScalarType.Byte);
  13.  
  14. torchvision.io.write_jpeg(imageTensor.cpu(), "result.jpg");
  15.

写在最后

使用C#开发深度学习项目，尤其是训练的项目，是一个十分困难的过程。或者说除了Python平台，训练都十分困难。C#进行深度学习训练这个方向在国内基本很少有人开展，所以能查得到的资料很少。本人十分喜爱C#这门语言，又十分喜爱深度学习，因此仅半年一直在这方面努力。遇到了很多困难，也收获了很多。

这条路走的不容易，希望能有更多人能加入进来，一起开发，一起学习。

我在Github上已经将完整的代码发布了，项目地址为：

https://github.com/IntptrMax/PadimSharp

，期待你能在Github上送我一颗小星星。在我的Github里还GGMLSharp这个项目，这个项目也是C#平台下深度学习的开发包，希望能得到你的支持。

项目下载链接

https://download.csdn.net/download/qq_30270773/89897710
天天代码码天天
微信公众号
.NET 人工智能实践
注：本文转载自blog.csdn.net的天天代码码天天的文章"https://lw112190.blog.csdn.net/article/details/143033329"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！