vgg16添加注意力模块做图像分类

已于 2023-09-13 15:49:51 修改
阅读量2.3k 收藏 57
点赞数 6
文章标签： 分类 深度学习 机器学习
于 2023-09-12 22:36:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cshsjdh/article/details/132841805
版权

1、传统VGG有以下几个版本：

我们拿出vgg16举例，其模型实现如下：

import torch
import torch.nn as nn

# 定义VGG16模型
class VGG16(nn.Module):
    def __init__(self, num_classes=1000):
        super(VGG16, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, num_classes)
        )

    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)
        return x

# 创建VGG16模型实例
model = VGG16()

# 打印模型结构
print(model)

受现代transformers思路启发，我打算在VGG16模型的特定层之间添加自注意力模块，以使模型能够自动学习图像中的关键区域。这样做需要对VGG16模型的结构进行修改，并添加自注意力模块的定义和连接，使用注意力机制替代VGG16模型中的卷积层。

import torch
import torch.nn as nn

# 定义自注意力层
class SelfAttention(nn.Module):
    def __init__(self, in_channels):
        super(SelfAttention, self).__init__()
        self.query_conv = nn.Conv2d(in_channels, in_channels // 8, kernel_size=1)
        self.key_conv = nn.Conv2d(in_channels, in_channels // 8, kernel_size=1)
        self.value_conv = nn.Conv2d(in_channels, in_channels, kernel_size=1)
        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        batch_size, channels, height, width = x.size()
        query = self.query_conv(x).view(batch_size, -1, height * width).permute(0, 2, 1)
        key = self.key_conv(x).view(batch_size, -1, height * width)
        energy = torch.bmm(query, key)
        attention = torch.softmax(energy, dim=-1)
        value = self.value_conv(x).view(batch_size, -1, height * width)
        out = torch.bmm(value, attention.permute(0, 2, 1))
        out = out.view(batch_size, channels, height, width)
        out = self.gamma * out + x
        return out

# 定义VGG16模型
class VGG16Attention(nn.Module):
    def __init__(self, num_classes=1000):
        super(VGG16Attention, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            SelfAttention(64),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            SelfAttention(128),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, num_classes)
        )

    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)
        return x

# 创建VGG16Attention模型实例
model = VGG16Attention()

# 打印模型结构
print(model)

它的结构图大概如下：

​
Input (224x224x3)

Convolutional Layer: 64 filters, 3x3 kernel, padding=1
ReLU Activation

Self-Attention Layer

Convolutional Layer: 64 filters, 3x3 kernel, padding=1
ReLU Activation

Max Pooling Layer: 2x2 pool size, stride=2

Convolutional Layer: 128 filters, 3x3 kernel, padding=1
ReLU Activation

Self-Attention Layer

Convolutional Layer: 128 filters, 3x3 kernel, padding=1
ReLU Activation

Max Pooling Layer: 2x2 pool size, stride=2

Convolutional Layer: 256 filters, 3x3 kernel, padding=1
ReLU Activation

Convolutional Layer: 256 filters, 3x3 kernel, padding=1
ReLU Activation

Convolutional Layer: 256 filters, 3x3 kernel, padding=1
ReLU Activation

Max Pooling Layer: 2x2 pool size, stride=2

Convolutional Layer: 512 filters, 3x3 kernel, padding=1
ReLU Activation

Convolutional Layer: 512 filters, 3x3 kernel, padding=1
ReLU Activation

Convolutional Layer: 512 filters, 3x3 kernel, padding=1
ReLU Activation

Max Pooling Layer: 2x2 pool size, stride=2

Convolutional Layer: 512 filters, 3x3 kernel, padding=1
ReLU Activation

Convolutional Layer: 512 filters, 3x3 kernel, padding=1
ReLU Activation

Convolutional Layer: 512 filters, 3x3 kernel, padding=1
ReLU Activation

Max Pooling Layer: 2x2 pool size, stride=2

Flatten

Fully Connected Layer: 4096 units
ReLU Activation

Dropout

Fully Connected Layer: 4096 units
ReLU Activation

Dropout

Fully Connected Layer: num_classes units

Output

​

接着我们用添加注意力机制的VGG16做图像分类训练：

​
import torch.optim as optim
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
from dataset.dataset import SeedlingData
from torch.autograd import Variable
from torchvision.models import vgg16

# 设置全局参数
modellr = 1e-4
BATCH_SIZE = 32
EPOCHS = 100
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 数据预处理

transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])

])
transform_test = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
dataset_train = SeedlingData('data/train', transforms=transform, train=True)
dataset_test = SeedlingData("data/train", transforms=transform_test, train=False)
# 读取数据
print(dataset_train.imgs)

# 导入数据
train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=BATCH_SIZE, shuffle=False)

# 实例化模型并且移动到GPU
criterion = nn.CrossEntropyLoss()
model_ft = VGG16Attention()
model_ft.classifier = classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 3),
        )
model_ft.to(DEVICE)
optimizer = optim.Adam(model_ft.parameters(), lr=modellr)


def adjust_learning_rate(optimizer, epoch):
    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
    modellrnew = modellr * (0.1 ** (epoch // 50))
    print("lr:", modellrnew)
    for param_group in optimizer.param_groups:
        param_group['lr'] = modellrnew


# 定义训练过程

def train(model, device, train_loader, optimizer, epoch):
    model.train()
    sum_loss = 0
    total_num = len(train_loader.dataset)
    print(total_num, len(train_loader))
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = Variable(data).to(device), Variable(target).to(device)
        output = model(data)
        loss = criterion(output, target)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        print_loss = loss.data.item()
        sum_loss += print_loss
        if (batch_idx + 1) % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
                       100. * (batch_idx + 1) / len(train_loader), loss.item()))
    ave_loss = sum_loss / len(train_loader)
    print('epoch:{},loss:{}'.format(epoch, ave_loss))


# 验证过程
def val(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    total_num = len(test_loader.dataset)
    print(total_num, len(test_loader))
    with torch.no_grad():
        for data, target in test_loader:
            data, target = Variable(data).to(device), Variable(target).to(device)
            output = model(data)
            loss = criterion(output, target)
            _, pred = torch.max(output.data, 1)
            correct += torch.sum(pred == target)
            print_loss = loss.data.item()
            test_loss += print_loss
        correct = correct.data.item()
        acc = correct / total_num
        avgloss = test_loss / len(test_loader)
        print('\nVal set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            avgloss, correct, len(test_loader.dataset), 100 * acc))


# 训练

for epoch in range(1, EPOCHS + 1):
    adjust_learning_rate(optimizer, epoch)
    train(model_ft, DEVICE, train_loader, optimizer, epoch)
    val(model_ft, DEVICE, test_loader)
torch.save(model_ft, 'model.pth')

​

还可以在VGG16模型中添加Triplet Attention模块。Triplet Attention由3个平行的Branch组成，其中两个负责捕获通道C和空间H或W之间的跨维交互。最后一个Branch类似于CBAM，用于构建Spatial Attention。最终3个Branch的输出使用平均进行聚合。这是通过使用三分支结构捕捉交叉维度交互来计算注意权重的新方法。对于输入张量，Triplet Attention通过旋转操作和残差变换建立维度间依赖关系，并以可忽略的计算开销对通道间和空间信息进行编码。（如图）

具体实现代码：

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

class TripletAttention(nn.Module):
    def __init__(self, in_channels):
        super(TripletAttention, self).__init__()
        self.conv_query = nn.Conv2d(in_channels, in_channels // 8, kernel_size=1)
        self.conv_key = nn.Conv2d(in_channels, in_channels // 8, kernel_size=1)
        self.conv_value = nn.Conv2d(in_channels, in_channels, kernel_size=1)

    def forward(self, x):
        query = self.conv_query(x)
        key = self.conv_key(x)
        value = self.conv_value(x)

        query = query.view(query.size(0), -1, query.size(2) * query.size(3))
        key = key.view(key.size(0), -1, key.size(2) * key.size(3))
        value = value.view(value.size(0), -1, value.size(2) * value.size(3))

        attention_map = torch.bmm(query.permute(0, 2, 1), key)
        attention_map = F.softmax(attention_map, dim=-1)

        attended_features = torch.bmm(value, attention_map.permute(0, 2, 1))
        attended_features = attended_features.view(x.size())

        return attended_features

Triplet Attention模块可以与VGG模型结合使用。下面是如何将Triplet Attention模块添加到VGG模型的某些层中：

import torch
import torch.nn as nn
import torchvision.models as models

class VGGWithTripletAttention(nn.Module):
    def __init__(self, attention_layers):
        super(VGGWithTripletAttention, self).__init__()
        self.vgg = models.vgg16(pretrained=True).features
        self.attention_layers = attention_layers

        for layer_idx in attention_layers:
            setattr(self, f"attention_{layer_idx}", TripletAttention(256))

    def forward(self, x):
        features = []
        for idx, module in enumerate(self.vgg):
            x = module(x)
            if idx in self.attention_layers:
                attention_module = getattr(self, f"attention_{idx}")
                x = attention_module(x)
                features.append(x)
        
        return features

# Example usage
vgg_model = VGGWithTripletAttention(attention_layers=[10, 17, 24])
input_tensor = torch.randn((1, 3, 224, 224))
output_features = vgg_model(input_tensor)

在构造函数中，我们首先加载了预训练的VGG模型，并指定了我们要在哪些层上添加Triplet Attention模块（在这里是第10、17和24层）。

以上为全部内容！

oliveray
关注
Attention(注意力机制代码)
07-16
Attention.zip文件中总结了几种关于注意力机制的代码，有keras和tensorflow，还有PyTorch框架的
高效、简单、易实现 | 多任务+注意力机制的学习（文末有福利）
gzq0723的博客
03-03 1225
科技改变生活“计算机视觉战队”在今天给大家带来干货的之前，先说一些最近我发现的一些事。（纯自己的见解）最近，CVPR2019让圈内有一次火热起来，出现了一大波新技术新思想...
5.vgg16网络模块的实现
weixin_71719718的博客
10-14 44
【代码】5.vgg16网络模块的实现。
基于pytorch在VGG9中加入CBAM注意力机制
wj0807的博客
07-17 1089
【代码】基于pytorch在VGG9中加入CBAM注意力机制。
图像领域attention加入谷歌开源vgg19（手把手教程）
m0_46686292的博客
06-02 4621
图像领域attention加入谷歌开源vgg19！！vgg16和vgg19有什么区别为什么要加入attention？并且基本原理attention加入vgg结束语 vgg16和vgg19有什么区别 转送门:https://www.jianshu.com/p/e0845ecaf7f7. 博主已经写的是非常明白了但是有一点需要重点的标注 vgg16：13个卷积层加上3个全链接层 vgg19：16个卷积层加上3个全链接层 为什么要加入attention？并且基本原理 Attention模型的基本表述可以这样理解成
大话注意力机制（Attention Mechanism）
chenjie7140的博客
06-14 810
当我们人类在看东西时，一般会将注意力集中注视着某个地方，而不会关注全部所有信息。例如当我们一看到下面这张猫的图片时，主要会将目光停留在猫的脸部，以及留意猫的躯干，而后面的草地则会被当成背景忽略掉，也就是说我们在每一处空间位置上的注意力分布是不一样的。 通过这种方式，人类在需要重点关注的...
注意力机制
duanmuji的博客
04-05 1708
Attention机制是什么？ 说到底attention实际上是一个加权求和，用于计算每个与attention关注的对象（其实是一个向量）的相关程度。 step1 设计一个打分函数fif ifi，针对每个hihihi，计算出一个scoresisisi 。而sisisi打分的依据，就是hihihi与attention所关注的对象(其实就是一个向量)的相关程度，越相关，所得sisisi越大。 step...
注意力机制论文研读
小膜仙的博客
04-12 4505
参考： 计算机视觉中的注意力机制 然后找了个博客，里面有论文引用，这篇博客真不错，把其论文好好看看 https://blog.csdn.net/Wayne2019/article/details/78488142 基于注意力机制的细腻度图像分类，里面也有篇论文，值得一看。 另外，我想寻找2018年甚至2019年的这领域的文章。 突然发现一片硕士论文讲述的是注意力机制的，基于注意力机制的图像分类深度...
vgg19加入注意力机制怎么做图像分类
05-15
1. 在VGG19的卷积层之后添加一个自注意力模块。 2. 在自注意力模块中，首先计算特征图中每个像素点的权重，使用Softmax函数对这些权重进行归一化。 3. 然后使用这些权重来对特征图进行加权平均，以得到加强后的...
基于视觉注意力机制的细粒度图像分类方法 代码仓库.zip
02-06
在这个任务中，“基于视觉注意力机制的细粒度图像分类方法”是一种重要的技术，它利用了自注意力机制来提升模型对关键特征的识别能力。 自注意力（Self-Attention）是深度学习中的一个核心概念，特别是在自然语言...
windows+TensorFlow/keras+vgg16训练自己的数据集-附件资源
03-02
windows+TensorFlow/keras+vgg16训练自己的数据集-附件资源
基于VGG16深度学习网络目标识别matlab仿真,输出识别混淆矩阵+代码仿真操作视频
07-05
1.领域：matlab，VGG16深度学习网络 2.内容：基于VGG16深度学习网络目标识别matlab仿真,输出识别混淆矩阵+代码仿真操作视频 3.用处：用于基于VGG16深度学习网络目标识别算法编程学习 4.指向人群：本硕博等教研学习使用 5.运行注意事项： 使用matlab2021a或者更高版本测试，运行里面的Runme_.m文件，不要直接运行子函数文件。运行时注意matlab左侧的当前文件夹窗口必须是当前工程所在路径。 具体可观看提供的操作录像视频跟着操作。
利用vgg16进行二分类-vgg16.zip
04-05
利用vgg16进行的猫狗图像的分类，由于其在模型比普通的cnn的层更加复杂，所以分类效果较优。同时可根据结果添加dropout层避免出现的过拟合现象。训练和测试图像较大没有放上来，可私聊/评论后发送。
vgg图像分类添加注意力机制
10-13
如果要在VGG模型中添加注意力机制，可以考虑在卷积层之间添加SE模块或CBAM模块。 SE模块全称为Squeeze-and-Excitation模块，其主要思想是在卷积层之间添加一个全局池化层和两个全连接层，其中全局池化层用于对每个...
中文核心：多维度注意力机制下网络图像识别分类-完整详细代码
最新发布
06-26 207
中文核心：多维度注意力机制下网络图像识别分类-完整详细代码
vgg16 加注意力机制
07-28
这可以通过在VGG16的最后一层卷积层之后添加一个注意力模块来实现。 另一种方法是通道注意力机制，它能够自适应地调整不同通道的权重，以提高模型对于不同特征的关注度。这可以通过在VGG16的每个卷积层后添加一个...
[ 注意力机制 ] 经典网络模型2——CBAM 详解与复现
热门推荐
A_John 的博客
04-19 4万+
[ 注意力机制 ] 经典网络模型2——CBAM 详解与复现 1、Convolutional Block Attention Module 2、CBAM 详解 Channel Attention Module Spatial Attention Module 3、CBAM 复现 简称 ``CBAM``，2018年 提出的一种新的 *卷积注意力模块* ； 对前馈卷积神经网络 是一个 简单而有效的 注意力模块 ； 因为它的轻量级和通用性，可以无缝集成到任何CNN网络当中 ；...
【实验记录】Fashion-Mnist分类实验记录
qq_40690815的博客
11-14 1000
使用深度学习解决Fashion-Mnist分类问题 • Problem Description https://github.com/zalandoresearch/fashion-mnist • Solution Design 先使用全连接神经网络 • Data Preparation matlab打开数据集：https://blog.csdn.net/tracer9/article/de...
用matlab搭建vgg,vgg-16网络结构 matlab程序
weixin_39957934的博客
03-17 1424
lr = [.1 2] ;net.layers = {} ;% cbr1net.layers{end+1} = struct('type', 'conv', ...'weights', {{0.01*randn(3,3,3,64, 'single'), zeros(1, 64, 'single')}}, ...'learningRate', lr, ...'stride', 1, ...'pad'...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值