(八)PyTorch深度学习:卷积神经网络(基础)---将(七)全连接神经网络改成卷积神经网络

本文介绍了将全连接神经网络替换为卷积神经网络如何提高图像识别的准确性。通过卷积层保留了图像的空间信息,避免了全连接层的信息丢失。示例展示了卷积层、最大值池化层的实现,并提供了卷积神经网络模型在MNIST数据集上的应用,包括模型结构、训练和测试过程。
摘要由CSDN通过智能技术生成

将(七)全连接神经网络改成卷积神经网络,正确率得到了提升。

全连接层神经网络相当于将一张2维图拆分成一行的一维形式,但却丧失了空间位置信息(例如:原来2维相邻的位置,转变成全链接时可能就分隔得很远)。而卷积神经网络却避免了这一情况。

1、假设一张图的维度是3x5x5,对应的卷积核是3x3x3,卷积后得到1x3x3:

在这里插入图片描述

2、对于其 n 通道的 5 x 5 图片所对应的 n 通道 3 x 3 卷积核,最后所得的卷积为:

在这里插入图片描述

3、对于 n 通道 width(in) x height(in) 图片,所对应 m 个 n 通道 width(in) x height(in) 卷积核,得到4维卷积【m 层、n通道、width(in) x height(in)】,然后将对全部卷积拼起来:

在这里插入图片描述

4、卷积层:

import torch
in_channels, out_channels = 5, 10    # s
width, height = 100, 100
kernel_size = 3
batch_size = 1

input = torch.randn(batch_size,
                    in_channels,
                    width,
                    height)
# 卷积层
conv_layer = torch.nn.Conv2d(in_channels,    # 输入通道数量
                             out_channels,   # 输出通道数量
                             kernel_size=kernel_size)

output = conv_layer(input)

print(input.shape)    # 输入是5个通道,100x100
print(output.shape)   # 输出是10个通道,98x98
print(conv_layer.weight.shape)   # 卷积层权重形状,10个输入通道、5个输出通道、3x3卷积核大小

运行结果:

在这里插入图片描述

5、最大值池化:

在这里插入图片描述

而最大值池化即是下采样,引用博主:不堪沉沦的解析

在这里插入图片描述

Max Pooling层的代码:


import torch

# 输入数据
input = [3,4,6,5,
         2,4,6,8,
         1,6,7,8,
         3,7,5,4]
# 将输入数据转换成 1 层、1通道的 5 x 5 矩阵数据
input = torch.Tensor(input).view(1, 1, 4, 4)
# 最大值池化
maxpooling_layer = torch.nn.MaxPool2d(kernel_size=2)

output = maxpooling_layer(input)
print(output)

运行结果:

在这里插入图片描述

6、卷积代码:(将(七)博文中的程序“全连接层”转换成“卷积层”)


#############将上一个程序(04_09_Number_Detect.py)全连接层转换成卷积层###################
################################卷积模型##############################################
# import torch
# in_channels, out_channels = 5, 10    # s
# width, height = 100, 100
# kernel_size = 3
# batch_size = 1
#
# input = torch.randn(batch_size,
#                     in_channels,
#                     width,
#                     height)
# # 卷积层
# conv_layer = torch.nn.Conv2d(in_channels,    # 输入通道数量
#                              out_channels,   # 输出通道数量
#                              kernel_size=kernel_size)
#
# output = conv_layer(input)
#
# print(input.shape)    # 输入是5个通道,100x100
# print(output.shape)   # 输出是10个通道,98x98
# print(conv_layer.weight.shape)   # 卷积层权重形状,10个输入通道、5个输出通道、3x3卷积核大小

###############################卷积##################################################

# import torch
#
# # 输入数据
# input = [3,4,6,5,7,
#          2,4,6,8,2,
#          1,6,7,8,4,
#          9,7,4,6,2,
#          3,7,5,4,1]
# # 将输入数据转换成 1 层、1通道的 5 x 5 矩阵数据
# input = torch.Tensor(input).view(1, 1, 5, 5)
# # 卷积层中参数:1层卷积层、1通道、卷积核大小3、滑动2格、没有加偏置
# conv_layer = torch.nn.Conv2d(1, 1, kernel_size=3, stride=2, padding=1, bias=False)
# # 将数据...构造一个输出通道数(1)、输入通道数(1)、3x3的卷积核,
# kernel = torch.Tensor([1,2,3,4,5,6,7,8,9]).view(1, 1, 3, 3)
# # 把张量 kernel的.data 赋予给卷积层的权重的 .data
# conv_layer.weight.data = kernel.data
#
# output = conv_layer(input)
# print(output)


############################池化处理#####################################################

# import torch
#
# # 输入数据
# input = [3,4,6,5,
#          2,4,6,8,
#          1,6,7,8,
#          3,7,5,4]
# # 将输入数据转换成 1 层、1通道的 5 x 5 矩阵数据
# input = torch.Tensor(input).view(1, 1, 4, 4)
# # 最大值池化
# maxpooling_layer = torch.nn.MaxPool2d(kernel_size=2)
#
# output = maxpooling_layer(input)
# print(output)


#############将上一个程序(04_09_Number_Detect.py)全连接层转换成卷积层###################
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),      # 将PIL格式图像转换成Tensor矩阵向量(维度28x28转换成1x28x28,1:为RGB通道)【 [0...255]--->[0,1] 】
    transforms.Normalize((0.1307, ), (0.3081, ))   # 均一化处理(均值、标准差)
])
# 训练集数据
train_dataset = datasets.MNIST(root='../dataset/mnist/',
                               train=True,
                               download=True,
                               transform=transform)
# 加载训练集数据
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
# 测试集数据集
test_dataset = datasets.MNIST(root='../dataset/mnist/',
                              train=False,
                              download=True,
                              transform=transform)
# 加载测试集数据集
test_loader = DataLoader(test_dataset,
                         shuffle=False,
                         batch_size=batch_size)

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)   # 卷积层:1-->10
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)  # 卷积层:10-->20
        self.pooling = torch.nn.MaxPool2d(2)                 # 池化层层:1-->10
        self.fc = torch.nn.Linear(320, 10)                   # 全连接层,320--10

    def forward(self, x):
        batch_size = x.size(0)
        x = F.relu(self.pooling(self.conv1(x)))   # 先做卷积-->然后池化-->优化器
        x = F.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1)      # .view:将数据变成全连接网络(-1:自动检测矩阵有有多少行,列指定为784)
        x = self.fc(x)

        return x

# 想使用模型,就实例化即可,可以直接调用
model = Net()

# 将模型放到GPU上运行,需要加如下两行代码(训练集、测试集中的输入值、实际值也需要加载到GPU上)
# 若有多个显卡,同时想跑多个模型,则可以把不同的模型分配到不同的GPU来跑
# device = torch.device("cude:0" if torch.cuda.is_available() else "cpu")
# model.to(device)

###################3 构建损失函数、优化器###############################
criterion = torch.nn.CrossEntropyLoss()          # 交叉熵损失
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)    # 参数优化

#####################4 循环训练 #########################
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        # 准备数据(input:输入,target:实际值)
        inputs, target = data
        # 将输入、实际值加载到GPU
        # inputs, target = inputs.to(device), target.to(device)
        # 梯度清0
        optimizer.zero_grad()
        # 前向传播
        outputs = model(inputs)
        # 交叉熵损失函数计算
        loss = criterion(outputs, target)
        # 反向传播
        loss.backward()
        # 参数优化
        optimizer.step()
        # 累计loss
        running_loss += loss.item()
        # 数据集一共有batch_idx个数据,每隔300个打印一次平均损失函数值
        if batch_idx % 300 ==299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

def test():
    correct = 0
    total = 0
    with torch.no_grad():   # 这个语句之后的部分代码就不会计算梯度(测试不需要梯度)
        for data in test_loader:
            images, labels = data   # 得到样品数据images(矩阵形式),以及样品数据的标签(矩阵形式)
            # 将输入、实际值加载到GPU中
            # inputs, target = inputs.to(device), target.to(device)
            outputs = model(images)   # 根据样品数据做预测,得到一个矩阵
            _, predicted = torch.max(outputs.data, dim=1)  # _:每一行的最大值是多少;predicted:每一行最大值的下标;(dim=0:以列方向找,dim=1:以行方向找)
            total += labels.size(0)  # 获取一共的lables标签数量
            correct += (predicted == labels).sum().item()
        print('Accuracy on test set: %d %%' % (100 * correct / total))

if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()

运行结果:

在这里插入图片描述

内容主要参考了b站up主:刘二大人

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值