blog

Welcome to my blog!

pytorch面经

ab's Avatar 2023-09-25 internship

分享本文
  1. 1. 1.conv2d的参数以及含义
  2. 2. 2.pytorch如何微调fine tuning
  3. 3. 3.pytorch使用多gpu
  4. 4. 4.torch.nn
  5. 5. 5.Sequential的三种写法
  6. 6. 6.tips
  7. 7. 7.torch.optim
  8. 8. 8.对于不同网络设置不同的学习率
  9. 9. 9.修改学习率的方法
  10. 10. 10.nn.functional中的函数和nn.Module主要区别
  11. 11. 11.将Module放在gpu上运行只需两步：分别将模型与数据放在gpu上
  12. 12. 12.在多个gpu上并行计算
  13. 13. 13.torchvision，
  14. 14. 14.PIL Image的操作
  15. 15. 15.ImageFolder:假设所有的文件按文件夹保存，每个文件夹下存储同一个类别图片，文件夹名为类名
  16. 16. 16.DataLoader函数：对batch的数据进行操作，同时还需要对数据进行shuffle和并行加速
  17. 17. 17.pytorch数据增加一个维度用什么函数：unsequeeze()
  18. 18. 18.pytorch是什么
  19. 19. 19.PyTorch 的基本要素
  20. 20. 20.张量
  21. 21. 21.抽象级别
  22. 22. 22.MSELoss、CTCLoss、BCELoss函数有什么用？
  23. 23. 23.反向传播是什么
  24. 24. 24.pytorch多卡训练原理
  25. 25. 25.pytorch中train和eval有什么不同
  26. 26. 26.如何确定cnn的卷积核通道数和卷积输出的通道数
  27. 27. 27.cnn的池化pool层
  28. 28. 28.生成对抗网络
  29. 29. 29.cnn
  30. 30. 30.为什么引入非线性激励函数
  31. 31. 31.batch_size如何影响正确率
  32. 32. 32.

1.conv2d的参数以及含义

  • 1.in_channels (int) – 输入图像中的通道数
  • 2.out_channels (int) – 由卷积产生的通道数=卷积核的数量
  • 3.kernel_size (int or tuple) – 卷积核的大小
  • 4.stride (int or tuple, optional) – 卷积的步幅. Default: 1
  • 4.padding (int, tuple or str, optional) – 填充添加到输入的所有四个边，边界补0的层数. Default: 0 (控制卷积层输出;避免信息丢失)
  • 5.padding_mode (str, optional) – ‘zeros’, ‘reflect’, ‘replicate’ or ‘circular’. Default: ‘zeros’
  • 6.dilation (int or tuple, optional) – 核元素间距. Default: 1
  • 7.groups (int, optional) – 分组卷积的分组数量. Default: 1
  • 8.bias (bool, optional) – 如果为True，则在输出中添加一个可学习的偏差. Default: True

2.pytorch如何微调fine tuning

局部微调：加载了模型参数后，只想调节最后几层，其它层不训练，也就是不进行梯度计算，pytorch提供的requires_grad使得对训练的控制变得非常简单

1
2
3
4
5
6
7
8
9
model = torchvision.models.resnet18(pretrained=True)
for param in model.parameters():
    param.requires_grad = False
# 替换最后的全连接层， 改为训练100类
# 新构造的模块的参数默认requires_grad为True
model.fc = nn.Linear(512, 100)
 
# 只优化最后的分类层
optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9)

全局微调：对全局微调时，只不过我们希望改换过的层和其他层的学习速率不一样，这时候把其它层和新层在optimizer中单独赋予不同的学习速率。

1
2
3
4
5
6
7
8
9
ignored_params = list(map(id, model.fc.parameters()))
base_params = filter(lambda p: id(p) not in ignored_params,
                     model.parameters())
 
optimizer = torch.optim.SGD([
            {'params': base_params},
            {'params': model.fc.parameters(), 'lr': 1e-3}
            ], lr=1e-2, momentum=0.9)

3.pytorch使用多gpu

model.gpu() 把模型放在gpu上

model = nn . DataParallel ( model ) 。DataParallel并行的方式，是将输入一个batch的数据均分成多份，分别送到对应的GPU进行计算，各个GPU得到的梯度累加。与Module相关的所有数据也都会以浅复制的方式复制多份，在此需要注意，在module中属性应该是只读的。
对模型和相应的数据进行.cuda()处理，可以将内存中的数据复制到gpu显存中去

1
2
3
4
5
6
7
8
9
model = Model(input_size, output_size)
if torch.cuda.device_count() > 1:
  print("Let's use", torch.cuda.device_count(), "GPUs!")
  # dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs
  model = nn.DataParallel(model)
 
if torch.cuda.is_available():
   model.cuda()

4.torch.nn

torch.nn:

  • 核心数据结构是Module,抽象的概念，既可以表示神经网络某个层layer，也可以表示一个包含很多层的神经网络。常见做法是继承nn.Module,编写自己的层。
  • 自定义层必须继承nn.Module，并且在其构造函数中需调用nn.Module的构造函数，super(xx,self).init()
  • 在构造函数__init__中必须自定义可学习的参数，并封装成Parameter
  • forward函数实现前向传播过程，其输入可以是一个或者多个tensor。无需写反向传播函数，nn.Module能够利用autograd自动实现反向传播，这比function简单的多
  • Module中可学习参数可以通过named_parameters()或者parameters()返回迭代器，前者会给每个parameter附上名字，使其更具有辨识度。
  • pytorch实现了大部分的layer,这些layer都继承于nn.Module
    • nn.conv2d卷积层
    • AvgPool,Maxpool,AdaptiveAvgPool
    • TransposeConv逆卷积
    • nn.Linear全连接层
    • nn.BatchNorm1d(1d,2d,3d)
    • nn.dropout
    • nn.ReLU
    • nn.Sequential

5.Sequential的三种写法

1
2
3
4
5
net1 = nn.Sequential()
net1.add_module('conv', nn.Conv2d(3, 3, 3))
net1.add_module('batchnorm', nn.BatchNorm2d(3))
net1.add_module('activation_layer', nn.ReLU())

1
2
3
4
5
net2 = nn.Sequential(
        nn.Conv2d(3, 3, 3),
        nn.BatchNorm2d(3),
        nn.ReLU()
        )
1
2
3
4
5
6
7
8

from collections import OrderedDict
net3= nn.Sequential(OrderedDict([
          ('conv1', nn.Conv2d(3, 3, 3)),
          ('bn1', nn.BatchNorm2d(3)),
          ('relu1', nn.ReLU())
        ]))

6.tips

  • nn.ModuleList（），可以包含几个子module，可以像list一样使用它，但不能直接把输入传给MuduleList
  • nn.LSTM(4,3,1) 输入向量4维，隐藏元3,1层 nn.LSTMCell(4,3) 对应层数只能是一层
  • nn.Embedding(4,5)4个词，每个词使用5个向量表示
  • 损失函数也是nn.Module的子类。nn.CrossEntropLoss() loss = criterion(score,label)

7.torch.optim

将深度学习常用优化方法全部封装在torch.optim中，所有优化方法继承基类optim.

  • optimizer = optim.SGD(param=net.parameters(),lr=1)
  • optimizer.zero_grad() #梯度清零，等价于net.zero_grad()
  • input = t.randn(1,3,32,32)
  • output = net(input)
  • output.backward(output)
  • optimizer.step()

8.对于不同网络设置不同的学习率

1
2
3
4
5
6
7
8
9
10
11
# 只为两个全连接层设置较大的学习率，其余层的学习率较小
special_layers = nn.ModuleList([net.classifier[0], net.classifier[3]])
special_layers_params = list(map(id, special_layers.parameters()))
base_params = filter(lambda p: id(p) not in special_layers_params,
                     net.parameters())
 
optimizer = t.optim.SGD([
            {'params': base_params},
            {'params': special_layers.parameters(), 'lr': 0.01}
        ], lr=0.001 )

9.修改学习率的方法

  • 修改optimizer.param_groups中的lr
  • 新建优化器
1
2
3
4
5
6
7
8
9
10
11
# 方法1: 调整学习率，新建一个optimizer
old_lr = 0.1
optimizer1 =optim.SGD([
                {'params': net.features.parameters()},
                {'params': net.classifier.parameters(), 'lr': old_lr*0.1}
            ], lr=1e-5)
 
# 方法2: 调整学习率, 手动decay, 保存动量
for param_group in optimizer.param_groups:
    param_group['lr'] *= 0.1 # 学习率为之前的0.1倍

10.nn.functional中的函数和nn.Module主要区别

  • nn.Module实现的layers是一个特殊的类，都是有class layer(nn.Module)定义，会自动提取可学习的参数
  • nn.functional中的函数更像是纯函数，由def function(input)定义
    也就是说如果模型有可学习的参数，最好用nn.Module否则使用哪个都可以，二者在性能上没多大差异，
    对于卷积，全连接等具有可学习参数的网络建议使用nn.Module
    激活函数（ReLU,sigmoid,tanh），池化等可以使用functional替代。对于不具有可学习参数的层，将他们用函数代替，这样可以不用放在构造函数__init__中。

11.将Module放在gpu上运行只需两步：分别将模型与数据放在gpu上

1
2
model=model.cuda()  #将模型的所有参数转到gpu
input.cuda()   #将输入数据也放置到GPU上

12.在多个gpu上并行计算

13.torchvision，

视觉工具包，提供了很多视觉图像处理的工具，其中transforms模块提供了对PIL Image对象和Tensor对象的常用操作。主要包含三部分：

  • models：提供深度学习中各种经典网络的网络结构以及预训练好的模型，包括AlexNet、VGG系列、ResNet系列、Inception系列等。
  • datasets： 提供常用的数据集加载，设计上都是继承torhc.utils.data.Dataset，主要包括MNIST、CIFAR10/100、ImageNet、COCO等。
  • transforms：提供常用的数据预处理操作，主要包括对Tensor以及PIL Image对象的操作。

14.PIL Image的操作

  • Scale:调整图片大小，长宽比保持不变
  • CenterCrop,RandomCrop,RandomResizedCrop : 裁剪图片
  • Pad：填充
  • ToTensor: 将PIL Image对象转成Tensor，会自动将[0,255]归一化至[0,1]

15.ImageFolder:假设所有的文件按文件夹保存，每个文件夹下存储同一个类别图片，文件夹名为类名

ImageFolder(root, transform=None, target_transform=None, loader=default_loader)

  • root：在root指定的路径下寻找图片
  • transform：对PIL Image进行的转换操作，transform的输入是使用loader读取图片的返回对象
  • target_transform：对label的转换
  • loader：给定路径后如何读取图片，默认读取为RGB格式的PIL Image对象

16.DataLoader函数：对batch的数据进行操作，同时还需要对数据进行shuffle和并行加速

DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, num_workers=0, collate_fn=default_collate, pin_memory=False, drop_last=False)

  • dataset：加载的数据集(Dataset对象)
  • batch_size：batch size
  • shuffle:：是否将数据打乱
  • sampler： 样本抽样，后续会详细介绍
  • num_workers：使用多进程加载的进程数，0代表不使用多进程
  • collate_fn： 如何将多个样本数据拼接成一个batch，一般使用默认的拼接方式即可
  • pin_memory：是否将数据保存在pin memory区，pin memory中的数据转到GPU会快一些
  • drop_last：dataset中的数据个数可能不是batch_size的整数倍，drop_last为True会将多出来不足一个batch的数据丢弃

17.pytorch数据增加一个维度用什么函数：unsequeeze()

18.pytorch是什么

PyTorch 是基于 Torch 库的计算机软件的一部分，它是 Python 的开源机器学习库。它是由 Facebook 人工智能研究小组开发的深度学习框架。它用于自然语言处理和计算机视觉等应用。

19.PyTorch 的基本要素

  • PyTorch 张量
  • PyTorch NumPy
  • 数学运算
  • Autograd 模块
  • 优化模块
  • nn 模块

20.张量

张量在 PyTorch 的深度学习中发挥着重要作用。简单来说，我们可以说，这个框架完全是基于张量的。张量被视为广义矩阵。它可以是 1D 张量（矢量）、2D 张量（矩阵）、3D 张量（立方体）或 4D 张量（立方体矢量）。

21.抽象级别

  • 张量：在gpu上运行的n维数组
  • 变量：计算图中的一个节点，存储数据和梯度
  • 模块：神经网络层讲存储状态

22.MSELoss、CTCLoss、BCELoss函数有什么用？

  • MSE 代表 Mean Squared Error，它用于创建衡量输入 x 和目标 y 中每个元素之间的均方误差的标准。
  • CTCLoss代表Connectionist Temporal Classification Loss，用于计算连续时间序列和目标序列之间的损失。
  • BCELoss(Binary Cross Entropy) 用于创建衡量目标和输出之间的二元交叉熵的标准。

23.反向传播是什么

计算出输出与标签间的损失函数值，然后计算其相对于每个神经元的梯度，根据梯度方向更新权值。

  • 将训练集数据输入到ANN的输入层，经过隐藏层，最后达到输出层并输出结果，这是ANN的前向传播过程；
  • 由于ANN的输出结果与实际结果有误差，则计算估计值与实际值之间的误差，并将该误差从输出层向隐藏层反向传播，直至传播到输入层；
  • 在反向传播的过程中，根据误差调整各种参数的值；不断迭代上述过程，直至收敛。

24.pytorch多卡训练原理

  • （1）将模型加载到一个指定的主GPU上，然后将模型浅拷贝到其它的从GPU上；
  • （2）将总的batch数据等分到不同的GPU上（坑：需要先将数据加载到主GPU上）；
  • （3）每个GPU根据自己分配到的数据进行forward计算得到loss，并通过backward得到权重梯度；
  • （4）主GPU将所有从GPU得到的梯度进行合并并用于更新模型的参数。

模型方面：

1
2
3
4
device_ids = [0, 1, 2, 3]
model = Model(input_size, output_size)
model = nn.DataParallel(model, device_ids=device_ids) #单卡没有这行代码
model = model.cuda(device_ids[1]) #指定哪块卡为主GPU，默认是0卡

数据方面：

1
2
3
for data in data_loader:
    input_var = Variable(data.cuda(device_ids[1])) #默认指定用0卡先加载数据就会报错
    output = model(input_var)

25.pytorch中train和eval有什么不同

  • (1). model.train()——训练时候启用
    启用 BatchNormalization 和 Dropout，将BatchNormalization和Dropout置为True
  • (2). model.eval()——验证和测试时候启用
    不启用 BatchNormalization 和 Dropout，将BatchNormalization和Dropout置为False

train模式会计算梯度，eval模式不会计算梯度。

26.如何确定cnn的卷积核通道数和卷积输出的通道数

cnn卷积核通道数=卷积输入层通道数

cnn卷积输出层通道数=卷积核个数

27.cnn的池化pool层

池化，简言之，即取区域平均或最大

28.生成对抗网络

GAN之所以是对抗的，是因为GAN的内部是竞争关系，一方叫generator，它的主要工作是生成图片，并且尽量使得其看上去是来自于训练样本的。另一方是discriminator，其目标是判断输入图片是否属于真实训练样本。

生成对抗网络的一个简单解释如下：假设有两个模型，一个是生成模型(Generative Model,下文简写为G)，一个是判别模型(Discriminative Model,下文简写为D)，判别模型(D)的任务就是判断一个实例是真实的还是由模型生成的，生成模型(G)的任务是生成一个实例来骗过判别模型(D) ，两个模型互相对抗，发展下去就会达到一个平衡，生成模型生成的实例与真实的没有区别，判别模型无法区分自然的还是模型生成的。

29.cnn

每个输入特征的组合特征

30.为什么引入非线性激励函数

深度学习的前提是神经网络的隐层加上了非线性激活函数，提升了模型的非线性表达能力，使得神经网络可以逼近任意复杂的函数。

31.batch_size如何影响正确率

运行时间确实随着批大小的增加而下降。然而，这导致了测试正确率的妥协，因为测试正确率随着批大小的增加而单调递减。

32.

本文最后更新于 天前，文中所描述的信息可能已发生改变

本文发表于 

internship