pytorch学习笔记（六）——pytorch中搭建神经网络

2023年7月12日下午8:25 • 人工智能 • 阅读 77

一、神经网络基本骨架搭建nn.module
*
nn.Module的使用
二、神经网络中一些神经结构的使用
*
1. Convolution Layers 卷积层
–
2. Pooling layers池化层
–
3. Non-linear Activations非线性激活
–
- 以ReLU为例
4. Linear Layer线性层
三、搭建一个简单的分类的神经网络
*
以CIFAR10数据集为例
四、torch.nn中的 Loss Functions损失函数
*
1. Loss作用
2. 几个Loss的简单用法
3. 在自写的神经网络中使用Loss Function
五、优化器 torch.optim
*
以随机梯度下降SGD优化器为例
六、神经网络完整的模型训练和测试套路

一、神经网络基本骨架搭建nn.module

神经网络(Nueral Networks) 是由对数据进行操作的一些层(layer) 或模块(module) 所组成，而PyTorch 中的每个模块都是 nn.Module 的子类，在调用或自定义时均需继承 nn.Module 类。
同时 torch.nn 包为我们提供了构建神经网络所需的各种模块，当然一个神经网络本身也是一个由其他模块/层组成的模块，这种嵌套结构就允许我们构建更为复杂的网络架构。
关于神经网络的工具主要在torch.nn里面，nn即neural network
torch.nn的官网API
在开始搭建神经网络之前先了解下 torch.nn 包，它包含了用于搭建神经网络的所有基础模块，其中有些是经常使用的，如卷积层、池化层、激活函数、损失函数等等

; nn.Module的使用

import torch
from torch import nn

class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()

    def forward(self, input_num):
        output_num = input_num + 1
        return output_num

neural = Model()
x = torch.tensor(1.0)

output = neural(x)
print(output)

二、神经网络中一些神经结构的使用

1. Convolution Layers 卷积层

（1）卷积操作示例

; （2）用代码验证上述卷积操作的正确性（使用F.conv2d）

import torch
import torch.nn.functional as F

input_matrix = torch.tensor([[1, 2, 0, 3, 1],
                             [0, 1, 2, 3, 1],
                             [1, 2, 1, 0, 0],
                             [5, 2, 3, 1, 1],
                             [2, 1, 0, 1, 1]])

kernel = torch.tensor([[1, 2, 1],
                       [0, 1, 0],
                       [2, 1, 0]])

input_matrix = torch.reshape(input_matrix, (1, 1, 5, 5))
kernel = torch.reshape(kernel, (1, 1, 3, 3))

print(input_matrix.shape)

output_matrix = F.conv2d(input_matrix, kernel, stride=1)
print(output_matrix)

output2 = F.conv2d(input_matrix, kernel, stride=2)
print(output2)

output3 = F.conv2d(input_matrix, kernel, stride=1, padding=1)
print(output3)

（3）卷积层nn.Conv2d的使用

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("../datasets", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=64)

class MyNeural(nn.Module):
    def __init__(self):
        super(MyNeural, self).__init__()

        self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, x):

        x = self.conv1(x)
        return x

my_neural = MyNeural()

writer = SummaryWriter("../logs")
step = 0

for data in dataloader:
    imgs, targets = data

    output = my_neural(imgs)

    print(imgs.shape)

    print(output.shape)

    writer.add_images("input", imgs, step)

    output = torch.reshape(output, (-1, 3, 30, 30))
    writer.add_images("output", output, step)
    step = step + 1

（4）理解卷积层nn.Conv2d的各个参数

in_channels：输入的通道数目【必选】
out_channels：输出的通道数目【必选】
kernel_size：卷积核的大小，类型为int 或者元组，当卷积是方形的时候，只需要一个整数边长即可，卷积不是方形，要输入一个元组表示高和宽。【必选】
stride：卷积每次滑动的步长为多少，默认是 1 【可选】
padding：设置在所有边界增加值为 0 的边距的大小（也就是在feature map 外围增加几圈 0 ），例如当 padding =1 的时候，如果原来大小为 3 × 3 ，那么之后的大小为 5 × 5 。即在外围加了一圈 0 。【可选】
dilation：指卷积核的元素之间是否有空是否紧挨着。默认dilation=1，当dilation>1时为空洞卷积

; （5） torch.nn.conv2d和torch.nn.functional.conv2d的区别

转载自那记忆微凉的一篇文章
https://blog.csdn.net/BigData_Mining/article/details/103746548

2. Pooling layers池化层

（1）最大池化层的理解

同卷积层⼀样，池化层每次对输⼊数据的⼀个固定形状窗⼝（⼜称池化窗⼝）中的元素计算输出。不同于卷积层里计算输⼊和核的互相关性，池化层直接计算池化窗口内元素的最大值或者平均值。该运算也分别叫做最大池化或平均池化。
pytorch学习笔记（六）——pytorch中搭建神经网络

; （2）最大池化层作用

为了在保留输入的特征同时把数据量减小，对于整个网络来说进行计算的参数就减少了，为了训练的更快（直观感受1080p池化之后720p，也能满足大多数需要，但是文件尺寸缩小了），马赛克行为
简要理解八个字： 压缩数据保留特征
如图，经过池化前后的图片对比

（3）用pytorch搭建一个最大池化层

import torch
import torchvision.datasets
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader

from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("../datasets", train=False, transform=torchvision.transforms.ToTensor())

dataloader = DataLoader(dataset, batch_size=64)

class MyNeural(nn.Module):
    def __init__(self):
        super(MyNeural, self).__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)

    def forward(self, input):
        output = self.maxpool1(input)
        return output

my_neural = MyNeural()

writer = SummaryWriter("../logs")
step = 0
for data in dataloader:
    imgs, targets = data
    output = my_neural(imgs)
    writer.add_images("input", imgs, step)

    writer.add_images("output", output, step)
    step = step + 1
writer.close()

3. Non-linear Activations非线性激活

以ReLU为例

import torch

from torch import nn
from torch.nn import ReLU

input_matrix = torch.tensor([[1, -0.5],
                             [-1, 3]])

input_matrix = torch.reshape(input_matrix, (-1, 1, 2, 2))

class MyNeural(nn.Module):
    def __init__(self):
        super(MyNeural, self).__init__()

        self.relu1 = ReLU()

    def forward(self, input):
        output = self.relu1(input)
        return output

my_neural = MyNeural()

output = my_neural(input_matrix)
print(output)

4. Linear Layer线性层

import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10("../datasets", train=False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)

class MyNeural(nn.Module):
    def __init__(self):
        super(MyNeural, self).__init__()

        self.linear1 = Linear(196608, 10)

    def forward(self, input):
        output = self.linear1(input)
        return output

my_neural = MyNeural()

for data in dataloader:
    imgs, targets = data

    output = torch.flatten(imgs)
    output = my_neural(output)
    print(imgs.shape)
    print(output.shape)

三、搭建一个简单的分类的神经网络

以CIFAR10数据集为例

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter

class MyNeural(nn.Module):
    def __init__(self):
        super(MyNeural, self).__init__()

        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x

my_neural = MyNeural()
print(my_neural)

input = torch.ones((64, 3, 32, 32))
output = my_neural(input)
print(output.shape)

writer = SummaryWriter("../logs")

writer.add_graph(my_neural, input)
writer.close()

四、torch.nn中的 Loss Functions损失函数

1. Loss作用

定义预测值和真实值之间的差距
并且指导我们提升预测值，为更新预测值提供依据（反向传播）

2. 几个Loss的简单用法

L1Loss、MSELoss、CrossEntropyLoss

import torch
from torch.nn import L1Loss, MSELoss, CrossEntropyLoss

outputs = torch.tensor([1, 2, 3], dtype=torch.float32)
targets = torch.tensor([1, 2, 5], dtype=torch.float32)

outputs = torch.reshape(outputs, (1, 1, 1, 3))
targets = torch.reshape(targets, (1, 1, 1, 3))

loss = L1Loss(reduction='sum')
result_l1 = loss(outputs, targets)

loss_mse = MSELoss()
result_mse = loss_mse(outputs, targets)

print(result_l1)

print(result_mse)

outputs = torch.tensor([0.1, 0.2, 0.3])
targets = torch.tensor([1])
outputs = torch.reshape(outputs, (1, 3))
loss_cross = CrossEntropyLoss()
result_cross = loss_cross(outputs, targets)
print(result_cross)

3. 在自写的神经网络中使用Loss Function

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10("../datasets", train=False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=1)

class MyNeural(nn.Module):
    def __init__(self):
        super(MyNeural, self).__init__()

        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x

my_neural = MyNeural()

loss = nn.CrossEntropyLoss()

for data in dataloader:
    imgs, targets = data
    outputs = my_neural(imgs)
    result_loss = loss(outputs, targets)

    print(result_loss)

五、优化器 torch.optim

torch.optim官网

以随机梯度下降SGD优化器为例

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10("../datasets", train=False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=1)

class MyNeural(nn.Module):
    def __init__(self):
        super(MyNeural, self).__init__()

        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x

my_neural = MyNeural()

loss = nn.CrossEntropyLoss()

optim = torch.optim.SGD(my_neural.parameters(), lr=0.01)

for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs = my_neural(imgs)
        result_loss = loss(outputs, targets)

        optim.zero_grad()

        result_loss.backward()

        optim.step()
        running_loss = running_loss + result_loss

    print(running_loss)

六、神经网络完整的模型训练和测试套路

神经网络完整的模型训练和模型测试套路（以CIFAR10数据集为例）

Original: https://blog.csdn.net/NA_imu/article/details/124455328
Author: NA娜儿
Title: pytorch学习笔记（六）——pytorch中搭建神经网络

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/688343/

转载文章受原作者版权保护。转载请注明原作者出处！

人工智能

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

【自动驾驶轨迹规划之hybrid A*算法】

本文参考论文：https://ai.stanford.edu/~ddolgov/papers/dolgov_gpp_stair08.pdf 这篇文章是基于经典A*算法与reeds-…

人工智能 2023年7月27日
0078
labelImg 使用以及安装教程—图像标注工具

目录 labelImg 使用教程 LabelImg简介 LabelImg用法步骤 (PascalVOC) 步骤 (YOLO) 创建预定义的类注释可视化热键验证图片设置困难…

人工智能 2023年7月25日
0067
如何用人工智能自动玩游戏

如何用人工智能自动玩游戏一、前言让AI玩游戏的思想早在上世纪就已经有了，那个时候更偏向棋类游戏。像是五子棋、象棋等。在上世纪”深蓝”就击败了国际象棋冠军…

人工智能 2023年7月28日
00110
联邦学习代码解读，超详细

参考文献：[1]Brendan McMahan, H., Moore, E., Ramage, D., Hampson, S., and Agüera y Arcas, B., &…

人工智能 2023年6月13日
0072
deepspeech 笔记

为了回馈广大粉丝和订阅者，我在之前的笔记中看到了一些可能对你有用的信息。我希望它能对你有所帮助。 [En] In order to give back to the majorit…

人工智能 2023年5月27日
0049
删了很多还提示内存不足？Mac内存空间你要这样清理

忍痛删应用、删文档、删照片视频等等一系列操作都是众多Mac用户清理内存空间的方法之一，悲催的是一顿”猛如虎的操作”下，释放出来的内存空间却少的可怜，原因很简…

人工智能 2023年6月29日
00108
粒子群算法（PSO）简介及Python实现

一、概述粒子群算法，也称粒子群优化算法或鸟群觅食算法(Particle Swarm Optimization) ，缩写为PSO.粒子群优化算法是一种进化计算技术(evolutio…

人工智能 2023年7月30日
0057
多元线性回归模型

目录：一、引言二、理想场景的预设三、多元线性回归模型四、鸢尾花数据集一、引言：多元线性回归是一元线性回归的多维运用。在一元线性回归中，我们用自变量系数表示对自变量与因变…

人工智能 2023年6月15日
0089
【神经网络】LSTM理论介绍

Recurrent Neural Networks RNN可以看做是同一神经网络的多次复制，每个神经网络模块会把消息传递给下一个。LSTM是一种特别的RNN。 ; 长期依赖问题（L…

人工智能 2023年7月13日
0076
【计算机视觉实验一图像的基本操作】

计算机视觉实验一图像的基本操作一、实验目的二、实验内容及要求三、实验程序 * 实验内容1：图像的打开、保存、显示实验内容2：图像上添加文字实验内容3：图像的减法运算…

人工智能 2023年6月18日
0056
图神经网络的可解释性方法介绍和GNNExplainer解释预测的代码示例

深度学习模型的可解释性为其预测提供了人类可以理解的推理。如果不解释预测背后的原因，深度学习算法就像黑匣子，对于一些场景说是无法被信任的。不提供预测的原因也会阻止深度学习算法在涉及跨…

人工智能 2023年7月13日
0073
如何用度量数据驱动代码评审的改善

本文正文内容共计8000字，建议阅读时间：16-18分钟。阅读本文你将收获： 1、为什么要做代码评审的背景介绍； 2、代码评审数据分析设计：过程+指标体系+分析方法和模型； 3、…

人工智能 2023年7月15日
0076
GAN的训练技巧：炼丹师养成计划 ——生成式对抗网络训练、调参和改进

目录一、模式崩溃：生成器产生的结果模式较为单一 * 1.1、改进训练方法 1.2、改进目标函数 1.3、改进网络架构二、训练缓慢：发生了梯度消失三、不收敛：训练不稳定，收敛…

人工智能 2023年6月24日
00146
【语音识别】详解kaldi的数据和模型文件——librispeech

在基于GMM-HMM的传统语音识别里，比音素（phone）更小的单位是状态（state）。一般每个音素由三个状态组成，特殊的是静音（SIL）由五个状态组成。这里所说的状态就是指HM…

人工智能 2023年5月23日
00120
MacOS下利用CMake编译安装OpenCV（带Contrib包）

–wongkai@hnu.edu.cn 所需环境： CMake 3.9 及以上 Git Python 2.7 及以上 NumPy 1.5 及以上若没有这些环境，请到文…

人工智能 2023年7月20日
0059
朴素贝叶斯分类

机器学习的经典算法：朴素贝叶斯（naive byes）分类贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。而朴素贝叶斯分类是贝叶斯分类中最简单，…

人工智能 2023年6月30日
0074

2024 年 5 月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31