internship

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.