pytorch-常用函数

2020-05-20 本文已影响0人一技破万法

卷积层

class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

二维卷积层, 输入的尺度是(N, Cin,H,W)，输出尺度（N,Cout,Hout,Wout）的计算方式：

$out(N_i , C_{out_j}) = bias(C_{out_j})+\sum_{k=0}^{C_{in} - 1} weight(C_{out_j}, k)*input(N_i, k)$
$H_{out} = 「\dfrac{H_{in} + 2*padding[0]-dilationg[0]*(kernel_ size[0]-1) -1}{stride[0]} +1」$
$W_{out}=「\dfrac{W_{in}+2*padding[1]-dilation[1]*(kernel_size[1]-1)-1}{stride[1]}+1」$
weight(tensor)-卷积的权重，大小是(out_channels, in_channels, kernel_size)
bias(tensor)-卷积的偏置系数，大小是(out_channels)
stride：步长
dilation：内核点间距离
groups：输入和输出之间的连接。

group=1输出是输入的所有卷积
group=2相当于有两个并排的卷积层，每个卷积层计算输入通道的一半，产生的输出也是一半，随后将两个输出连接起来。
group=in_channels每个通道和它对应的卷积核进行卷积 $\dfrac{C_{out}}{C_{in}}$

标准化层

class torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True)

对小批量(mini-batch)3d数据组成的4d输入进行批标准化(Batch Normalization)操作
$y = \dfrac{x-E[x]}{\sqrt{Var[x] + \epsilon}}*\gamma+\beta$
num_features： C来自期待的输入大小(N,C,H,W)
eps：即上面式子中分母的ε ，为保证数值稳定性（分母不能趋近或取0）,给分母加上的值。默认为1e-5。
momentum：动态均值和动态方差所使用的动量。默认为0.1。
affine：一个布尔值，当设为true，给该层添加可学习的仿射变换参数，即γ与β。
track_running_stats：一个布尔值，当设置为True时，该模块跟踪运行的平均值和方差，当设置为False时，该模块不跟踪此类统计数据，并且始终在train和eval模式中使用批处理统计数据。默认值:True

池化层

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

$H_{out} = 「\dfrac{H_{in} +2*padding[0]-dilation[0]*(kernel_size[0]-1)-1}{stride[0]}+1」$
$W_{out} = 「\dfrac{W_{in}+2*padding[1]-dilation[1]*kernel_size[1]-1)-1}{stride[1]}+1」$

kernel_size(int or tuple) - max pooling的窗口大小
stride(int or tuple, optional) - max pooling的窗口移动的步长。默认值是kernel_size
padding(int or tuple, optional) - 输入的每一条边补充0的层数
dilation(int or tuple, optional) – 一个控制窗口中元素步幅的参数
return_indices - 如果等于True，会返回输出最大值的序号，对于上采样操作torch.nn.MaxUnpool2d会有帮助
ceil_mode - 如果等于True，计算输出信号大小的时候，会使用向上取整ceil，代替默认的向下取整floor的操作

class torch.nn.AdaptiveAvgPool2d(output_size)

对输入信号，提供2维的自适应平均池化操作
Adaptive Pooling特殊性在于：
输出张量的大小都是给定的output_size。
例如输入张量大小为(1, 64, 8, 9)，设定输出大小为(5,7)，通过Adaptive Pooling层，可以得到大小为(1, 64, 5, 7)的张量
对于任何输入大小的输入，可以将输出尺寸指定为H*W，但是输入和输出特征的数目不会变化。
output_size:输出信号的尺寸，(H,W)

非线性激活函数

class torch.nn.ReLU(inplace=False)

{ReLU}(x)= max(0, x)
inplace-选择是否进行原位运算

class torch.nn.LeakyReLU(negative_slope=0.01, inplace=False)

给所有负值赋予一个非零斜率。
$LeakyRELU(x) = max(0,x)+negative_slope*min(0,x)$
negative_slope:控制负斜率的角度
inplace:选择是否进行原位运算

class torch.nn.Sigmoid

输出值范围[0, 1]
$Sigmoid(x)=\dfrac{1}{1+e^{(-x)}}$

class torch.nn.Tanh

输出值范围[-1, 1]
$Tanh(x) = tanh(x) = \dfrac{e^x - e^{-z}}{e^x+e{-z}}$

损失函数

nn.CrossEntropyLoss() #多用于多分类问题的交叉熵。
$loss(x,class) = -log\dfrac{e^{(x[class])}}{\sum_{j}e^{(x[j])}} = -x[class] + log(\sum_j e^{(x[j])})$
若含有权重函数，则公式为：
$loss(x,class) = weight[class](-x[class] + log(\sum_j e^{(x[j])}))$

优化函数

class torch.nn.Dropout(0.25)

这里的0.25指的是该层的神经元在每次迭代训练时会随机有25%的可能性会失活。

模型修改

nn.Sequential(*list(model.children())[:-1})

将model的最后一层去掉

GPU使用

使用.cuda()将模型和对应的数据从内存中复制到GPU的显存中去，从而通过GPU运行。

判断使用GPU

torch.cuda.is_available()

通过函数的返回值判断是否有GPU可以使用。

torch.cuda.device_count()

通过函数获取CPU能够使用的数量。
通过如下判断来写可以跑在GPU和CPU的通用模型：

if torch.cuda.is_Available():
  tensor = tensor.cuda()
  model = model.cuda()

数据返回cpu

在data后面加.cpu()

torch.range()和torch.arange()函数

torch.range(start=1, end=6)的结果包含6，返回的是一个torch.float64类型的tensor。
torch.arange(start=1, end=6)的结果不包含6，并且返回的是一个torch.int64类型的tensor。
tensor.view(1,6) 将结果转化为1行6列的tensor

torch.expand()

扩大tensor为更高维

torch.cat((a,b),0)

将a,b按维度0拼接（竖行），若是1则为横行。

torch.from_numpy()

将numpy.ndarray()转换为pytorch的tensor。返回的张量tensor和numpy的ndarray共享同一内存空间。修改一个会导致另外一个也被修改。返回的张量不能改变大小。

torch.nonzero()

输出非零元素的坐标位置。

Variable

Variable计算时，默认后台搭建计算图，将所有计算步骤连接起来，然后在进行误差反向传播的时候将所有Variable中的修改梯度都计算出来，Tensor没有这个功能！

获取variable中的数据

要获取Variable形式的数据，首先要转换成tensor形式，即：print(variable.data)或者是variable.data.numpy()

提取参数

nn.Module中有两个特别重要的关于参数的属性，分别是named_parameters()和parameters()。前一个是给出网络层的名字和参数的迭代器，parameters()会给出一个网络的全部参数的迭代器。
使用named_parameters()可以迭代打印元素的名字和param。

nn,DataParallel()

多机器分布式训练，插眼

tensorboardX

自动记录数据作图，本质是tensorflow里面的board。

调用

from tensorboardX import SummaryWriter
writer = SummaryWriter('log')

writer就相当于一个日志，保存要做图的所有信息，并且建一个文件夹log，存放画图用的文件。
训练的循环中，每次写入图像名称，loss数值，n_iteration

writer.add_scalar('Train/loss',loss.data[0],niter)

验证的循环中，写入预测的准确度：

writer.add_scalar('Test/Accu',correct/total, niter)
#####################################
def train_eval(epoch):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data
inputs, labels = Variable(inputs), Variable(labels)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.data[0]
#每2000个batch显示一次当前的loss和accu
if i % 2000 == 1999:
print('[epoch: %d, batch: %5d] loss: %.3f' %
(epoch + 1, i+1, running_loss / 2000))
running_loss = 0.0
print('[epoch: %d, batch: %5d] Accu: %.3f' %(epoch + 1, i+1, correct/total))

#每10个batch画个点用于loss曲线
if i % 10 == 0:
niter = epoch * len(trainloader) + i
writer.add_scalar('Train/Loss', loss.data[0], niter)

#每500个batch全验证集检测，画个点用于Accu
if i % 500 == 0:
correct = 0
total = 0
for data in testloader:
images, target = data
res = net(Variable(images))
_, predicted = torch.max(res.data, 1)
total += labels.size(0)
correct += (predicted == target).sum()
writer.add_scalar('Test/Accu', correct/total, niter)

显示
命令行输入：

tensorboard --logdir=./log

浏览器输入：

http://0.0.0.0:6006/

前向传播函数forward

神经网络的运行模式如下：

定义网络结构
数据集输入
处理输入，主要为foward函数
计算loss
反向传播求梯度
根据梯度改变参数值
在forward函数过程，以一个module为例：
调用module的call方法
module的call里面调用module的forward方法
forward里面如果有Module的子类，回到第1步，如果碰到Function的子类，往下
调用Function的call方法
Function的call方法调用forward方法
Function的forward返回值
module的forward返回值
在module的call进行forward_hook操作，然后返回值

torch.Tensor.premute(python method, in torch.Tensor)

将各个维度互相转换。

block.parameters()

Parameters:Variable模块的一种，常用于模块参数。Parameters 是 Variable 的子类。Paramenters和Modules一起使用的时候会有一些特殊的属性，即：当Paramenters赋值给Module的属性的时候，他会自动的被加到 Module的参数列表中(即：会出现在 parameters() 迭代器中)。将Varibale赋值给Module属性则不会有这样的影响。这样做的原因是：我们有时候会需要缓存一些临时的状态(state), 比如：模型中RNN的最后一个隐状态。如果没有Parameter这个类的话，那么这些临时变量也会注册成为模型变量。
Variable 与 Parameter的另一个不同之处在于，Parameter不能被 volatile(即：无法设置volatile=True)而且默认requires_grad=True。Variable默认requires_grad=False。
参数说明:
data (Tensor) – parameter tensor.
requires_grad (bool, optional) – 默认为True，在BP的过程中会对其求微分。

torch.utils.model_zoo

torch.utils.model_zoo.load_url(url, model_dir=None)

在给定URL上加载Torch序列化对象。
如果对象已经存在于 model_dir 中，则将被反序列化并返回。URL的文件名部分应遵循命名约定filename-<sha256>.ext，其中<sha256>是文件内容的SHA256哈希的前八位或更多位数字。哈希用于确保唯一的名称并验证文件的内容。
model_dir 的默认值为TORCH_HOME/models，其中TORCH_HOME默认为~/.torch。可以使用TORCH_MODEL_ZOO环境变量来覆盖默认目录。
参数：

url (string) - 要下载对象的URL
model_dir (string, optional) - 保存对象的目录

torch.backends.cudnn.benchmark=True

设置 torch.backends.cudnn.benchmark=True 将会让程序在开始时花费一点额外时间，为整个网络的每个卷积层搜索最适合它的卷积实现算法，进而实现网络的加速。适用场景是网络结构固定（不是动态变化的），网络的输入形状（包括 batch size，图片大小，输入的通道）是不变的，其实也就是一般情况下都比较适用。反之，如果卷积层的设置一直变化，将会导致程序不停地做优化，反而会耗费更多的时间。

torch.nn.init.normal(tensor, mean=0, std=1)

从给定均值和标准差的正态分布N(mean, std)中生成值，填充输入的张量或变量

参数：

tensor – n维的torch.Tensor
mean – 正态分布的均值
std – 正态分布的标准差

例子

>>> w = torch.Tensor(3, 5)
>>> nn.init.normal(w)