我在B站读大学-【小土堆】PyTorch深度学习快速入门教程学习笔记(一)

介绍

Pytorch入门选手的学习笔记 (序号与视频序号完全对应), 本文尽可能的在详细记录了自己的学习内容, 包括但不限于(加了详细注释的代码, 截图并补充了说明的插图, UP讲课时的关键内容),因为自己学习过程中看其他博主的笔记, 有所收获,.
希望我的笔记也可以帮助一起学习的小伙伴, 加油哇~

视频链接

PyTorch深度学习快速入门教程【小土堆】: 点这里

参考的其他博主的笔记链接 ,非常感谢!!

笔记1
笔记2
再次感谢两位博主分享, 在学习过程中有效帮助我节约了时间并加深了理解~

15.DataLoader

点进dataset源文件查找getitem（）可以查看该数据集返回数据类型（如CIFAR，返回img和target）

官网原文:
torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None, generator=None, *, prefetch_factor=2, persistent_workers=False)

• dataset (Dataset) – dataset from which to load the data.

• batch_size (int, optional) – how many samples per batch to load (default: 1).一次取几个

• shuffle (bool, optional) – set to True to have the data reshuffled at every epoch (default: False).是否打乱顺序

• drop_last (bool, optional) – set to True to drop the last incomplete batch, if the dataset size is not divisible by the batch size. If False and the size of dataset is not divisible by the batch size, then the last batch will be smaller. (default: False)是否丢弃剩余

16.神经网络的基本骨架-nn.Module

Module

# 官网教程
"""
Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing to nest them in a tree structure. You can assign the submodules as regular attributes:
所有神经网络模块的基类。

您的模型还应子类化此类。

模块还可以包含其他模块，允许将它们嵌套在树结构中。您可以将子模块指定为常规属性：
"""
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module): 
    def __init__(self):# 初始化
        super().__init__() # 必须的 首先对模板/父类进行初始化
        # 下方两步为根据自己的需求写的
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x): # 神经网络中的forward函数(前向传播) 运算步骤,x是自定义的
        
       # 尽管需要在此函数中定义正向传递的配方，但之后应该调用 Module 实例而不是这样，因为前者负责运行已注册的钩子，而后者则静默地忽略它们。
    
        # 卷积-非线性-卷积-非线性-再输出
        x = F.relu(self.conv1(x))# conv--卷积  relu--激活函数非线性处理
        return F.relu(self.conv2(x))

from torch import nn
import torch
class haha(nn.Module):
    def __init__(self):
        super(haha,self).__init__()#调用父类初始化函数
        #自定义
 
    def forward(self,input):#forward一定不能拼错！否则会报错
        output=input+1#自定义
        return output#自定义
 
c=haha()#实例化
x=torch.tensor(1.0)
output=c(x)
print(output)
 
output
#tensor(2.)

17.卷积操作

Stride 步长 可以控制卷积核横向或者纵向的路径 (sH,sW) 如果只输入一位默认横向

kernel_size 卷积核的大小 后向传播就是改变里面的权重

padding 填充 padding=1时 给输入图像周围拓宽1像素空白部分补0(有padding可以避免边缘的数据只计算一次)

18.神经网络-卷积层

与卷积不用，池化是选取核中最大数作为output

torch.nn.Conv2d(==in_channels,out_ channels,kernel_size,stride=1,padding=0,==dilation=1,groups=1,bias=True,padding_mod=‘zero’)

一般只设置高亮部分的5个参数

• kernel_size – the size of the window to take a max over 卷积核的大小,如果该参数是一个整数s，那么卷积核的大小
• return_indices – if True, will return the max indices along with the outputs. Useful for torch.nn.MaxUnpool2d later

ceil_mode – when True, will use ceil instead of floor to compute the output shape（True则保留多出来的input，False丢弃。）

conv2d常用参数：

• in_channels (int) – 输入通道数，一般彩色图像就是RGB图像就是三通道.

• out_channels (int) – 输出通道数，也就是卷积核的个数，输入通道不为1的情况.

  • 示例(out_channels = 2) 两个叠加作为一个输出
    

• kernel_size (int or tuple) –值一般为个数或者元组 卷积核大小，比如3就代表3×3的卷积核.

• stride (int or tuple, optional) – 步长，卷积完成一次计算后，卷积核移动多少步.

• padding (int, tuple or str, optional) – 是否需要在图像边缘进行填充，比如1就代表图像外围加一圈，默认填充的是0.

• padding_mode (string, optional) – 填充模式，“零”、“反射”、“复制”或“圆形”。 默认值：‘零’.

• dilation (int or tuple, optional) – 内核元素之间的间距 空洞卷积,但不常用.

• groups (int, optional) – 从输入通道到输出通道的阻塞连接数。 一般设置为1

• bias (bool, optional) –偏置，如果为 True，则向输出添加可学习的偏差。 默认值：真

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

# 准备数据集
dataset = torchvision.datasets.CIFAR10("../data",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
# transform=torchvision.transforms.ToTensor() 进行数据变换,把数据类型变幻成tensor数据类型

# 把数据集放进 dataloader 进行加载
dataloader =DataLoader(dataset,batch_size=64)

# 搭建简单神经网络
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__()
        # 定义卷积层
        self.conv1 = Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)

    # 定义forward函数 输出为x
    def forward(self,x):
        x = self.conv1(x)
        return x

tudui = Tudui()

# 每张图像放入神经网络中
for data in dataloader:
    imgs,targets = data
    output = tudui(imgs) # imgs 是网络的输入, 将照片放进神经网络中
    print(imgs.shape)
    print(output.shape)

    

运行结果:

19.神经网络-最大池化的使用

最常用的是torch.nn.MaxPool2d

torch.nn.MaxPool2d**(kernel_size, stride=None, padding=0, dilation=1**, return_indices=False, ceil_mode=False)

• Kernel_size – the size of the window to take a max over

  用来取最大值的窗口,取int 如3 就生成3*3的窗口,如果给一个数组(2,3) 就是2*3的池化核

• stride – the stride of the window. Default value is kernel_size

• padding – implicit zero padding to be added on both sides

• dilation – a parameter that controls the stride of elements in the window

• return_indices – if True, will return the max indices along with the outputs. Useful for torch.nn.MaxUnpool2d later,几乎不用

• ceil_mode – when True, will use ceil instead of floor to compute the output shape 使用ceil (向上取值)或者floor(向下取值)模式（True则保留多出来的input，False丢弃,默认为 False。）

最大池化操作, 取池化核覆盖的最大值–(还是看下图吧)

import torch
input = 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]])
input = torch.reshape(input,(-1,1,5,5))
print(input.shape)
"""
output:

torch.Size([1, 1, 5, 5])

"""

import torch
from torch import nn
from torch.nn import MaxPool2d

input = 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]],dtype=torch.float32)
input = torch.reshape(input,(-1,1,5,5))
print(input.shape)

# 搭建神经网络
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__() # 对父类进行一个初始化
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=True)

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

tudui = Tudui()
output = tudui(input)
print(output)
"""
输出:
torch.Size([1, 1, 5, 5])
tensor([[[[2., 3.],
          [5., 1.]]]])
"""

# 把ceil_module改成False
import torch
from torch import nn
from torch.nn import MaxPool2d

input = 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]],dtype=torch.float32)
input = torch.reshape(input,(-1,1,5,5))
print(input.shape)

# 搭建神经网络
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__() # 对父类进行一个初始化
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=False)

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

tudui = Tudui()
output = tudui(input)
print(output)
"""
输出:
torch.Size([1, 1, 5, 5])
tensor([[[[2.]]]])
"""

最大池化的目的:池化：在保留数据特征的情况下减小数据量

上例中,原本是5*5,池化后编程2*2,或者1*1的

# 可视化~
import torch
import torchvision
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("../data",train=False,download=True,
                                       transform=torchvision.transforms.ToTensor())


dataloader = DataLoader(dataset,batch_size=64)

# 搭建神经网络
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__() # 对父类进行一个初始化
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=False)

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

tudui = Tudui()
# output = tudui(input)
# print(output)

writer = SummaryWriter("../logs_maxpool")
step = 0
for data in dataloader:
    imgs,target = data
    writer.add_images("input",imgs,step)
    output = tudui(imgs)
    writer.add_images("output",output,step)
    step += 1

writer.close()

20.神经网络-非线性激活

import torch
from torch import nn
from torch.nn import ReLU

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

output = torch.reshape(input,(-1,1,2,2)) # batch size自己算,channel=1,2*2矩阵
print(output.shape)

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__()
        self.relu1 = ReLU() # 其中的inplace参数是指是否在原位变换 True的时候就变换,默认值为False

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

tudui  = Tudui()
output = tudui(input)
print(output)

'''
输出:
torch.Size([1, 1, 2, 2])
tensor([[1., 0.],
        [0., 3.]])

ps: 就是把＜1的部分变成0 啦~
'''

# 非线性变换 可视化  给网络中引入一些非线性特征
import torch
import torchvision
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter


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

output = torch.reshape(input,(-1,1,2,2)) # batch size自己算,channel=1,2*2矩阵
print(output.shape)

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

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__()
        self.relu1 = ReLU()
        self.sigmoid1 = Sigmoid()

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

tudui  = Tudui()
# output = tudui(input)
# print(output)

writer = SummaryWriter("../logs_relu")
step = 0
for data in dataloader:
    imgs,targets = data
    writer.add_images("input", imgs,global_step=step)
    output = tudui(imgs)
    writer.add_images("output", output,step)
    step += 1

writer.close()

21.神经网络线性层及其他层介绍

1. 正则化层 -BatchNorm2d

   采用正则化可以加快神经网络的训练速度

2. Recurrent Layers

   文字识别常用,是一个固定的网络

3. 线性层

4. Dropout层 防止过拟合 自然语言处理常用

线性层

• 对于上图来说，

  • 第一个线性层中，in_features为d，out_features为L。
  • 第二个线性层中，in_features为L，out_features为m。

• 线性层中涉及两个变量，weight和bias，即上图中的k和b。
  

VGG16 model网络的线性层的实现

import torchvision
from torch.utils.data import DataLoader

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

for data in dataloader:
    imgs,targets =data
    print(imgs.shape)
 '''
 输出:
 torch.Size([64, 3, 32, 32])
torch.Size([64, 3, 32, 32])
torch.Size([64, 3, 32, 32])
torch.Size([64, 3, 32, 32])
torch.Size([64, 3, 32, 32])
torch.Size([64, 3, 32, 32])
... 
 '''

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

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

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__()
        self.linear1 = Linear(in_features=196608,out_features=10)

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

tudui = Tudui()


for data in dataloader:
    imgs,targets =data
    print(imgs.shape)
    # output = torch.reshape(imgs,(1,1,1,-1)) # 展平方法1 展平成 torch.Size([1, 1, 1, 196608])
    output = torch.flatten(imgs)   # 把输入展平方法2  torch.Size([196608])
    print(output.shape)
    output = tudui(output) # 进入线性层网络网络
    print(output.shape)    # torch.Size([1, 1, 1, 10])   用了flatten  torch.Size([10])