用自己网络添加注意力机制后画出热力图

这篇具有很好参考价值的文章主要介绍了用自己网络添加注意力机制后画出热力图。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

不知道大家有没有像我这样的困惑,就是加了注意力机制到自己网络里面之后,算法性能提升不大,不知道自己添加的注意力有没有关注自己所希望关注的地方,于是就想验证自己的注意力是否有用,然后又不知道怎么验证它。
反正我被这个问题困惑了好久,经过几天CSDN的“拾荒“”,我总算了解了如何将注意力热力图添加到自己的网络中,现在我将以一个通用的例子举例,然后再将其应用到我自己的网络中:

1.首先我们需要构建一个极简的网络:

from PIL import Image
import torchvision
import cv2
import numpy as np
from collections import OrderedDict
import torch
import torch.nn as nn

class MDNet(nn.Module):
    def __init__(self, model_path=None, K=1):
        super(MDNet, self).__init__()
        self.avgpool=nn.AdaptiveAvgPool2d(1)
        self.layers=nn.Sequential(OrderedDict([
                ('conv1', nn.Sequential(nn.Conv2d(3, 96, kernel_size=7, stride=2),
                                        nn.ReLU(inplace=True),
                                        nn.LocalResponseNorm(2),
                                        nn.MaxPool2d(kernel_size=3, stride=2))),
                ('conv2', nn.Sequential(nn.Conv2d(96, 256, kernel_size=5, stride=2),
                            nn.ReLU(inplace=True),
                            nn.LocalResponseNorm(2),
                            nn.MaxPool2d(kernel_size=3, stride=2))),
                ('features', nn.Sequential(nn.Conv2d(3, 512, kernel_size=3, stride=1),
                                  nn.ReLU(inplace=True))),
                ('fc4', nn.Sequential(nn.Linear(500, 512),
                                  nn.ReLU(inplace=True))),
                ('fc5', nn.Sequential(nn.Dropout(0.5),
                                  nn.Linear(500, 512),
                                  nn.ReLU(inplace=True)))
        ]))

    def forward(self, x):
        avg_result = self.avgpool(x)
        output = self.layers(x)
        return output
if __name__ == '__main__':
    net = MDNet()

其次将该模型保存下来,即在代码中添加:

def save_model(model):
    torch.save(obj=model, f='B.pth')

具体代码如下:

from PIL import Image
import torchvision
import cv2
import numpy as np
from collections import OrderedDict
import torch
import torch.nn as nn


class MDNet(nn.Module):
    def __init__(self, model_path=None, K=1):
        super(MDNet, self).__init__()
        self.avgpool=nn.AdaptiveAvgPool2d(1)
        self.layers=nn.Sequential(OrderedDict([
                ('conv1', nn.Sequential(nn.Conv2d(3, 96, kernel_size=7, stride=2),
                                        nn.ReLU(inplace=True),
                                        nn.LocalResponseNorm(2),
                                        nn.MaxPool2d(kernel_size=3, stride=2))),
                ('conv2', nn.Sequential(nn.Conv2d(96, 256, kernel_size=5, stride=2),
                            nn.ReLU(inplace=True),
                            nn.LocalResponseNorm(2),
                            nn.MaxPool2d(kernel_size=3, stride=2))),
                ('features', nn.Sequential(nn.Conv2d(3, 512, kernel_size=3, stride=1),
                                  nn.ReLU(inplace=True))),
                ('fc4', nn.Sequential(nn.Linear(500, 512),
                                  nn.ReLU(inplace=True))),
                ('fc5', nn.Sequential(nn.Dropout(0.5),
                                  nn.Linear(500, 512),
                                  nn.ReLU(inplace=True)))
        ]))

    def forward(self, x):
        avg_result = self.avgpool(x)
        output = self.layers(x)
        return output

def save_model(model):
    torch.save(obj=model, f='B.pth')

if __name__ == '__main__':
    net = MDNet()
    save_model(net)
    # model = torch.load(f="A.pth")

运行Python后可以看见生成了一个B.pth文件
用自己网络添加注意力机制后画出热力图

2.使用热红外图生成图片:

#图片路径
img_path = r'C:/Users/HP/Desktop/w/1.jpg'

#给图片进行标准化操作
img = Image.open(img_path).convert('RGB')
transforms = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor(),
    torchvision.transforms.Normalize([0.5, ], [0.5, ])])
data = transforms(img).unsqueeze(0)

#用于加载Pycharm中封装好的网络框架
# model = torchvision.models.vgg11_bn(pretrained=True)
#用于加载1中生成的.pth文件
model = torch.load(f="B.pth")
#打印一下刚刚生成的.pth文件看看他的网络结构
print(model)
model.eval()

#读取他fc4层图片特征
features = net.layers.Conv1(data)
features.retain_grad()
# t = model.avgpool(features)
# t = t.reshape(1, -1)
# output = model.classifier(t)[0]


# pred = torch.argmax(output).item()
# pred_class = output[pred]
#
# pred_class.backward()
grads = features.grad


features = features[0]
# avg_grads = torch.mean(grads[0], dim=(1, 2))
# avg_grads = avg_grads.expand(features.shape[1], features.shape[2], features.shape[0]).permute(2, 0, 1)
# features *= avg_grads

heatmap = features.detach().cpu().numpy()
heatmap = np.mean(heatmap, axis=0)

heatmap = np.maximum(heatmap, 0)
heatmap /= (np.max(heatmap) + 1e-8)


img = cv2.imread(img_path)
heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0]))
heatmap = np.uint8(255 * heatmap)
heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
superimposed_img = np.uint8(heatmap * 0.5 + img * 0.5)
cv2.imshow('1', superimposed_img)
cv2.waitKey(0)

3.总代码:

from PIL import Image
import torchvision
import cv2
import numpy as np
from collections import OrderedDict
import torch
import torch.nn as nn


class MDNet(nn.Module):
    def __init__(self, model_path=None, K=1):
        super(MDNet, self).__init__()
        self.avgpool=nn.AdaptiveAvgPool2d(1)
        self.layers=nn.Sequential(OrderedDict([
                ('conv1', nn.Sequential(nn.Conv2d(3, 96, kernel_size=7, stride=2),
                                        nn.ReLU(inplace=True),
                                        nn.LocalResponseNorm(2),
                                        nn.MaxPool2d(kernel_size=3, stride=2))),
                ('conv2', nn.Sequential(nn.Conv2d(96, 256, kernel_size=5, stride=2),
                            nn.ReLU(inplace=True),
                            nn.LocalResponseNorm(2),
                            nn.MaxPool2d(kernel_size=3, stride=2))),
                ('features', nn.Sequential(nn.Conv2d(256, 512, kernel_size=3, stride=1),
                                  nn.ReLU(inplace=True))),
                # ('fc4', nn.Sequential(nn.Linear(500, 512),
                #                   nn.ReLU(inplace=True))),
                # ('fc5', nn.Sequential(nn.Dropout(0.5),
                #                   nn.Linear(500, 512),
                #                   nn.ReLU(inplace=True)))
        ]))

    def forward(self, x):
        avg_result = self.avgpool(x)
        output = self.layers(x)
        return output

def save_model(model):
    torch.save(obj=model, f='B.pth')

if __name__ == '__main__':
    # 图片路径
    img_path = r'I:/2.jpg'
    # 给图片进行标准化操作
    img = Image.open(img_path).convert('RGB')
    transforms = torchvision.transforms.Compose([
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize([0.5, ], [0.5, ])])
    data = transforms(img).unsqueeze(0)
    # 用于加载Pycharm中封装好的网络框架
    # model = torchvision.models.vgg11_bn(pretrained=True)
    # 用于加载1中生成的.pth文件
    model = torch.load(f="B.pth")
    # 打印一下刚刚生成的.pth文件看看他的网络结构
    print(model)
    model.eval()
    #实例化
    net = MDNet()
    save_model(net)
    features=MDNet.forward(net,data)
    # model = torch.load(f="A.pth")
    features.retain_grad()
    # t = model.avgpool(features)
    # t = t.reshape(1, -1)
    # output = model.classifier(t)[0]
    # pred = torch.argmax(output).item()
    # pred_class = output[pred]
    #
    # pred_class.backward()
    grads = features.grad

    features = features[0]
    # avg_grads = torch.mean(grads[0], dim=(1, 2))
    # avg_grads = avg_grads.expand(features.shape[1], features.shape[2], features.shape[0]).permute(2, 0, 1)
    # features *= avg_grads

    heatmap = features.detach().cpu().numpy()
    heatmap = np.mean(heatmap, axis=0)

    heatmap = np.maximum(heatmap, 0)
    heatmap /= (np.max(heatmap) + 1e-8)

    img = cv2.imread(img_path)
    heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0]))
    heatmap = np.uint8(255 * heatmap)
    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
    superimposed_img = np.uint8(heatmap * 0.5 + img * 0.5)
    cv2.imshow('1', superimposed_img)
    cv2.waitKey(0)

原图如下:
用自己网络添加注意力机制后画出热力图

结果图如下:
用自己网络添加注意力机制后画出热力图


本博客大部分都来自于其他博客,我下面给出了他们的链接,以上代码全部由我测试过了,运行一点问题都没有,我的工作就是将他们汇总,然后加入一些自己的东西,以方便自己学习和大家学习,如果觉得有帮助请给我一个一键三连,有什么问题也可以在评论区讨论。


参考博客:保存和加载自己所搭建的网络模型
现有网络模型的使用与修改的学习 及ImageNet 数据集的下载
怎样得到神经网络注意力热图?(CAM方法+pytorch代码)文章来源地址https://www.toymoban.com/news/detail-464787.html

到了这里,关于用自己网络添加注意力机制后画出热力图的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • YOLOv5改进 | 一文汇总:如何在网络结构中添加注意力机制、C3、卷积、Neck、SPPF、检测头

    本篇文章的内容是在大家得到一个改进版本的C3一个新的注意力机制、或者一个新的卷积模块、或者是检测头的时候如何替换我们YOLOv5模型中的原有的模块,从而用你的模块去进行训练模型或者检测。因为最近开了一个专栏里面涉及到挺多改进的地方,不能每篇文章都去讲解

    2024年02月19日
    浏览(47)
  • yolov7添加注意力机制

    yolov7结构图 方法:直接在common里改,在相关的后面加上就行 1、目的:在三个输出地方添加注意力 yolov7.yaml文件,换成其他模块 注意力链接 2、models下建SE.py 3、common.py下,先找class Conv,再复制一份修改,把模块导进来 4、yolo.py文件,导入进来,添加 5、yolov7.yaml,修改模块名

    2024年02月09日
    浏览(43)
  • 改进YOLO系列:11.添加CrissCrossAttention注意力机制

    论文题目:CCNet: Criss-Cross Attention for Semantic Segmentation 论文链接:CCNet: Criss-Cross Attention for Semantic Segmentation

    2024年02月11日
    浏览(47)
  • Yolov5 中添加注意力机制 CBAM

    CBAM(Convolutional Block Attention Module)是一种注意力机制,它通过关注输入数据中的重要特征来增强卷积神经网络(CNN)的性能。CBAM的原理可以分为两个部分:空间注意力模块和通道注意力模块。 空间注意力模块:该模块关注输入特征图的每个空间位置的重要性。它首先对特征

    2024年02月10日
    浏览(42)
  • 改进YOLO系列:3.添加SOCA注意力机制

    暂未找到 ./models/common.py文件增加以下模块 在最后添加如下

    2024年02月12日
    浏览(49)
  • 改进YOLOv5:添加EMA注意力机制

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 本文主要介绍一种在YOLOv5-7.0中添加EMA注意力机制的方法。EMA注意力机制原论文地址,有关EMA注意力机制的解读可参考文章。 在yolov5的models文件中新建一个名为EMA.py文件,将下述代码复制到EMA.py文件中并

    2024年02月09日
    浏览(40)
  • YOLOv5改进系列(1)——添加SE注意力机制

    从这篇开始我们进入YOLOv5改进系列。那就先从最简单的添加注意力机制开始吧!( ̄︶ ̄)↗ 【YOLOv5改进系列】前期回顾: YOLOv5改进系列(0)——重要性能指标与训练结果评价及分析 目录

    2024年02月03日
    浏览(59)
  • YOLOv8改进算法之添加CA注意力机制

    CA(Coordinate Attention)注意力机制是一种用于加强深度学习模型对输入数据的空间结构理解的注意力机制。CA 注意力机制的核心思想是引入坐标信息,以便模型可以更好地理解不同位置之间的关系。如下图: 1. 输入特征 : CA 注意力机制的输入通常是一个特征图,它通常是卷积

    2024年02月08日
    浏览(47)
  • YOLOv5改进算法之添加CA注意力机制模块

    目录   1.CA注意力机制 2.YOLOv5添加注意力机制 送书活动   CA(Coordinate Attention)注意力机制是一种用于加强深度学习模型对输入数据的空间结构理解的注意力机制。CA 注意力机制的核心思想是引入坐标信息,以便模型可以更好地理解不同位置之间的关系。如下图: 1. 输入特征

    2024年02月09日
    浏览(39)
  • (超详细)4-YOLOV5改进-添加ShuffleAttention注意力机制

    1、在yolov5/models下面新建一个ShuffleAttention.py文件,在里面放入下面的代码 代码如下: 2、找到yolo.py文件,进行更改内容 在28行加一个 from models.ShuffleAttention import ShuffleAttention , 保存即可 3、找到自己想要更改的yaml文件,我选择的yolov5s.yaml文件(你可以根据自己需求进行选择),

    2024年01月23日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包